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