1 /*
2  * Copyright (C) 2021-2022 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 #include "radio_protocol_controller.h"
16 
17 #include "radio_event.h"
18 #include "telephony_log_wrapper.h"
19 
20 namespace OHOS {
21 namespace Telephony {
22 static const int64_t COMMUNICATION_TIMEOUT = 45 * 1000; // Set the timeout millisecond for radio protocol communication
23 static const int64_t SET_ACTIVE_OUT_TIME = 5 * 1000;
24 std::mutex RadioProtocolController::ctx_;
25 std::condition_variable RadioProtocolController::cv_;
26 
RadioProtocolController(std::weak_ptr<Telephony::ITelRilManager> telRilManager)27 RadioProtocolController::RadioProtocolController(std::weak_ptr<Telephony::ITelRilManager> telRilManager)
28     : TelEventHandler("RadioProtocolController"), telRilManager_(telRilManager)
29 {}
30 
Init()31 void RadioProtocolController::Init()
32 {
33     auto telRilManager = telRilManager_.lock();
34     if (telRilManager == nullptr) {
35         TELEPHONY_LOGE("telRilManager is nullptr");
36         return;
37     }
38 
39     slotCount_ = SIM_SLOT_COUNT;
40     InitMemberFunc();
41     // make sure communication is in the initial state
42     CleanUpCommunication();
43     for (int32_t i = 0; i < slotCount_; i++) {
44         RadioProtocol protocol;
45         protocol.slotId = i;
46         protocol.sessionId = 0;
47         protocol.phase = RadioProtocolPhase::RADIO_PROTOCOL_PHASE_INITIAL;
48         protocol.technology = 0xFFFFFFFF;
49         protocol.modemId = 0;
50         protocol.status = RadioProtocolStatus::RADIO_PROTOCOL_STATUS_NONE;
51         radioProtocol_.emplace_back(protocol);
52         telRilManager->RegisterCoreNotify(i, shared_from_this(), RADIO_SIM_RADIO_PROTOCOL_NOTIFY, nullptr);
53     }
54 }
55 
GetRadioProtocolTech(int32_t slotId)56 int32_t RadioProtocolController::GetRadioProtocolTech(int32_t slotId)
57 {
58     std::unique_lock<std::mutex> radioProtocolLock(radioProtocolMutex_);
59     return static_cast<int32_t>(radioProtocol_[slotId].technology);
60 }
61 
GetRadioProtocol(int32_t slotId)62 void RadioProtocolController::GetRadioProtocol(int32_t slotId)
63 {
64     auto telRilManager = telRilManager_.lock();
65     if (telRilManager == nullptr) {
66         TELEPHONY_LOGE("RadioProtocolController::GetRadioProtocol telRilManager is nullptr");
67         return;
68     }
69     AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(RADIO_SIM_GET_RADIO_PROTOCOL);
70     if (event == nullptr) {
71         TELEPHONY_LOGE("RadioProtocolController::GetRadioProtocol event is nullptr");
72         return;
73     }
74     event->SetOwner(shared_from_this());
75     telRilManager->GetRadioProtocol(slotId, event);
76 }
77 
SetRadioProtocol(int32_t slotId)78 bool RadioProtocolController::SetRadioProtocol(int32_t slotId)
79 {
80     if (isCommunicating_) {
81         TELEPHONY_LOGE("RadioProtocolController::SetRadioProtocol protocol is communicating, can not set now");
82         return false;
83     }
84 
85     std::unique_lock<std::mutex> radioProtocolLock(radioProtocolMutex_);
86     communicationResponseResult_ = false;
87     CleanUpCommunication();
88     ExecuteCheckCommunication();
89     while (isCommunicating_) {
90         TELEPHONY_LOGI("RadioProtocolController::SetRadioProtocol wait for the communication to finish");
91         radioProtocolCv_.wait(radioProtocolLock);
92     }
93     return communicationResponseResult_;
94 }
95 
InitMemberFunc()96 void RadioProtocolController::InitMemberFunc()
97 {
98     memberFuncMap_[MSG_SIM_TIME_OUT_ACTIVE] =
99         [this](const AppExecFwk::InnerEvent::Pointer &event) { ProcessActiveSimTimeOutDone(event); };
100     memberFuncMap_[MSG_SIM_SET_ACTIVE] =
101         [this](const AppExecFwk::InnerEvent::Pointer &event) { ProcessActiveSimToRilResponse(event); };
102     memberFuncMap_[RADIO_SIM_GET_RADIO_PROTOCOL] =
103         [this](const AppExecFwk::InnerEvent::Pointer &event) { ProcessGetRadioProtocol(event); };
104     memberFuncMap_[RADIO_SIM_CHECK_RADIO_PROTOCOL] =
105         [this](const AppExecFwk::InnerEvent::Pointer &event) { ProcessCheckRadioProtocol(event); };
106     memberFuncMap_[RADIO_SIM_UPDATE_RADIO_PROTOCOL] =
107         [this](const AppExecFwk::InnerEvent::Pointer &event) { ProcessUpdateRadioProtocol(event); };
108     memberFuncMap_[RADIO_SIM_RADIO_PROTOCOL_NOTIFY] =
109         [this](const AppExecFwk::InnerEvent::Pointer &event) { ProcessRadioProtocolNotify(event); };
110     memberFuncMap_[RADIO_SIM_SET_RADIO_PROTOCOL_COMPLETE] =
111         [this](const AppExecFwk::InnerEvent::Pointer &event) { ProcessSetRadioProtocolComplete(event); };
112     memberFuncMap_[RADIO_SIM_SET_RADIO_PROTOCOL_TIMEOUT] =
113         [this](const AppExecFwk::InnerEvent::Pointer &event) { ProcessSetRadioProtocolTimeout(event); };
114 }
115 
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)116 void RadioProtocolController::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event)
117 {
118     if (event == nullptr) {
119         TELEPHONY_LOGE("RadioProtocolController::ProcessEvent event is nullptr");
120         return;
121     }
122     auto id = event->GetInnerEventId();
123     TELEPHONY_LOGD("RadioProtocolController::ProcessEvent id = %{public}d", id);
124     auto itFunc = memberFuncMap_.find(id);
125     if (itFunc != memberFuncMap_.end()) {
126         auto memberFunc = itFunc->second;
127         if (memberFunc == nullptr) {
128             TELEPHONY_LOGE("RadioProtocolController::ProcessEvent memberFunc is nullptr");
129             return;
130         }
131         memberFunc(event);
132     }
133 }
134 
ProcessGetRadioProtocol(const AppExecFwk::InnerEvent::Pointer & event)135 void RadioProtocolController::ProcessGetRadioProtocol(const AppExecFwk::InnerEvent::Pointer &event)
136 {
137     if (event == nullptr) {
138         TELEPHONY_LOGE("RadioProtocolController::ProcessGetRadioProtocol event is nullptr");
139         return;
140     }
141     std::shared_ptr<RadioProtocol> radioProtocol = event->GetSharedObject<RadioProtocol>();
142     if (radioProtocol == nullptr) {
143         TELEPHONY_LOGE("RadioProtocolController::ProcessGetRadioProtocol radioProtocol is nullptr");
144         return;
145     }
146     UpdateRadioProtocol(radioProtocol);
147 }
148 
ProcessCheckRadioProtocol(const AppExecFwk::InnerEvent::Pointer & event)149 void RadioProtocolController::ProcessCheckRadioProtocol(const AppExecFwk::InnerEvent::Pointer &event)
150 {
151     if (!ProcessResponseInfoOfEvent(event)) {
152         TELEPHONY_LOGE("RadioProtocolController::ProcessCheckRadioProtocol failed due to invalid sessionId");
153         return;
154     }
155 
156     if (--communicatingSlotCount_ != 0) {
157         TELEPHONY_LOGI("RadioProtocolController::ProcessCheckRadioProtocol wait for all sim to complete check");
158         return;
159     }
160 
161     if (communicationFailed_) {
162         ExecuteCompleteCommunication();
163     } else {
164         ExecuteUpdateCommunication();
165     }
166 }
167 
ProcessUpdateRadioProtocol(const AppExecFwk::InnerEvent::Pointer & event)168 void RadioProtocolController::ProcessUpdateRadioProtocol(const AppExecFwk::InnerEvent::Pointer &event)
169 {
170     if (!ProcessResponseInfoOfEvent(event)) {
171         TELEPHONY_LOGE("RadioProtocolController::ProcessUpdateRadioProtocol failed due to invalid sessionId");
172         return;
173     }
174 }
175 
ProcessRadioProtocolNotify(const AppExecFwk::InnerEvent::Pointer & event)176 void RadioProtocolController::ProcessRadioProtocolNotify(const AppExecFwk::InnerEvent::Pointer &event)
177 {
178     if (event == nullptr) {
179         TELEPHONY_LOGE("RadioProtocolController::ProcessRadioProtocolNotify event is nullptr");
180         return;
181     }
182     std::shared_ptr<RadioProtocol> radioProtocol = event->GetSharedObject<RadioProtocol>();
183     if (radioProtocol == nullptr || radioProtocol->sessionId != sessionId_) {
184         TELEPHONY_LOGE("RadioProtocolController::ProcessRadioProtocolNotify failed due to invalid sessionId");
185         return;
186     }
187 
188     if (radioProtocol->status == RadioProtocolStatus::RADIO_PROTOCOL_STATUS_FAIL) {
189         TELEPHONY_LOGE("RadioProtocolController::ProcessRadioProtocolNotify update failed");
190         communicationFailed_ = true;
191     } else {
192         UpdateRadioProtocol(radioProtocol);
193     }
194     if (--communicatingSlotCount_ != 0) {
195         TELEPHONY_LOGI("RadioProtocolController::ProcessRadioProtocolNotify wait for all sim to complete update");
196         return;
197     }
198 
199     ExecuteCompleteCommunication();
200 }
201 
ProcessSetRadioProtocolComplete(const AppExecFwk::InnerEvent::Pointer & event)202 void RadioProtocolController::ProcessSetRadioProtocolComplete(const AppExecFwk::InnerEvent::Pointer &event)
203 {
204     if (event == nullptr) {
205         TELEPHONY_LOGE("RadioProtocolController::ProcessSetRadioProtocolComplete event is nullptr");
206         return;
207     }
208     if (!ProcessResponseInfoOfEvent(event)) {
209         TELEPHONY_LOGE("RadioProtocolController::ProcessSetRadioProtocolComplete failed due to invalid sessionId");
210         return;
211     }
212 
213     if (--communicatingSlotCount_ != 0) {
214         TELEPHONY_LOGI("RadioProtocolController::ProcessSetRadioProtocolComplete wait for all sim to complete");
215         return;
216     }
217 
218     ProcessCommunicationResponse(!communicationFailed_);
219     CleanUpCommunication();
220 }
221 
ProcessSetRadioProtocolTimeout(const AppExecFwk::InnerEvent::Pointer & event)222 void RadioProtocolController::ProcessSetRadioProtocolTimeout(const AppExecFwk::InnerEvent::Pointer &event)
223 {
224     TELEPHONY_LOGI("RadioProtocolController::ProcessSetRadioProtocolTimeout");
225     if (event == nullptr) {
226         TELEPHONY_LOGE("RadioProtocolController::ProcessSetRadioProtocolTimeout event is nullptr");
227         return;
228     }
229     auto sessionId = event->GetParam();
230     if (sessionId != sessionId_) {
231         TELEPHONY_LOGE("RadioProtocolController::ProcessSetRadioProtocolTimeout failed due to invalid sessionId");
232         return;
233     }
234     ProcessCommunicationResponse(false);
235     CleanUpCommunication();
236     sessionId_++;
237     communicatingSlotCount_ = 0;
238     communicationFailed_ = true;
239     ExecuteCompleteCommunication();
240 }
241 
ExecuteCheckCommunication()242 void RadioProtocolController::ExecuteCheckCommunication()
243 {
244     TELEPHONY_LOGI("RadioProtocolController::ExecuteCheckCommunication");
245     sessionId_++;
246     isCommunicating_ = true;
247     SendEvent(RADIO_SIM_SET_RADIO_PROTOCOL_TIMEOUT, sessionId_, COMMUNICATION_TIMEOUT);
248     BuildRadioProtocolForCommunication(RadioProtocolPhase::RADIO_PROTOCOL_PHASE_CHECK,
249         RadioProtocolStatus::RADIO_PROTOCOL_STATUS_NONE);
250     ResetNextCommunicationSlotCount();
251     SendRadioProtocolEvent(oldRadioProtocol_, RADIO_SIM_CHECK_RADIO_PROTOCOL);
252 }
253 
ExecuteUpdateCommunication()254 void RadioProtocolController::ExecuteUpdateCommunication()
255 {
256     std::unique_lock<std::mutex> radioProtocolLock(radioProtocolMutex_);
257     BuildRadioProtocolForCommunication(RadioProtocolPhase::RADIO_PROTOCOL_PHASE_UPDATE,
258         RadioProtocolStatus::RADIO_PROTOCOL_STATUS_NONE);
259     ResetNextCommunicationSlotCount();
260     SendRadioProtocolEvent(newRadioProtocol_, RADIO_SIM_UPDATE_RADIO_PROTOCOL);
261 }
262 
ExecuteCompleteCommunication()263 void RadioProtocolController::ExecuteCompleteCommunication()
264 {
265     std::unique_lock<std::mutex> radioProtocolLock(radioProtocolMutex_);
266     TELEPHONY_LOGI("RadioProtocolController::ExecuteCompleteCommunication failed:%{public}d", communicationFailed_);
267     BuildRadioProtocolForCommunication(RadioProtocolPhase::RADIO_PROTOCOL_PHASE_COMPLETE,
268         communicationFailed_ ? RadioProtocolStatus::RADIO_PROTOCOL_STATUS_FAIL :
269         RadioProtocolStatus::RADIO_PROTOCOL_STATUS_SUCCESS);
270     ResetNextCommunicationSlotCount();
271     SendRadioProtocolEvent(communicationFailed_ ? oldRadioProtocol_ : newRadioProtocol_,
272         RADIO_SIM_SET_RADIO_PROTOCOL_COMPLETE);
273 }
274 
ResetNextCommunicationSlotCount()275 void RadioProtocolController::ResetNextCommunicationSlotCount()
276 {
277     communicatingSlotCount_ = slotCount_;
278 }
279 
BuildRadioProtocolForCommunication(RadioProtocolPhase phase,RadioProtocolStatus status)280 void RadioProtocolController::BuildRadioProtocolForCommunication(RadioProtocolPhase phase, RadioProtocolStatus status)
281 {
282     switch (phase) {
283         case RadioProtocolPhase::RADIO_PROTOCOL_PHASE_CHECK: {
284             if (slotCount_ > static_cast<int32_t>(radioProtocol_.size()) || slotCount_ < 0) {
285                 TELEPHONY_LOGE("error, size = %{public}zu, slotCount_ = %{public}d", radioProtocol_.size(), slotCount_);
286                 break;
287             }
288             for (int32_t i = 0; i < slotCount_; i++) {
289                 RadioProtocol radioProtocol;
290                 radioProtocol.slotId = i;
291                 radioProtocol.sessionId = sessionId_;
292                 radioProtocol.phase = phase;
293                 radioProtocol.technology = radioProtocol_[i].technology;
294                 radioProtocol.modemId = radioProtocol_[i].modemId;
295                 radioProtocol.status = status;
296                 oldRadioProtocol_.emplace_back(radioProtocol);
297                 newRadioProtocol_.emplace_back(radioProtocol);
298             }
299             // Switch the tech and modemId of main and non-main card
300             for (int32_t i = 0; i < slotCount_; i++) {
301                 newRadioProtocol_[i].technology = radioProtocol_[slotCount_ - 1 - i].technology;
302                 newRadioProtocol_[i].modemId = radioProtocol_[slotCount_ - 1 - i].modemId;
303             }
304             break;
305         }
306         case RadioProtocolPhase::RADIO_PROTOCOL_PHASE_UPDATE:
307         case RadioProtocolPhase::RADIO_PROTOCOL_PHASE_NOTIFY:
308         case RadioProtocolPhase::RADIO_PROTOCOL_PHASE_COMPLETE: {
309             if (slotCount_ < 0 || static_cast<int32_t>(oldRadioProtocol_.size()) < slotCount_ ||
310                 static_cast<int32_t>(newRadioProtocol_.size()) < slotCount_) {
311                 TELEPHONY_LOGE("error, old size = %{public}zu, new size = %{public}zu, slotCount_ = %{public}d",
312                     oldRadioProtocol_.size(), newRadioProtocol_.size(), slotCount_);
313                 break;
314             }
315             for (int32_t i = 0; i < slotCount_; i++) {
316                 oldRadioProtocol_[i].sessionId = sessionId_;
317                 oldRadioProtocol_[i].phase = phase;
318                 oldRadioProtocol_[i].status = status;
319                 newRadioProtocol_[i].sessionId = sessionId_;
320                 newRadioProtocol_[i].phase = phase;
321                 newRadioProtocol_[i].status = status;
322             }
323             break;
324         }
325         default:
326             TELEPHONY_LOGE("RadioProtocolController::BuildRadioProtocolForCommunication invalid phase");
327             break;
328     }
329 }
330 
SendRadioProtocolEvent(std::vector<RadioProtocol> radioProtocol,uint32_t eventId)331 void RadioProtocolController::SendRadioProtocolEvent(std::vector<RadioProtocol> radioProtocol, uint32_t eventId)
332 {
333     auto telRilManager = telRilManager_.lock();
334     if (telRilManager == nullptr || radioProtocol.empty()) {
335         TELEPHONY_LOGE("RadioProtocolController::SendRadioProtocol telRilManager or radioProtocol is nullptr");
336         ProcessCommunicationResponse(false);
337         CleanUpCommunication();
338         return;
339     }
340     if (slotCount_ > static_cast<int32_t>(radioProtocol.size()) || slotCount_ < 0) {
341         TELEPHONY_LOGE("error, size = %{public}zu, slotCount_ = %{public}d", radioProtocol_.size(), slotCount_);
342         ProcessCommunicationResponse(false);
343         CleanUpCommunication();
344         return;
345     }
346     for (int32_t i = 0; i < slotCount_; i++) {
347         AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(eventId);
348         if (event == nullptr) {
349             TELEPHONY_LOGE("RadioProtocolController::SendRadioProtocol event is nullptr");
350             ProcessCommunicationResponse(false);
351             CleanUpCommunication();
352             return;
353         }
354         event->SetOwner(shared_from_this());
355         telRilManager->SetRadioProtocol(i, radioProtocol[i], event);
356     }
357 }
358 
UpdateRadioProtocol(std::shared_ptr<RadioProtocol> radioProtocol)359 void RadioProtocolController::UpdateRadioProtocol(std::shared_ptr<RadioProtocol> radioProtocol)
360 {
361     std::unique_lock<std::mutex> radioProtocolLock(radioProtocolMutex_);
362     int32_t slotId = radioProtocol->slotId;
363     if ((slotId >= DEFAULT_SIM_SLOT_ID) && (slotId < SIM_SLOT_COUNT)) {
364         radioProtocol_[slotId].sessionId = radioProtocol->sessionId;
365         radioProtocol_[slotId].phase = radioProtocol->phase;
366         radioProtocol_[slotId].technology = radioProtocol->technology;
367         radioProtocol_[slotId].modemId = radioProtocol->modemId;
368         radioProtocol_[slotId].status = radioProtocol->status;
369     }
370 }
371 
ProcessResponseInfoOfEvent(const AppExecFwk::InnerEvent::Pointer & event)372 bool RadioProtocolController::ProcessResponseInfoOfEvent(const AppExecFwk::InnerEvent::Pointer &event)
373 {
374     if (event == nullptr) {
375         TELEPHONY_LOGE("RadioProtocolController::ProcessResponseInfoOfEvent event is nullptr");
376         return false;
377     }
378     std::shared_ptr<RadioResponseInfo> responseInfo = event->GetSharedObject<RadioResponseInfo>();
379     if (responseInfo != nullptr && responseInfo->error != ErrType::NONE) {
380         TELEPHONY_LOGE("RadioProtocolController::ProcessResponseInfoOfEvent error:%{public}d", responseInfo->error);
381         communicationFailed_ = true;
382         return true;
383     }
384 
385     std::shared_ptr<RadioProtocol> radioProtocol = event->GetSharedObject<RadioProtocol>();
386     return radioProtocol != nullptr && radioProtocol->sessionId == sessionId_;
387 }
388 
CleanUpCommunication()389 void RadioProtocolController::CleanUpCommunication()
390 {
391     TELEPHONY_LOGI("RadioProtocolController::CleanUpCommunication");
392     RemoveEvent(RADIO_SIM_SET_RADIO_PROTOCOL_TIMEOUT);
393     communicationFailed_ = false;
394     std::vector<RadioProtocol>().swap(oldRadioProtocol_);
395     std::vector<RadioProtocol>().swap(newRadioProtocol_);
396 }
397 
ProcessCommunicationResponse(bool result)398 void RadioProtocolController::ProcessCommunicationResponse(bool result)
399 {
400     communicationResponseResult_ = result;
401     isCommunicating_ = false;
402     radioProtocolCv_.notify_all();
403 }
404 
UnRegisterEvents()405 void RadioProtocolController::UnRegisterEvents()
406 {
407     auto telRilManager = telRilManager_.lock();
408     if (telRilManager == nullptr) {
409         TELEPHONY_LOGE("RadioProtocolController::UnRegisterEvents telRilManager is nullptr");
410         return;
411     }
412     for (int32_t i = 0; i < slotCount_; i++) {
413         telRilManager->UnRegisterCoreNotify(i, shared_from_this(), RADIO_SIM_RADIO_PROTOCOL_NOTIFY);
414     }
415 }
416 
RadioProtocolControllerWait()417 void RadioProtocolController::RadioProtocolControllerWait()
418 {
419     responseReady_ = false;
420 }
421 
RadioProtocolControllerContinue()422 void RadioProtocolController::RadioProtocolControllerContinue()
423 {
424     responseReady_ = true;
425 }
426 
RadioProtocolControllerPoll()427 bool RadioProtocolController::RadioProtocolControllerPoll()
428 {
429     return responseReady_;
430 }
431 
ProcessActiveSimTimeOutDone(const AppExecFwk::InnerEvent::Pointer & event)432 void RadioProtocolController::ProcessActiveSimTimeOutDone(const AppExecFwk::InnerEvent::Pointer &event)
433 {
434     TELEPHONY_LOGI("RadioProtocolController::ProcessActiveSimTimeOutDone");
435     RadioProtocolControllerContinue();
436     cv_.notify_all();
437 }
438 
SetActiveSimToRil(int32_t slotId,int32_t type,int32_t enable)439 bool RadioProtocolController::SetActiveSimToRil(int32_t slotId, int32_t type, int32_t enable)
440 {
441     TELEPHONY_LOGI("RadioProtocolController::SetActiveSim(), enable=%{public}d", enable);
442     auto telRilManager = telRilManager_.lock();
443     if (telRilManager == nullptr) {
444         TELEPHONY_LOGE("RadioProtocolController::SetActiveSim nullptr");
445         return false;
446     }
447     auto event = AppExecFwk::InnerEvent::Get(MSG_SIM_SET_ACTIVE);
448     if (event == nullptr) {
449         TELEPHONY_LOGE("event is nullptr!");
450         return false;
451     }
452     activeResponse_ = 1;
453     event->SetOwner(shared_from_this());
454     SendEvent(MSG_SIM_TIME_OUT_ACTIVE, SET_ACTIVE_OUT_TIME, Priority::LOW);
455     telRilManager->SetActiveSim(slotId, type, enable, event);
456     return true;
457 }
458 
ProcessActiveSimToRilResponse(const AppExecFwk::InnerEvent::Pointer & event)459 void RadioProtocolController::ProcessActiveSimToRilResponse(const AppExecFwk::InnerEvent::Pointer &event)
460 {
461     if (event == nullptr) {
462         TELEPHONY_LOGE("RadioProtocolController::ProcessActiveSimToRilResponse event is nullptr");
463         return;
464     }
465     TELEPHONY_LOGI("RadioProtocolController::GetSetActiveSimResult");
466     int32_t result = 0;
467     std::shared_ptr<ErrType> param = event->GetSharedObject<ErrType>();
468     std::shared_ptr<RadioResponseInfo> response = event->GetSharedObject<RadioResponseInfo>();
469     if ((param == nullptr) && (response == nullptr)) {
470         TELEPHONY_LOGE("RadioProtocolController::GetSetActiveSimResult() fail");
471         RadioProtocolControllerContinue();
472         cv_.notify_all();
473         return;
474     }
475     if (param != nullptr) {
476         result = static_cast<int32_t>(*param);
477     } else {
478         result = static_cast<int32_t>(response->error);
479     }
480     TELEPHONY_LOGI("RadioProtocolController::GetSetActiveSimResult(), activeResponse = %{public}d", result);
481     activeResponse_ = result;
482     RadioProtocolControllerContinue();
483     cv_.notify_all();
484 }
485 
GetActiveSimToRilResult()486 int32_t RadioProtocolController::GetActiveSimToRilResult()
487 {
488     RemoveEvent(MSG_SIM_TIME_OUT_ACTIVE);
489     return activeResponse_;
490 }
491 } // namespace Telephony
492 } // namespace OHOS
493