1 /*
2  * Copyright (c) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "ability_manager_client.h"
17 #include "hilog_wrapper.h"
18 #include "ability_connect_callback_stub.h"
19 #include "edm_errors.h"
20 #include "driver_extension_controller.h"
21 namespace OHOS {
22 namespace ExternalDeviceManager {
23 using namespace std;
24 IMPLEMENT_SINGLE_INSTANCE(DriverExtensionController);
25 
26 class DriverExtensionController::DriverExtensionAbilityConnection : public OHOS::AAFwk::AbilityConnectionStub {
27 public:
28     DriverExtensionAbilityConnection() = default;
29     ~DriverExtensionAbilityConnection() = default;
OnAbilityConnectDone(const OHOS::AppExecFwk::ElementName & element,const sptr<IRemoteObject> & remoteObject,int resultCode)30     void OnAbilityConnectDone(
31         const OHOS::AppExecFwk::ElementName &element, const sptr<IRemoteObject> &remoteObject, int resultCode) override
32     {
33         EDM_LOGI(MODULE_EA_MGR,
34             "OnAbilityConnectDone, bundle = %{public}s, ability = %{public}s, resultCode = %{public}d",
35             element.GetBundleName().c_str(), element.GetAbilityName().c_str(), resultCode);
36         remoteObject_ = remoteObject;
37         auto cb = callback_.lock();
38         if (cb != nullptr) {
39             cb->OnConnectDone(remoteObject, resultCode);
40         }
41     }
OnAbilityDisconnectDone(const OHOS::AppExecFwk::ElementName & element,int resultCode)42     void OnAbilityDisconnectDone(
43         const OHOS::AppExecFwk::ElementName &element, int resultCode) override
44     {
45         EDM_LOGI(MODULE_EA_MGR,
46             "OnAbilityDisconnectDone, bundle = %{public}s,ability = %{public}s, resultCode = %{public}d",
47             element.GetBundleName().c_str(), element.GetAbilityName().c_str(), resultCode);
48         remoteObject_ = nullptr;
49         auto cb = callback_.lock();
50         if (cb != nullptr) {
51             cb->OnDisconnectDone(resultCode);
52         }
53     }
54     std::weak_ptr<IDriverExtensionConnectCallback> callback_;
55     sptr<IRemoteObject> remoteObject_;
56 };
57 
GetRemoteObj()58 sptr<IRemoteObject> IDriverExtensionConnectCallback::GetRemoteObj()
59 {
60     return info_->connectInner_->remoteObject_;
61 }
62 
IsConnectDone()63 bool IDriverExtensionConnectCallback::IsConnectDone()
64 {
65     return info_->connectInner_->remoteObject_ != nullptr;
66 }
67 
StartDriverExtension(std::string bundleName,std::string abilityName)68 int32_t DriverExtensionController::StartDriverExtension(
69     std::string bundleName,
70     std::string abilityName)
71 {
72     EDM_LOGI(MODULE_EA_MGR, "Begin to start DriverExtension, bundle:%{public}s, ability:%{public}s", \
73         bundleName.c_str(), abilityName.c_str());
74     auto abmc = AAFwk::AbilityManagerClient::GetInstance();
75     if (abmc == nullptr) {
76         EDM_LOGE(MODULE_EA_MGR, "Get AMC Instance failed");
77         return EDM_ERR_INVALID_OBJECT;
78     }
79     AAFwk::Want want;
80     want.SetElementName(bundleName, abilityName);
81 
82     auto ret = abmc->StartExtensionAbility(want, nullptr);
83     if (ret != 0) {
84         EDM_LOGE(MODULE_EA_MGR, "StartExtensionAbility failed %{public}d", ret);
85         return ret;
86     }
87     EDM_LOGI(MODULE_EA_MGR, "StartExtensionAbility success");
88     return EDM_OK;
89 }
90 
StopDriverExtension(std::string bundleName,std::string abilityName,int32_t userId)91 int32_t DriverExtensionController::StopDriverExtension(
92     std::string bundleName,
93     std::string abilityName,
94     int32_t userId)
95 {
96     EDM_LOGI(MODULE_EA_MGR, "Begin to stop DriverExtension, bundle:%{public}s, ability:%{public}s", \
97         bundleName.c_str(), abilityName.c_str());
98     auto abmc = AAFwk::AbilityManagerClient::GetInstance();
99     if (abmc == nullptr) {
100         EDM_LOGE(MODULE_EA_MGR, "Get AMC Instance failed");
101         return EDM_ERR_INVALID_OBJECT;
102     }
103     AAFwk::Want want;
104     want.SetElementName(bundleName, abilityName);
105     auto ret = abmc->StopExtensionAbility(want, nullptr, userId);
106     if (ret != 0) {
107         EDM_LOGE(MODULE_EA_MGR, "StopExtensionAbility failed %{public}d", ret);
108         return ret;
109     }
110     EDM_LOGI(MODULE_EA_MGR, "StopExtensionAbility success");
111     return EDM_OK;
112 }
ConnectDriverExtension(std::string bundleName,std::string abilityName,std::shared_ptr<IDriverExtensionConnectCallback> callback,uint32_t deviceId)113 int32_t DriverExtensionController::ConnectDriverExtension(
114     std::string bundleName,
115     std::string abilityName,
116     std::shared_ptr<IDriverExtensionConnectCallback> callback,
117     uint32_t deviceId
118 )
119 {
120     EDM_LOGI(MODULE_EA_MGR, "Begin to Connect DriverExtension, bundle:%{public}s, ability:%{public}s", \
121         bundleName.c_str(), abilityName.c_str());
122 
123     if (callback == nullptr) {
124         EDM_LOGE(MODULE_EA_MGR, "param callback is nullptr");
125         return EDM_ERR_INVALID_PARAM;
126     }
127     if (callback->info_ != nullptr) {
128         EDM_LOGE(MODULE_EA_MGR, "callback->info_ is not empty, please use an new callback");
129         return EDM_ERR_INVALID_OBJECT;
130     }
131 
132     callback->info_ = make_shared<DrvExtConnectionInfo>();
133     callback->info_->bundleName_ = bundleName;
134     callback->info_->abilityName_ = abilityName;
135     callback->info_->deviceId_ = deviceId;
136     callback->info_->connectInner_ = new DriverExtensionAbilityConnection();
137     callback->info_->connectInner_->callback_ = callback;
138     auto abmc = AAFwk::AbilityManagerClient::GetInstance();
139     if (abmc == nullptr) {
140         EDM_LOGE(MODULE_EA_MGR, "Get AMC Instance failed");
141         return EDM_ERR_INVALID_OBJECT;
142     }
143     AAFwk::Want want;
144     want.SetElementName(bundleName, abilityName);
145     want.SetParam("deviceId", static_cast<int>(deviceId));
146     auto ret = abmc->ConnectAbility(want, callback->info_->connectInner_, -1);
147     if (ret != 0) {
148         EDM_LOGE(MODULE_EA_MGR, "ConnectExtensionAbility failed %{public}d", ret);
149         return ret;
150     }
151 
152     EDM_LOGI(MODULE_EA_MGR, "ConnectExtensionAbility success");
153     return EDM_OK;
154 }
DisconnectDriverExtension(std::string bundleName,std::string abilityName,std::shared_ptr<IDriverExtensionConnectCallback> callback,uint32_t deviceId)155 int32_t DriverExtensionController::DisconnectDriverExtension(
156     std::string bundleName,
157     std::string abilityName,
158     std::shared_ptr<IDriverExtensionConnectCallback> callback,
159     uint32_t deviceId
160 )
161 {
162     EDM_LOGI(MODULE_EA_MGR, "Begin to Disconnect DriverExtension, bundle:%{public}s, ability:%{public}s", \
163         bundleName.c_str(), abilityName.c_str());
164     if (callback == nullptr) {
165         EDM_LOGE(MODULE_EA_MGR, "param callback is nullptr");
166         return EDM_ERR_INVALID_PARAM;
167     }
168     if (callback->info_ == nullptr) {
169         EDM_LOGE(MODULE_EA_MGR, "param callback->info_ is nullptr");
170         return EDM_ERR_INVALID_PARAM;
171     }
172     if (callback->info_->bundleName_ != bundleName ||
173         callback->info_->abilityName_ != abilityName ||
174         callback->info_->deviceId_ != deviceId) {
175         EDM_LOGE(MODULE_EA_MGR, "bundleName, abilityName, or deviceId not match info in callback");
176         return EDM_ERR_INVALID_OBJECT;
177     }
178     auto abmc = AAFwk::AbilityManagerClient::GetInstance();
179     if (abmc == nullptr) {
180         EDM_LOGE(MODULE_EA_MGR, "Get AMC Instance failed");
181         return EDM_ERR_INVALID_OBJECT;
182     }
183     auto ret = abmc->DisconnectAbility(callback->info_->connectInner_);
184     if (ret != 0) {
185         EDM_LOGE(MODULE_EA_MGR, "DisconnectExtensionAbility failed %{public}d", ret);
186         return ret;
187     }
188     EDM_LOGI(MODULE_EA_MGR, "DisconnectExtensionAbility success");
189     return EDM_OK;
190 }
191 }
192 }