1 /*
2  * Copyright (C) 2021 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 "stk_controller.h"
17 
18 #include "ability_manager_client.h"
19 #include "bundle_mgr_proxy.h"
20 #include "common_event_data.h"
21 #include "common_event_manager.h"
22 #include "common_event_publish_info.h"
23 #include "common_event_support.h"
24 #include "extension_ability_info.h"
25 #include "tel_ril_types.h"
26 #include "if_system_ability_manager.h"
27 #include "iservice_registry.h"
28 #include "parameters.h"
29 #include "radio_event.h"
30 #include "system_ability_definition.h"
31 #include "telephony_errors.h"
32 #include "telephony_log_wrapper.h"
33 #include "telephony_ext_wrapper.h"
34 
35 namespace OHOS {
36 namespace Telephony {
37 namespace {
38 const int32_t ICC_CARD_STATE_ABSENT = 0;
39 const int32_t ICC_CARD_STATE_PRESENT = 1;
40 const int32_t WAIT_TIME_SECOND = 2; // Set the timeout for sending the stk command
41 const int32_t PARAMETER_LENGTH = 128;
42 const int64_t DELAY_TIME = 3000;
43 const int32_t MAX_RETRY_COUNT = 10;
44 const int32_t REFRESH_RESULT_FILE_UPDATE = 0;
45 const std::string PARAM_SLOTID = "slotId";
46 const std::string PARAM_MSG_CMD = "msgCmd";
47 const std::string PARAM_CARD_STATUS = "cardStatus";
48 const std::string PARAM_ALPHA_STRING = "alphaString";
49 const std::string PARAM_REFRESH_RESULT = "refreshResult";
50 const std::string STK_BUNDLE = "const.telephony.stk_bundle_name";
51 const std::string ABILITY_NAME = "ServiceExtAbility";
52 const std::string DEFAULT_BUNDLE = "";
53 } // namespace
54 
StkController(const std::weak_ptr<Telephony::ITelRilManager> & telRilManager,const std::weak_ptr<Telephony::SimStateManager> & simStateManager,int32_t slotId)55 StkController::StkController(const std::weak_ptr<Telephony::ITelRilManager> &telRilManager,
56     const std::weak_ptr<Telephony::SimStateManager> &simStateManager, int32_t slotId)
57     : TelEventHandler("StkController"), telRilManager_(telRilManager), simStateManager_(simStateManager),
58       slotId_(slotId)
59 {}
60 
~StkController()61 StkController::~StkController()
62 {
63     UnSubscribeListeners();
64 }
65 
Init()66 void StkController::Init()
67 {
68     stkBundleName_ = initStkBudleName();
69     RegisterEvents();
70     if (TELEPHONY_EXT_WRAPPER.initBip_ != nullptr) {
71         TELEPHONY_EXT_WRAPPER.initBip_(slotId_);
72     }
73     InitListener();
74 }
75 
UnSubscribeListeners()76 void StkController::UnSubscribeListeners()
77 {
78     if (bundleScanFinishedSubscriber_ != nullptr &&
79         CommonEventManager::UnSubscribeCommonEvent(bundleScanFinishedSubscriber_)) {
80         bundleScanFinishedSubscriber_ = nullptr;
81         TELEPHONY_LOGI("Unsubscribe Bundle Scan Finished success");
82     }
83     if (statusChangeListener_ != nullptr) {
84         auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
85         if (samgrProxy != nullptr) {
86             samgrProxy->UnSubscribeSystemAbility(OHOS::COMMON_EVENT_SERVICE_ID, statusChangeListener_);
87             statusChangeListener_ = nullptr;
88             TELEPHONY_LOGI("Unsubscribe COMMON_EVENT_SERVICE_ID success");
89         }
90     }
91 }
92 
InitListener()93 void StkController::InitListener()
94 {
95     auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
96     statusChangeListener_ = new (std::nothrow) SystemAbilityStatusChangeListener(*this);
97     if (samgrProxy == nullptr || statusChangeListener_ == nullptr) {
98         TELEPHONY_LOGE("samgrProxy or statusChangeListener_ is nullptr");
99         return;
100     }
101     auto ret = samgrProxy->SubscribeSystemAbility(COMMON_EVENT_SERVICE_ID, statusChangeListener_);
102     TELEPHONY_LOGI("SubscribeSystemAbility COMMON_EVENT_SERVICE_ID result is %{public}d", ret);
103 }
104 
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)105 void StkController::SystemAbilityStatusChangeListener::OnAddSystemAbility(int32_t systemAbilityId,
106     const std::string &deviceId)
107 {
108     switch (systemAbilityId) {
109         case COMMON_EVENT_SERVICE_ID: {
110             TELEPHONY_LOGI("COMMON_EVENT_SERVICE_ID is running");
111             handler_.SubscribeBundleScanFinished();
112             break;
113         }
114         default:
115             TELEPHONY_LOGE("systemAbilityId is invalid");
116             break;
117     }
118 }
119 
OnRemoveSystemAbility(int32_t systemAbilityId,const std::string & deviceId)120 void StkController::SystemAbilityStatusChangeListener::OnRemoveSystemAbility(int32_t systemAbilityId,
121     const std::string &deviceId)
122 {
123     switch (systemAbilityId) {
124         case COMMON_EVENT_SERVICE_ID: {
125             handler_.UnSubscribeListeners();
126             TELEPHONY_LOGI("COMMON_EVENT_SERVICE_ID stopped");
127             break;
128         }
129         default:
130             TELEPHONY_LOGE("systemAbilityId is invalid");
131             break;
132     }
133 }
134 
SubscribeBundleScanFinished()135 void StkController::SubscribeBundleScanFinished()
136 {
137     if (bundleScanFinishedSubscriber_ != nullptr) {
138         TELEPHONY_LOGW("Bundle Scan Finished has Subscribed");
139         return;
140     }
141     MatchingSkills matchingSkills;
142     matchingSkills.AddEvent(BUNDLE_SCAN_FINISHED_EVENT);
143     CommonEventSubscribeInfo subscriberInfo(matchingSkills);
144     subscriberInfo.SetThreadMode(CommonEventSubscribeInfo::COMMON);
145     bundleScanFinishedSubscriber_ = std::make_shared<BundleScanFinishedEventSubscriber>(subscriberInfo, *this);
146     if (CommonEventManager::SubscribeCommonEvent(bundleScanFinishedSubscriber_)) {
147         TELEPHONY_LOGI("Subscribe Bundle Scan Finished success");
148     } else {
149         bundleScanFinishedSubscriber_ = nullptr;
150         TELEPHONY_LOGE("Subscribe Bundle Scan Finished fail");
151     }
152 }
153 
OnReceiveEvent(const CommonEventData & data)154 void StkController::BundleScanFinishedEventSubscriber::OnReceiveEvent(const CommonEventData &data)
155 {
156     OHOS::EventFwk::Want want = data.GetWant();
157     std::string action = want.GetAction();
158     TELEPHONY_LOGI("action = %{public}s", action.c_str());
159     if (action == BUNDLE_SCAN_FINISHED_EVENT) {
160         handler_.OnReceiveBms();
161     }
162 }
163 
OnReceiveBms()164 void StkController::OnReceiveBms()
165 {
166     if (!retryWant_.GetStringParam(PARAM_MSG_CMD).empty() && !isProactiveCommandSucc) {
167         if (remainTryCount_ == 0) {
168             remainTryCount_ = MAX_RETRY_COUNT;
169             TELEPHONY_LOGI("OnReceiveBms retry send stkdata");
170             SendEvent(StkController::RETRY_SEND_RIL_PROACTIVE_COMMAND, 0, DELAY_TIME);
171         } else {
172             remainTryCount_ = MAX_RETRY_COUNT;
173         }
174     }
175 }
176 
initStkBudleName()177 std::string StkController::initStkBudleName()
178 {
179     char bundleName[PARAMETER_LENGTH] = { 0 };
180     GetParameter(STK_BUNDLE.c_str(), DEFAULT_BUNDLE.c_str(), bundleName, PARAMETER_LENGTH);
181     return bundleName;
182 }
183 
GetBundleMgr()184 sptr<OHOS::IRemoteObject> StkController::GetBundleMgr()
185 {
186     OHOS::sptr<OHOS::ISystemAbilityManager> systemAbilityManager =
187         OHOS::SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
188     if (systemAbilityManager == nullptr) {
189         TELEPHONY_LOGE("Failed to get ability mgr.");
190         return nullptr;
191     }
192     return systemAbilityManager->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
193 }
194 
RegisterEvents()195 void StkController::RegisterEvents()
196 {
197     std::shared_ptr<ITelRilManager> telRilManager = telRilManager_.lock();
198     if (telRilManager == nullptr) {
199         TELEPHONY_LOGE("StkController[%{public}d]::RegisterEvents() telRilManager is nullptr", slotId_);
200         return;
201     }
202     std::shared_ptr<SimStateManager> simStateManager = simStateManager_.lock();
203     if (simStateManager == nullptr) {
204         TELEPHONY_LOGE("StkController[%{public}d]::RegisterEvents() simStateManager is nullptr", slotId_);
205         return;
206     }
207     simStateManager->RegisterCoreNotify(shared_from_this(), RadioEvent::RADIO_SIM_STATE_CHANGE);
208     telRilManager->RegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_STK_SESSION_END, nullptr);
209     telRilManager->RegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_STK_PROACTIVE_COMMAND, nullptr);
210     telRilManager->RegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_STK_ALPHA_NOTIFY, nullptr);
211     telRilManager->RegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_STK_EVENT_NOTIFY, nullptr);
212     telRilManager->RegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_STK_CALL_SETUP, nullptr);
213     telRilManager->RegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_ICC_REFRESH, nullptr);
214 }
215 
UnRegisterEvents()216 void StkController::UnRegisterEvents()
217 {
218     std::shared_ptr<ITelRilManager> telRilManager = telRilManager_.lock();
219     if (telRilManager == nullptr) {
220         TELEPHONY_LOGE("StkController[%{public}d]::UnRegisterEvents() telRilManager is nullptr", slotId_);
221         return;
222     }
223     std::shared_ptr<SimStateManager> simStateManager = simStateManager_.lock();
224     if (simStateManager == nullptr) {
225         TELEPHONY_LOGE("StkController[%{public}d]::UnRegisterEvents() simStateManager is nullptr", slotId_);
226         return;
227     }
228     simStateManager->UnRegisterCoreNotify(shared_from_this(), RadioEvent::RADIO_SIM_STATE_CHANGE);
229     telRilManager->UnRegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_STK_SESSION_END);
230     telRilManager->UnRegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_STK_PROACTIVE_COMMAND);
231     telRilManager->UnRegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_STK_ALPHA_NOTIFY);
232     telRilManager->UnRegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_STK_EVENT_NOTIFY);
233     telRilManager->UnRegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_STK_CALL_SETUP);
234     telRilManager->UnRegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_ICC_REFRESH);
235 }
236 
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)237 void StkController::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event)
238 {
239     if (event == nullptr) {
240         TELEPHONY_LOGE("StkController[%{public}d]::ProcessEvent() event is nullptr", slotId_);
241         return;
242     }
243     uint32_t id = event->GetInnerEventId();
244     switch (id) {
245         case RadioEvent::RADIO_SIM_STATE_CHANGE:
246             OnIccStateChanged(event);
247             break;
248         case RadioEvent::RADIO_STK_SESSION_END:
249             OnSendRilSessionEnd(event);
250             break;
251         case RadioEvent::RADIO_STK_PROACTIVE_COMMAND:
252             OnSendRilProactiveCommand(event);
253             break;
254         case RadioEvent::RADIO_STK_ALPHA_NOTIFY:
255             OnSendRilAlphaNotify(event);
256             break;
257         case RadioEvent::RADIO_STK_EVENT_NOTIFY:
258             OnSendRilEventNotify(event);
259             break;
260         case RadioEvent::RADIO_STK_CALL_SETUP:
261             TELEPHONY_LOGI("StkController[%{public}d]::ProcessEvent(),"
262                 " event notify command supplied all the information needed for set up call processing", slotId_);
263             break;
264         case RadioEvent::RADIO_ICC_REFRESH:
265             OnIccRefresh(event);
266             break;
267         case RadioEvent::RADIO_STK_SEND_TERMINAL_RESPONSE:
268             OnSendTerminalResponseResult(event);
269             break;
270         case RadioEvent::RADIO_STK_SEND_ENVELOPE:
271             OnSendEnvelopeCmdResult(event);
272             break;
273         case RadioEvent::RADIO_STK_IS_READY:
274             TELEPHONY_LOGI("StkController[%{public}d]::ProcessEvent() SimStkIsReady done", slotId_);
275             break;
276         case RadioEvent::RADIO_STK_SEND_CALL_SETUP_REQUEST_RESULT:
277             OnSendCallSetupRequestResult(event);
278             break;
279         case StkController::RETRY_SEND_RIL_PROACTIVE_COMMAND:
280             RetrySendRilProactiveCommand();
281             break;
282         default:
283             TELEPHONY_LOGE("StkController[%{public}d]::ProcessEvent() unknown event", slotId_);
284             break;
285     }
286 }
287 
OnIccStateChanged(const AppExecFwk::InnerEvent::Pointer & event)288 void StkController::OnIccStateChanged(const AppExecFwk::InnerEvent::Pointer &event)
289 {
290     std::shared_ptr<SimStateManager> simStateManager = simStateManager_.lock();
291     if (simStateManager == nullptr) {
292         TELEPHONY_LOGE("StkController[%{public}d]::OnIccStateChanged() simStateManager is nullptr", slotId_);
293         return;
294     }
295     int32_t newState = simStateManager->HasSimCard() ? ICC_CARD_STATE_PRESENT : ICC_CARD_STATE_ABSENT;
296     int32_t oldState = iccCardState_;
297     iccCardState_ = newState;
298     TELEPHONY_LOGI("StkController[%{public}d]::OnIccStateChanged(), oldState: %{public}d newState: %{public}d",
299         slotId_, oldState, newState);
300     if (oldState == ICC_CARD_STATE_PRESENT && newState == ICC_CARD_STATE_ABSENT) {
301         AAFwk::Want want;
302         want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_STK_CARD_STATE_CHANGED);
303         want.SetParam(PARAM_SLOTID, slotId_);
304         want.SetParam(PARAM_CARD_STATUS, iccCardState_);
305         bool publishResult = PublishStkEvent(want);
306         TELEPHONY_LOGI("StkController[%{public}d]::OnIccStateChanged() publishResult = %{public}d",
307             slotId_, publishResult);
308     } else if (oldState == ICC_CARD_STATE_ABSENT && newState == ICC_CARD_STATE_PRESENT) {
309         TELEPHONY_LOGI("StkController[%{public}d]::OnIccStateChanged(), call SimStkIsReady()", slotId_);
310         auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_STK_IS_READY);
311         if (event == nullptr) {
312             TELEPHONY_LOGE("StkController[%{public}d]::OnIccStateChanged() event is nullptr", slotId_);
313             return;
314         }
315         event->SetOwner(shared_from_this());
316         std::shared_ptr<ITelRilManager> telRilManager = telRilManager_.lock();
317         if (telRilManager == nullptr) {
318             TELEPHONY_LOGE("StkController[%{public}d]::OnIccStateChanged() telRilManager is nullptr", slotId_);
319             return;
320         }
321         telRilManager->SimStkIsReady(slotId_, event);
322     }
323 }
324 
OnSendRilSessionEnd(const AppExecFwk::InnerEvent::Pointer & event)325 void StkController::OnSendRilSessionEnd(const AppExecFwk::InnerEvent::Pointer &event)
326 {
327     AAFwk::Want want;
328     want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_STK_SESSION_END);
329     want.SetParam(PARAM_SLOTID, slotId_);
330     bool publishResult = PublishStkEvent(want);
331     TELEPHONY_LOGI("StkController[%{public}d]::OnSendRilSessionEnd() publishResult = %{public}d",
332         slotId_, publishResult);
333 }
334 
CheckIsBipCmd(const std::string & cmdData)335 bool StkController::CheckIsBipCmd(const std::string &cmdData)
336 {
337     std::string commandType = cmdData.substr(STK_CMD_TYPE_INDEX, STK_CMD_TYPE_LEN);
338     if (commandType == STK_BIP_CMD_OPEN_CHANNEL || commandType == STK_BIP_CMD_SEND_DATA ||
339         commandType == STK_BIP_CMD_RECEVIE_DATA || commandType == STK_BIP_CMD_GET_CHANNEL_STATUS ||
340         commandType == STK_BIP_CMD_CLOSE_CHANNEL) {
341         if (TELEPHONY_EXT_WRAPPER.sendEvent_ &&
342             TELEPHONY_EXT_WRAPPER.sendEvent_(std::make_shared<std::string>(cmdData), slotId_)) {
343                 TELEPHONY_LOGE("StkController slotId_ [%{public}d] ", slotId_);
344         }
345         return true;
346     }
347     return false;
348 }
349 
OnSendRilProactiveCommand(const AppExecFwk::InnerEvent::Pointer & event)350 void StkController::OnSendRilProactiveCommand(const AppExecFwk::InnerEvent::Pointer &event)
351 {
352     auto stkData = event->GetSharedObject<std::string>();
353     if (stkData == nullptr) {
354         TELEPHONY_LOGE("StkController[%{public}d]::OnSendRilProactiveCommand() stkData is nullptr", slotId_);
355         return;
356     }
357 
358     std::string cmdData = (std::string)*stkData;
359     if (CheckIsBipCmd(cmdData)) {
360         return;
361     }
362 
363     AAFwk::Want want;
364     want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_STK_COMMAND);
365     want.SetParam(PARAM_SLOTID, slotId_);
366     want.SetParam(PARAM_MSG_CMD, cmdData);
367     bool publishResult = PublishStkEvent(want);
368     TELEPHONY_LOGI("StkController[%{public}d]::OnSendRilProactiveCommand() stkData = %{public}s "
369         "publishResult = %{public}d", slotId_, cmdData.c_str(), publishResult);
370     if (!publishResult) {
371         retryWant_ = want;
372         remainTryCount_ = MAX_RETRY_COUNT;
373         SendEvent(StkController::RETRY_SEND_RIL_PROACTIVE_COMMAND, 0, DELAY_TIME);
374         return;
375     }
376     isProactiveCommandSucc = true;
377     remainTryCount_ = 0;
378 }
379 
RetrySendRilProactiveCommand()380 void StkController::RetrySendRilProactiveCommand()
381 {
382     remainTryCount_--;
383     TELEPHONY_LOGI("StkController[%{public}d], remainTryCount_ is %{public}d", slotId_, remainTryCount_);
384     if (remainTryCount_ > 0) {
385         if (!PublishStkEvent(retryWant_)) {
386             SendEvent(StkController::RETRY_SEND_RIL_PROACTIVE_COMMAND, 0, DELAY_TIME);
387             return;
388         }
389         TELEPHONY_LOGI("StkController[%{public}d] retry sucess", slotId_);
390         isProactiveCommandSucc = true;
391         remainTryCount_ = 0;
392         return;
393     }
394     TELEPHONY_LOGI("StkController[%{public}d] stop retry", slotId_);
395 }
396 
OnSendRilAlphaNotify(const AppExecFwk::InnerEvent::Pointer & event)397 void StkController::OnSendRilAlphaNotify(const AppExecFwk::InnerEvent::Pointer &event)
398 {
399     auto alphaData = event->GetSharedObject<std::string>();
400     if (alphaData == nullptr) {
401         TELEPHONY_LOGE("StkController[%{public}d]::OnSendRilAlphaNotify() alphaData is nullptr", slotId_);
402         return;
403     }
404     std::string cmdData = (std::string)*alphaData;
405     AAFwk::Want want;
406     want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_STK_ALPHA_IDENTIFIER);
407     want.SetParam(PARAM_SLOTID, slotId_);
408     want.SetParam(PARAM_ALPHA_STRING, cmdData);
409     bool publishResult = PublishStkEvent(want);
410     TELEPHONY_LOGI("StkController[%{public}d]::OnSendRilAlphaNotify() alphaData = %{public}s "
411         "publishResult = %{public}d", slotId_, cmdData.c_str(), publishResult);
412 }
413 
OnSendRilEventNotify(const AppExecFwk::InnerEvent::Pointer & event)414 void StkController::OnSendRilEventNotify(const AppExecFwk::InnerEvent::Pointer &event)
415 {
416     auto eventData = event->GetSharedObject<std::string>();
417     if (eventData == nullptr) {
418         TELEPHONY_LOGE("StkController[%{public}d]::OnSendRilEventNotify() eventData is nullptr", slotId_);
419         return;
420     }
421     std::string cmdData = (std::string)*eventData;
422     AAFwk::Want want;
423     want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_STK_COMMAND);
424     want.SetParam(PARAM_SLOTID, slotId_);
425     want.SetParam(PARAM_MSG_CMD, cmdData);
426     bool publishResult = PublishStkEvent(want);
427     TELEPHONY_LOGI("StkController[%{public}d]::OnSendRilEventNotify() eventData = %{public}s "
428         "publishResult = %{public}d", slotId_, cmdData.c_str(), publishResult);
429 }
430 
OnIccRefresh(const AppExecFwk::InnerEvent::Pointer & event)431 void StkController::OnIccRefresh(const AppExecFwk::InnerEvent::Pointer &event)
432 {
433     auto refreshResult = event->GetSharedObject<int32_t>();
434     int32_t result = REFRESH_RESULT_FILE_UPDATE;
435     if (refreshResult == nullptr) {
436         TELEPHONY_LOGE("StkController[%{public}d]::OnIccRefresh() refreshResult is nullptr", slotId_);
437     } else {
438         result = (int32_t)*refreshResult;
439     }
440     AAFwk::Want want;
441     want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_STK_CARD_STATE_CHANGED);
442     want.SetParam(PARAM_SLOTID, slotId_);
443     want.SetParam(PARAM_CARD_STATUS, ICC_CARD_STATE_PRESENT);
444     want.SetParam(PARAM_REFRESH_RESULT, result);
445     bool publishResult = PublishStkEvent(want);
446     TELEPHONY_LOGI("StkController[%{public}d]::OnIccRefresh() refresh result = %{public}d publishResult = %{public}d",
447         slotId_, result, publishResult);
448 }
449 
PublishStkEvent(AAFwk::Want & want)450 bool StkController::PublishStkEvent(AAFwk::Want &want)
451 {
452     if (stkBundleName_.empty()) {
453         TELEPHONY_LOGE("stkBundleName_ is empty");
454         return false;
455     }
456     if (!CheckIsSystemApp(stkBundleName_)) {
457         TELEPHONY_LOGE("is not system app");
458         return false;
459     }
460     AppExecFwk::ElementName element("", stkBundleName_, ABILITY_NAME);
461     want.SetElement(element);
462     int32_t accountId = -1;
463     auto ret = AAFwk::AbilityManagerClient::GetInstance()->StartExtensionAbility(
464         want, nullptr, accountId, AppExecFwk::ExtensionAbilityType::SERVICE);
465     return ret == 0;
466 }
467 
CheckIsSystemApp(const std::string & bundleName)468 bool StkController::CheckIsSystemApp(const std::string &bundleName)
469 {
470     sptr<OHOS::IRemoteObject> remoteObject = GetBundleMgr();
471     if (remoteObject == nullptr) {
472         TELEPHONY_LOGE("error to get bundleMgr");
473         return false;
474     }
475     sptr<AppExecFwk::IBundleMgr> iBundleMgr = OHOS::iface_cast<AppExecFwk::IBundleMgr>(remoteObject);
476     if (iBundleMgr == nullptr) {
477         TELEPHONY_LOGE("iBundleMgr is null");
478         return false;
479     }
480     OHOS::AppExecFwk::BundleInfo info;
481     info.applicationInfo.isSystemApp = false;
482     if (!iBundleMgr->GetBundleInfo(
483         bundleName, OHOS::AppExecFwk::GET_BUNDLE_DEFAULT, info, AppExecFwk::Constants::ALL_USERID)) {
484         TELEPHONY_LOGE("Failed to get bundleInfo from bundleMgr");
485     } else {
486         TELEPHONY_LOGI("isSystemApp =%{public}d", info.applicationInfo.isSystemApp);
487     }
488     return info.applicationInfo.isSystemApp;
489 }
490 
SendTerminalResponseCmd(const std::string & strCmd)491 int32_t StkController::SendTerminalResponseCmd(const std::string &strCmd)
492 {
493     auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_STK_SEND_TERMINAL_RESPONSE);
494     if (event == nullptr) {
495         TELEPHONY_LOGE("StkController[%{public}d]::SendTerminalResponseCmd() event is nullptr", slotId_);
496         return TELEPHONY_ERR_LOCAL_PTR_NULL;
497     }
498     event->SetOwner(shared_from_this());
499     std::shared_ptr<ITelRilManager> telRilManager = telRilManager_.lock();
500     if (telRilManager == nullptr) {
501         TELEPHONY_LOGE("StkController[%{public}d]::SendTerminalResponseCmd() telRilManager is nullptr", slotId_);
502         return TELEPHONY_ERR_LOCAL_PTR_NULL;
503     }
504 
505     std::unique_lock<std::mutex> terminalResponselock(stkMutex_);
506     terminalResponseResult_ = 0;
507     responseFinished_ = false;
508     telRilManager->SendTerminalResponseCmd(slotId_, strCmd, event);
509     while (!responseFinished_) {
510         TELEPHONY_LOGI("StkController[%{public}d]::SendTerminalResponseCmd() wait for the response to finish", slotId_);
511         if (stkCv_.wait_for(terminalResponselock, std::chrono::seconds(WAIT_TIME_SECOND)) == std::cv_status::timeout) {
512             TELEPHONY_LOGE("StkController[%{public}d]::SendTerminalResponseCmd() wait timeout", slotId_);
513             break;
514         }
515     }
516     if (!responseFinished_) {
517         TELEPHONY_LOGE("ril cmd fail");
518         return TELEPHONY_ERR_RIL_CMD_FAIL;
519     }
520     return TELEPHONY_SUCCESS;
521 }
522 
SendEnvelopeCmd(const std::string & strCmd)523 int32_t StkController::SendEnvelopeCmd(const std::string &strCmd)
524 {
525     auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_STK_SEND_ENVELOPE);
526     if (event == nullptr) {
527         TELEPHONY_LOGE("StkController[%{public}d]::SendEnvelopeCmd() event is nullptr", slotId_);
528         return TELEPHONY_ERR_LOCAL_PTR_NULL;
529     }
530     event->SetOwner(shared_from_this());
531     std::shared_ptr<ITelRilManager> telRilManager = telRilManager_.lock();
532     if (telRilManager == nullptr) {
533         TELEPHONY_LOGE("StkController[%{public}d]::SendEnvelopeCmd() telRilManager is nullptr", slotId_);
534         return TELEPHONY_ERR_LOCAL_PTR_NULL;
535     }
536 
537     std::unique_lock<std::mutex> envelopelock(stkMutex_);
538     envelopeResponseResult_ = 0;
539     responseFinished_ = false;
540     telRilManager->SendEnvelopeCmd(slotId_, strCmd, event);
541     while (!responseFinished_) {
542         TELEPHONY_LOGI("StkController[%{public}d]::SendEnvelopeCmd() wait for the response to finish", slotId_);
543         if (stkCv_.wait_for(envelopelock, std::chrono::seconds(WAIT_TIME_SECOND)) == std::cv_status::timeout) {
544             TELEPHONY_LOGE("StkController[%{public}d]::SendEnvelopeCmd() wait timeout", slotId_);
545             break;
546         }
547     }
548     if (!responseFinished_) {
549         TELEPHONY_LOGE("ril cmd fail");
550         return TELEPHONY_ERR_RIL_CMD_FAIL;
551     }
552     return TELEPHONY_SUCCESS;
553 }
554 
SendCallSetupRequestResult(bool accept)555 int32_t StkController::SendCallSetupRequestResult(bool accept)
556 {
557     auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_STK_SEND_CALL_SETUP_REQUEST_RESULT);
558     if (event == nullptr) {
559         TELEPHONY_LOGE("StkController[%{public}d]::SendCallSetupRequestResult() event is nullptr", slotId_);
560         return TELEPHONY_ERR_FAIL;
561     }
562     event->SetOwner(shared_from_this());
563     std::shared_ptr<ITelRilManager> telRilManager = telRilManager_.lock();
564     if (telRilManager == nullptr) {
565         TELEPHONY_LOGE("StkController[%{public}d]::SendCallSetupRequestResult() telRilManager is nullptr", slotId_);
566         return TELEPHONY_ERR_FAIL;
567     }
568 
569     std::unique_lock<std::mutex> callSetupRequestlock(stkMutex_);
570     callSetupResponseResult_ = TELEPHONY_ERR_FAIL;
571     responseFinished_ = false;
572     telRilManager->SendCallSetupRequestResult(slotId_, accept, event);
573     while (!responseFinished_) {
574         TELEPHONY_LOGI(
575             "StkController[%{public}d]::SendCallSetupRequestResult() wait for the response to finish", slotId_);
576         if (stkCv_.wait_for(callSetupRequestlock, std::chrono::seconds(WAIT_TIME_SECOND)) == std::cv_status::timeout) {
577             TELEPHONY_LOGE("StkController[%{public}d]::SendCallSetupRequestResult() wait timeout", slotId_);
578             responseFinished_ = true;
579         }
580     }
581     return callSetupResponseResult_;
582 }
583 
OnSendTerminalResponseResult(const AppExecFwk::InnerEvent::Pointer & event)584 void StkController::OnSendTerminalResponseResult(const AppExecFwk::InnerEvent::Pointer &event)
585 {
586     if (event == nullptr) {
587         TELEPHONY_LOGE("StkController[%{public}d]::OnSendTerminalResponseResult() event is nullptr", slotId_);
588         return;
589     }
590     std::shared_ptr<RadioResponseInfo> response = event->GetSharedObject<RadioResponseInfo>();
591     if (response == nullptr) {
592         TELEPHONY_LOGE("StkController[%{public}d]::OnSendTerminalResponseResult() response is nullptr", slotId_);
593         return;
594     }
595     terminalResponseResult_ = response->error == ErrType::NONE;
596     TELEPHONY_LOGI("StkController[%{public}d]::OnSendTerminalResponseResult(), result = %{public}d",
597         slotId_, terminalResponseResult_);
598     responseFinished_ = true;
599     stkCv_.notify_one();
600 }
601 
OnSendEnvelopeCmdResult(const AppExecFwk::InnerEvent::Pointer & event)602 void StkController::OnSendEnvelopeCmdResult(const AppExecFwk::InnerEvent::Pointer &event)
603 {
604     if (event == nullptr) {
605         TELEPHONY_LOGE("StkController[%{public}d]::OnSendEnvelopeCmdResult() event is nullptr", slotId_);
606         return;
607     }
608     std::shared_ptr<RadioResponseInfo> response = event->GetSharedObject<RadioResponseInfo>();
609     if (response == nullptr) {
610         TELEPHONY_LOGE("StkController[%{public}d]::OnSendEnvelopeCmdResult() response is nullptr", slotId_);
611         return;
612     }
613     envelopeResponseResult_ = response->error == ErrType::NONE;
614     TELEPHONY_LOGI("StkController[%{public}d]::OnSendEnvelopeCmdResult(), result = %{public}d",
615         slotId_, envelopeResponseResult_);
616     responseFinished_ = true;
617     stkCv_.notify_one();
618 }
619 
OnSendCallSetupRequestResult(const AppExecFwk::InnerEvent::Pointer & event)620 void StkController::OnSendCallSetupRequestResult(const AppExecFwk::InnerEvent::Pointer &event)
621 {
622     if (event == nullptr) {
623         TELEPHONY_LOGE("StkController[%{public}d]::OnSendCallSetupRequestResult() event is nullptr", slotId_);
624         return;
625     }
626     std::shared_ptr<RadioResponseInfo> response = event->GetSharedObject<RadioResponseInfo>();
627     if (response == nullptr) {
628         TELEPHONY_LOGE("StkController[%{public}d]::OnSendCallSetupRequestResult() response is nullptr", slotId_);
629         return;
630     }
631     callSetupResponseResult_ = response->error == ErrType::NONE ? TELEPHONY_ERR_SUCCESS : TELEPHONY_ERR_FAIL;
632     TELEPHONY_LOGI("StkController[%{public}d]::OnSendCallSetupRequestResult(), result = %{public}d",
633         slotId_, callSetupResponseResult_);
634     responseFinished_ = true;
635     stkCv_.notify_one();
636 }
637 } // namespace Telephony
638 } // namespace OHOS
639