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 #include "telephony_log_wrapper.h"
18 #include "common_event_data.h"
19 #include "common_event_publish_info.h"
20 #include "common_event_manager.h"
21 #include "hril_types.h"
22 #include "radio_event.h"
23
24 namespace OHOS {
25 namespace Telephony {
StkController(const std::shared_ptr<AppExecFwk::EventRunner> & runner)26 StkController::StkController(
27 const std::shared_ptr<AppExecFwk::EventRunner> &runner) : AppExecFwk::EventHandler(runner)
28 {
29 TELEPHONY_LOGI("StkController::StkController()");
30 iccCardState_ = ICC_CARD_STATE_ABSENT;
31 }
32
~StkController()33 StkController::~StkController()
34 {
35 UnRegisterEvents();
36 }
37
Init(int slotId)38 void StkController::Init(int slotId)
39 {
40 TELEPHONY_LOGI("StkController::Init() started ");
41 slotId_ = slotId;
42 RegisterEvents();
43 TELEPHONY_LOGI("StkController::Init() end");
44 }
45
RegisterEvents()46 void StkController::RegisterEvents()
47 {
48 if (telRilManager_ == nullptr) {
49 TELEPHONY_LOGE("StkController:: RegisterEvents TelRilManager is null");
50 return;
51 }
52 if (simStateManager_ == nullptr) {
53 TELEPHONY_LOGE("StkController:: RegisterEvents SimStateManager is null");
54 return;
55 }
56 TELEPHONY_LOGI("StkController:: RegisterEvent start");
57 simStateManager_->RegisterCoreNotify(shared_from_this(), RadioEvent::RADIO_SIM_STATE_CHANGE);
58 telRilManager_->RegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_STK_SESSION_END, nullptr);
59 telRilManager_->RegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_STK_PROACTIVE_COMMAND, nullptr);
60 telRilManager_->RegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_STK_ALPHA_NOTIFY, nullptr);
61 TELEPHONY_LOGI("StkController:: RegisterEvent end");
62 }
63
UnRegisterEvents()64 void StkController::UnRegisterEvents()
65 {
66 if (telRilManager_ == nullptr) {
67 TELEPHONY_LOGE("StkController:: UnRegisterEvents TelRilManager is null");
68 return;
69 }
70 if (telRilManager_ == nullptr) {
71 TELEPHONY_LOGE("StkController:: UnRegisterEvents SimStateManager is null");
72 return;
73 }
74 TELEPHONY_LOGI("StkController:: UnRegisterEvent start");
75 simStateManager_->UnRegisterCoreNotify(shared_from_this(), RadioEvent::RADIO_SIM_STATE_CHANGE);
76 telRilManager_->UnRegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_STK_SESSION_END);
77 telRilManager_->UnRegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_STK_PROACTIVE_COMMAND);
78 telRilManager_->UnRegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_STK_ALPHA_NOTIFY);
79 TELEPHONY_LOGI("StkController:: UnRegisterEvent end");
80 }
81
SetRilAndSimStateManager(std::shared_ptr<Telephony::ITelRilManager> ril,const std::shared_ptr<Telephony::SimStateManager> simstateMgr)82 void StkController::SetRilAndSimStateManager(std::shared_ptr<Telephony::ITelRilManager> ril,
83 const std::shared_ptr<Telephony::SimStateManager> simstateMgr)
84 {
85 telRilManager_ = ril;
86 if (telRilManager_ == nullptr) {
87 TELEPHONY_LOGE("StkController set NULL TelRilManager!!");
88 }
89 simStateManager_ = simstateMgr;
90 if (simStateManager_ == nullptr) {
91 TELEPHONY_LOGE("StkController set NULL SimStateManager!!");
92 }
93 }
94
OnsendRilSessionEnd(const AppExecFwk::InnerEvent::Pointer & event)95 bool StkController::OnsendRilSessionEnd(const AppExecFwk::InnerEvent::Pointer &event)
96 {
97 TELEPHONY_LOGI("StkController::OnsendRilSessionEnd(), publish to STK APP.");
98
99 AAFwk::Want want;
100 want.SetParam(PARAM_SLOTID, slotId_);
101 want.SetAction(ACTION_SESSION_END);
102 int32_t eventCode = 1;
103 std::string eventData("OnsendRilSessionEnd");
104 return PublishStkEvent(want, eventCode, eventData);
105 }
106
OnsendRilProactiveCommand(const AppExecFwk::InnerEvent::Pointer & event)107 bool StkController::OnsendRilProactiveCommand(const AppExecFwk::InnerEvent::Pointer &event)
108 {
109 TELEPHONY_LOGI("StkController::OnsendRilProactiveCommand(), publish to STK APP.");
110
111 if (event == nullptr) {
112 TELEPHONY_LOGE("StkController::OnsendRilProactiveCommand(), event nullptr!!!!!!");
113 return false;
114 }
115
116 auto stkData = event->GetSharedObject<std::string>();
117 if (stkData == nullptr) {
118 TELEPHONY_LOGE("StkController::OnsendRilProactiveCommand(), event nullptr!!!!!!");
119 return false;
120 }
121
122 AAFwk::Want want;
123 EventFwk::CommonEventData data;
124 std::string cmdData = (std::string)*stkData;
125 TELEPHONY_LOGI("StkController::OnsendRilProactiveCommand() command data package = %{public}s\n", cmdData.c_str());
126 // want
127 want.SetParam(PARAM_SLOTID, slotId_);
128 want.SetParam(PARAM_MSG_CMD, cmdData);
129 want.SetAction(ACTION_STK_COMMAND);
130
131 // event code and event data
132 int32_t eventCode = EVENT_CODE;
133 std::string eventData("OnsendRilProactiveCommand");
134
135 bool publishResult = PublishStkEvent(want, eventCode, eventData);
136 TELEPHONY_LOGI("StkController::ProacitveCommand end\npublishResult = %{public}d\n", publishResult);
137
138 return true;
139 }
140
OnsendRilAlphaNotify(const AppExecFwk::InnerEvent::Pointer & event)141 bool StkController::OnsendRilAlphaNotify(const AppExecFwk::InnerEvent::Pointer &event)
142 {
143 TELEPHONY_LOGI("StkController::OnsendRilAlphaNotify(), publish to STK APP.");
144 return false;
145 }
146
OnIccStateChanged(const AppExecFwk::InnerEvent::Pointer & event)147 bool StkController::OnIccStateChanged(const AppExecFwk::InnerEvent::Pointer &event)
148 {
149 TELEPHONY_LOGI("StkController::OnIccStateChanged(), publish to STK APP.");
150 bool hasCard = simStateManager_->HasSimCard();
151 TELEPHONY_LOGI("StkController::OnIccStateChanged(), hasCard: %{public}d\n", hasCard);
152 int32_t newState = hasCard ? ICC_CARD_STATE_PRESENT : ICC_CARD_STATE_ABSENT;
153 int32_t oldState = iccCardState_;
154 iccCardState_ = newState;
155 if ((oldState == ICC_CARD_STATE_PRESENT) && (newState == ICC_CARD_STATE_ABSENT)) {
156 AAFwk::Want want;
157 EventFwk::CommonEventData data;
158 // want
159 want.SetParam(PARAM_SLOTID, slotId_);
160 want.SetParam(PARAM_CARD_STATUS, newState);
161 want.SetAction(ACTION_CARD_STATUS_INFORM);
162
163 // event code and event data
164 int32_t eventCode = EVENT_CODE;
165 std::string eventData("OnIccStateChanged");
166
167 bool publishResult = PublishStkEvent(want, eventCode, eventData);
168 TELEPHONY_LOGI("StkController::OnIccStateChanged end ### publishResult = %{public}d\n", publishResult);
169 } else if ((oldState == ICC_CARD_STATE_ABSENT) && (newState == ICC_CARD_STATE_PRESENT)) {
170 TELEPHONY_LOGI("StkController::OnIccStateChanged(), call SimStkIsReady()");
171 auto event = AppExecFwk::InnerEvent::Get(MSG_SIM_STK_IS_READY);
172 event->SetOwner(shared_from_this());
173 telRilManager_->SimStkIsReady(slotId_, event);
174 }
175 return true;
176 }
177
PublishStkEvent(const AAFwk::Want & want,int eventCode,const std::string & eventData)178 bool StkController::PublishStkEvent(const AAFwk::Want &want, int eventCode, const std::string &eventData)
179 {
180 EventFwk::CommonEventData data;
181 data.SetWant(want);
182 data.SetCode(eventCode);
183 data.SetData(eventData);
184 EventFwk::CommonEventPublishInfo publishInfo;
185 publishInfo.SetOrdered(true);
186 bool publishResult = EventFwk::CommonEventManager::PublishCommonEvent(data, publishInfo, nullptr);
187 TELEPHONY_LOGI("StkController::PublishStkEvent end###publishResult = %{public}d\n", publishResult);
188 return publishResult;
189 }
190
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)191 void StkController::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event)
192 {
193 int id = 0;
194 id = event->GetInnerEventId();
195 TELEPHONY_LOGI("StkController ProcessEvent Id is %{public}d", id);
196 if (event == nullptr) {
197 TELEPHONY_LOGE("start ProcessEvent but event is null!");
198 return;
199 }
200 switch (id) {
201 case RadioEvent::RADIO_SIM_STATE_CHANGE:
202 OnIccStateChanged(event);
203 break;
204 case RadioEvent::RADIO_STK_SESSION_END:
205 OnsendRilSessionEnd(event);
206 break;
207 case RadioEvent::RADIO_STK_PROACTIVE_COMMAND:
208 OnsendRilProactiveCommand(event);
209 break;
210 case RadioEvent::RADIO_STK_ALPHA_NOTIFY:
211 OnsendRilAlphaNotify(event);
212 break;
213 case MSG_SIM_STK_TERMINAL_RESPONSE:
214 TELEPHONY_LOGI("StkController::SendTerminalResponseCmd done.");
215 GetTerminalResponseResult(event);
216 break;
217 case MSG_SIM_STK_ENVELOPE:
218 TELEPHONY_LOGI("StkController::SendEnvelopeCmd done.");
219 GetEnvelopeCmdResult(event);
220 break;
221 case MSG_SIM_STK_IS_READY:
222 TELEPHONY_LOGI("StkController::SimStkIsReady done.");
223 break;
224 default:
225 TELEPHONY_LOGI("StkController::ProcessEvent(), unknown event");
226 break;
227 }
228 }
229
SendTerminalResponseCmd(int32_t slotId,const std::string & strCmd)230 bool StkController::SendTerminalResponseCmd(int32_t slotId, const std::string &strCmd)
231 {
232 TELEPHONY_LOGI("StkController::SendTerminalResponseCmd");
233 auto event = AppExecFwk::InnerEvent::Get(MSG_SIM_STK_TERMINAL_RESPONSE);
234 event->SetOwner(shared_from_this());
235 std::unique_lock<std::mutex> lck(ctx_);
236 responseReady_ = false;
237
238 if (telRilManager_ != nullptr) {
239 telRilManager_->SendTerminalResponseCmd(slotId_, strCmd, event);
240 }
241 while (!responseReady_) {
242 TELEPHONY_LOGI("StkController::wait(), response = false");
243 cv_.wait(lck);
244 }
245 return terminalResponse_;
246 }
247
SendEnvelopeCmd(int32_t slotId,const std::string & strCmd)248 bool StkController::SendEnvelopeCmd(int32_t slotId, const std::string &strCmd)
249 {
250 TELEPHONY_LOGI("StkController::SendEnvelopeCmd");
251 auto event = AppExecFwk::InnerEvent::Get(MSG_SIM_STK_ENVELOPE);
252 event->SetOwner(shared_from_this());
253 std::unique_lock<std::mutex> lck(ctx_);
254 responseReady_ = false;
255 if (telRilManager_ != nullptr) {
256 telRilManager_->SendEnvelopeCmd(slotId, strCmd, event);
257 }
258 while (!responseReady_) {
259 TELEPHONY_LOGI("StkController::wait(), response = false");
260 cv_.wait(lck);
261 }
262 return envelopeResponse_;
263 }
264
GetTerminalResponseResult(const AppExecFwk::InnerEvent::Pointer & event)265 void StkController::GetTerminalResponseResult(const AppExecFwk::InnerEvent::Pointer &event)
266 {
267 TELEPHONY_LOGI("StkController::GetTerminalResponseResult");
268 int32_t result = 0;
269 std::shared_ptr<HRilErrType> param = event->GetSharedObject<HRilErrType>();
270 std::shared_ptr<HRilRadioResponseInfo> response = event->GetSharedObject<HRilRadioResponseInfo>();
271 if ((param == nullptr) && (response == nullptr)) {
272 TELEPHONY_LOGE("StkController::GetTerminalResponseResult() fail");
273 return;
274 }
275 if (param) {
276 result = static_cast<int32_t>(*param);
277 } else {
278 result = static_cast<int32_t>(response->error);
279 }
280 std::unique_lock<std::mutex> lck(ctx_);
281 TELEPHONY_LOGI("StkController::GetTerminalResponseResult(), error = %{public}d", result);
282 terminalResponse_ = result ? false : true;
283 responseReady_ = true;
284 cv_.notify_one();
285 }
286
GetEnvelopeCmdResult(const AppExecFwk::InnerEvent::Pointer & event)287 void StkController::GetEnvelopeCmdResult(const AppExecFwk::InnerEvent::Pointer &event)
288 {
289 TELEPHONY_LOGI("StkController::GetEnvelopeCmdResult");
290 int32_t result = 0;
291 std::shared_ptr<HRilErrType> param = event->GetSharedObject<HRilErrType>();
292 std::shared_ptr<HRilRadioResponseInfo> response = event->GetSharedObject<HRilRadioResponseInfo>();
293 if ((param == nullptr) && (response == nullptr)) {
294 TELEPHONY_LOGE("StkController::GetEnvelopeCmdResult() fail");
295 return;
296 }
297 if (param) {
298 result = static_cast<int32_t>(*param);
299 } else {
300 result = static_cast<int32_t>(response->error);
301 }
302 std::unique_lock<std::mutex> lck(ctx_);
303 TELEPHONY_LOGI("StkController::GetEnvelopeCmdResult(), error = %{public}d", result);
304 envelopeResponse_ = result ? false : true;
305 responseReady_ = true;
306 cv_.notify_one();
307 }
308 } // namespace Telephony
309 } // namespace OHOS
310