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 "icc_file_controller.h"
17
18 using namespace std;
19 using namespace OHOS::AppExecFwk;
20
21 namespace OHOS {
22 namespace Telephony {
IccFileController(const std::shared_ptr<AppExecFwk::EventRunner> & runner,int slotId)23 IccFileController::IccFileController(const std::shared_ptr<AppExecFwk::EventRunner> &runner, int slotId)
24 : AppExecFwk::EventHandler(runner), slotId_(slotId)
25 {}
26
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)27 void IccFileController::ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event)
28 {
29 int id = 0;
30 id = event->GetInnerEventId();
31 TELEPHONY_LOGI("IccFileController ProcessEvent Id is %{public}d", id);
32 if (ProcessErrorResponse(event)) {
33 return;
34 }
35 switch (id) {
36 case MSG_SIM_OBTAIN_SIZE_OF_LINEAR_ELEMENTARY_FILE_DONE:
37 ProcessLinearRecordSize(event);
38 break;
39 case MSG_SIM_OBTAIN_SIZE_OF_FIXED_ELEMENTARY_FILE_DONE:
40 ProcessRecordSize(event);
41 break;
42 case MSG_SIM_OBTAIN_SIZE_OF_TRANSPARENT_ELEMENTARY_FILE_DONE:
43 ProcessBinarySize(event);
44 break;
45 case MSG_SIM_OBTAIN_FIXED_ELEMENTARY_FILE_DONE:
46 ProcessReadRecord(event);
47 break;
48 case MSG_SIM_OBTAIN_ICON_DONE:
49 case MSG_SIM_UPDATE_LINEAR_FIXED_FILE_DONE:
50 case MSG_SIM_UPDATE_TRANSPARENT_ELEMENTARY_FILE_DONE:
51 case MSG_SIM_OBTAIN_TRANSPARENT_ELEMENTARY_FILE_DONE:
52 ProcessReadBinary(event);
53 break;
54 default:
55 break;
56 }
57 }
58
ProcessLinearRecordSize(const AppExecFwk::InnerEvent::Pointer & event)59 void IccFileController::ProcessLinearRecordSize(const AppExecFwk::InnerEvent::Pointer &event)
60 {
61 std::string str = IccFileController::NULLSTR;
62 std::string path = IccFileController::NULLSTR;
63 auto eventId = event->GetInnerEventId();
64 std::unique_ptr<IccFromRilMsg> rcvMsg = event->GetUniqueObject<IccFromRilMsg>();
65 const AppExecFwk::InnerEvent::Pointer &process = rcvMsg->controlHolder->fileLoaded;
66 IccFileData *result = &(rcvMsg->fileData);
67 std::shared_ptr<IccControllerHolder> &hd = rcvMsg->controlHolder;
68 path = hd->filePath;
69 const char *iccDdata = (result->resultData).c_str();
70 char *rawData = const_cast<char *>(iccDdata);
71 unsigned char *fileData = reinterpret_cast<unsigned char *>(rawData); // for unsigned int bitwise
72
73 if (IsValidSizeData(fileData)) {
74 TELEPHONY_LOGI("ProcessLinearRecordSize valid data");
75 } else {
76 TELEPHONY_LOGI("IccFileTypeMismatch Error type %{public}d", eventId);
77 }
78 int fileSize[] = {0, 0, 0};
79 if (!result->resultData.empty()) {
80 ParseFileSize(fileSize, RECORD_NUM, fileData);
81 }
82 SendEfLinearResult(process, fileSize, RECORD_NUM);
83 }
84
ProcessRecordSize(const AppExecFwk::InnerEvent::Pointer & event)85 void IccFileController::ProcessRecordSize(const AppExecFwk::InnerEvent::Pointer &event)
86 {
87 int size = 0;
88 std::string str = IccFileController::NULLSTR;
89 std::string path = IccFileController::NULLSTR;
90 std::unique_ptr<IccFromRilMsg> rcvMsg = event->GetUniqueObject<IccFromRilMsg>();
91 IccFileData *result = &(rcvMsg->fileData);
92 std::shared_ptr<IccControllerHolder> &hd = rcvMsg->controlHolder;
93 const char *iccDdata = (result->resultData).c_str();
94 char *rawData = const_cast<char *>(iccDdata);
95 unsigned char *fileData = reinterpret_cast<unsigned char *>(rawData); // for unsigned int bitwise
96
97 path = CheckRightPath(hd->filePath, hd->fileId);
98 if (!IsValidSizeData(fileData)) {
99 TELEPHONY_LOGE("ProcessRecordSize get error filetype");
100 }
101 GetFileAndDataSize(fileData, hd->fileSize, size);
102 if (hd->fileSize != 0) {
103 hd->countFiles = size / hd->fileSize;
104 TELEPHONY_LOGI("origin count file %{public}d", hd->countFiles);
105 }
106
107 if (IsFixedNumberType(hd->fileId)) {
108 hd->countFiles = MAX_RECORD_NUM;
109 }
110 TELEPHONY_LOGI("ProcessRecordSize %{public}d %{public}d %{public}d", size, hd->fileSize, hd->countFiles);
111 if (telRilManager_ != nullptr) {
112 SimIoRequestInfo msg;
113 msg.command = CONTROLLER_REQ_READ_RECORD;
114 msg.fileId = hd->fileId;
115 msg.p1 = hd->fileNum;
116 msg.p2 = ICC_FILE_CURRENT_MODE;
117 msg.p3 = hd->fileSize;
118 msg.data = IccFileController::NULLSTR;
119 msg.path = path;
120 msg.pin2 = "";
121 telRilManager_->GetSimIO(slotId_, msg, BuildCallerInfo(MSG_SIM_OBTAIN_FIXED_ELEMENTARY_FILE_DONE, hd));
122 }
123 }
124
ProcessBinarySize(const AppExecFwk::InnerEvent::Pointer & event)125 void IccFileController::ProcessBinarySize(const AppExecFwk::InnerEvent::Pointer &event)
126 {
127 std::string str = IccFileController::NULLSTR;
128 std::string path = IccFileController::NULLSTR;
129 TELEPHONY_LOGI("IccFileController::ProcessBinarySize init");
130 std::unique_ptr<IccFromRilMsg> rcvMsg = event->GetUniqueObject<IccFromRilMsg>();
131 bool isNull = rcvMsg->controlHolder == nullptr;
132 const AppExecFwk::InnerEvent::Pointer &evt = rcvMsg->controlHolder->fileLoaded;
133 isNull = evt->GetOwner() == nullptr;
134 int fileId = rcvMsg->arg1;
135 int size = 0;
136 AppExecFwk::InnerEvent::Pointer process =
137 BuildCallerInfo(MSG_SIM_OBTAIN_TRANSPARENT_ELEMENTARY_FILE_DONE, fileId, 0, evt);
138 if (telRilManager_ != nullptr) {
139 SimIoRequestInfo msg;
140 msg.command = CONTROLLER_REQ_READ_BINARY;
141 msg.fileId = fileId;
142 msg.p1 = 0;
143 msg.p2 = 0;
144 msg.p3 = size;
145 msg.data = IccFileController::NULLSTR;
146 msg.path = ObtainElementFilePath(fileId);
147 msg.pin2 = "";
148 telRilManager_->GetSimIO(slotId_, msg, process);
149 }
150 TELEPHONY_LOGI("IccFileController::ProcessBinarySize finish %{public}d", fileId);
151 }
152
ProcessReadRecord(const AppExecFwk::InnerEvent::Pointer & event)153 void IccFileController::ProcessReadRecord(const AppExecFwk::InnerEvent::Pointer &event)
154 {
155 std::string str = IccFileController::NULLSTR;
156 std::string path = IccFileController::NULLSTR;
157 std::unique_ptr<IccFromRilMsg> rcvMsg = event->GetUniqueObject<IccFromRilMsg>();
158 const AppExecFwk::InnerEvent::Pointer &process = rcvMsg->controlHolder->fileLoaded;
159 IccFileData *result = &(rcvMsg->fileData);
160 std::shared_ptr<IccControllerHolder> &hd = rcvMsg->controlHolder;
161 TELEPHONY_LOGI("ProcessReadRecord %{public}d %{public}d %{public}d %{public}s", hd->getAllFile, hd->fileNum,
162 hd->countFiles, result->resultData.c_str());
163 path = CheckRightPath(hd->filePath, hd->fileId);
164 if (hd->getAllFile) {
165 hd->fileResults.push_back(result->resultData);
166 hd->fileNum++;
167 if (hd->fileNum > hd->countFiles) {
168 SendMultiRecordResult(process, hd->fileResults);
169 } else {
170 SimIoRequestInfo msg;
171 msg.command = CONTROLLER_REQ_READ_RECORD;
172 msg.fileId = hd->fileId;
173 msg.p1 = hd->fileNum;
174 msg.p2 = ICC_FILE_CURRENT_MODE;
175 msg.p3 = hd->fileSize;
176 msg.data = IccFileController::NULLSTR;
177 msg.path = path;
178 msg.pin2 = "";
179 telRilManager_->GetSimIO(slotId_, msg, BuildCallerInfo(MSG_SIM_OBTAIN_FIXED_ELEMENTARY_FILE_DONE, hd));
180 }
181 } else {
182 SendResponse(rcvMsg->controlHolder, &(rcvMsg->fileData));
183 }
184 }
185
ProcessReadBinary(const AppExecFwk::InnerEvent::Pointer & event)186 void IccFileController::ProcessReadBinary(const AppExecFwk::InnerEvent::Pointer &event)
187 {
188 TELEPHONY_LOGI("IccFileController MSG_SIM_OBTAIN_TRANSPARENT_ELEMENTARY_FILE_DONE");
189 std::unique_ptr<IccFromRilMsg> rcvMsg = event->GetUniqueObject<IccFromRilMsg>();
190 SendResponse(rcvMsg->controlHolder, &(rcvMsg->fileData));
191 }
192
ObtainElementFileForPublic(int efId)193 std::string IccFileController::ObtainElementFileForPublic(int efId)
194 {
195 std::string mf = MASTER_FILE_SIM;
196 if (efId == ELEMENTARY_FILE_ICCID || efId == ELEMENTARY_FILE_PL) {
197 return mf;
198 }
199 mf.append(DEDICATED_FILE_TELECOM);
200 if (efId == ELEMENTARY_FILE_ADN || efId == ELEMENTARY_FILE_FDN || efId == ELEMENTARY_FILE_MSISDN ||
201 efId == ELEMENTARY_FILE_SDN || efId == ELEMENTARY_FILE_EXT1 || efId == ELEMENTARY_FILE_EXT2 ||
202 efId == ELEMENTARY_FILE_EXT3) {
203 return mf;
204 }
205 if (efId == ELEMENTARY_FILE_PBR) {
206 mf.append(DEDICATED_FILE_DIALLING_NUMBERS);
207 return mf;
208 }
209 if (efId == ELEMENTARY_FILE_IMG) {
210 mf.append(DEDICATED_FILE_GRAPHICS);
211 return mf;
212 }
213 return IccFileController::NULLSTR;
214 }
215
216 // implementation ObtainBinaryFile
ObtainBinaryFile(int fileId,const AppExecFwk::InnerEvent::Pointer & event)217 void IccFileController::ObtainBinaryFile(int fileId, const AppExecFwk::InnerEvent::Pointer &event)
218 {
219 TELEPHONY_LOGI("IccFileController::ObtainBinaryFile start");
220 AppExecFwk::InnerEvent::Pointer process =
221 BuildCallerInfo(MSG_SIM_OBTAIN_SIZE_OF_TRANSPARENT_ELEMENTARY_FILE_DONE, fileId, 0, event);
222 if (telRilManager_ != nullptr) {
223 SimIoRequestInfo msg;
224 msg.command = CONTROLLER_REQ_GET_RESPONSE;
225 msg.fileId = fileId;
226 msg.p1 = 0;
227 msg.p2 = 0;
228 msg.p3 = GET_RESPONSE_ELEMENTARY_FILE_SIZE_BYTES;
229 msg.data = IccFileController::NULLSTR;
230 msg.path = ObtainElementFilePath(fileId);
231 msg.pin2 = "";
232 telRilManager_->GetSimIO(slotId_, msg, process);
233 }
234 TELEPHONY_LOGI("IccFileController::ObtainBinaryFile end");
235 }
236
ObtainBinaryFile(int fileId,int size,const AppExecFwk::InnerEvent::Pointer & event)237 void IccFileController::ObtainBinaryFile(int fileId, int size, const AppExecFwk::InnerEvent::Pointer &event)
238 {
239 AppExecFwk::InnerEvent::Pointer process =
240 BuildCallerInfo(MSG_SIM_OBTAIN_TRANSPARENT_ELEMENTARY_FILE_DONE, fileId, 0, event);
241 if (telRilManager_ != nullptr) {
242 SimIoRequestInfo msg;
243 msg.command = CONTROLLER_REQ_READ_BINARY;
244 msg.fileId = fileId;
245 msg.p1 = 0;
246 msg.p2 = 0;
247 msg.p3 = size;
248 msg.data = IccFileController::NULLSTR;
249 msg.path = ObtainElementFilePath(fileId);
250 msg.pin2 = "";
251 telRilManager_->GetSimIO(slotId_, msg, process);
252 }
253 }
254
255 // implementation ObtainLinearFixedFile
ObtainLinearFixedFile(int fileId,const std::string & path,int fileNum,const AppExecFwk::InnerEvent::Pointer & event)256 void IccFileController::ObtainLinearFixedFile(
257 int fileId, const std::string &path, int fileNum, const AppExecFwk::InnerEvent::Pointer &event)
258 {
259 std::string filePath = CheckRightPath(path, fileId);
260 std::shared_ptr<IccControllerHolder> ctrlHolder =
261 std::make_shared<IccControllerHolder>(fileId, fileNum, filePath);
262 ctrlHolder->fileLoaded = std::move(const_cast<AppExecFwk::InnerEvent::Pointer &>(event));
263 AppExecFwk::InnerEvent::Pointer process =
264 BuildCallerInfo(MSG_SIM_OBTAIN_SIZE_OF_FIXED_ELEMENTARY_FILE_DONE, ctrlHolder);
265 if (telRilManager_ != nullptr) {
266 SimIoRequestInfo msg;
267 msg.command = CONTROLLER_REQ_GET_RESPONSE;
268 msg.fileId = fileId;
269 msg.p1 = 0;
270 msg.p2 = 0;
271 msg.p3 = GET_RESPONSE_ELEMENTARY_FILE_SIZE_BYTES;
272 msg.data = IccFileController::NULLSTR;
273 msg.path = filePath;
274 msg.pin2 = "";
275 telRilManager_->GetSimIO(slotId_, msg, process);
276 }
277 }
278
ObtainLinearFixedFile(int fileId,int fileNum,const AppExecFwk::InnerEvent::Pointer & event)279 void IccFileController::ObtainLinearFixedFile(int fileId, int fileNum, const AppExecFwk::InnerEvent::Pointer &event)
280 {
281 ObtainLinearFixedFile(fileId, ObtainElementFilePath(fileId), fileNum, event);
282 }
283
284 // implementation ObtainAllLinearFixedFile
ObtainAllLinearFixedFile(int fileId,const std::string & path,const AppExecFwk::InnerEvent::Pointer & event)285 void IccFileController::ObtainAllLinearFixedFile(
286 int fileId, const std::string &path, const AppExecFwk::InnerEvent::Pointer &event)
287 {
288 std::string filePath = CheckRightPath(path, fileId);
289 std::shared_ptr<IccControllerHolder> ctrlHolder = std::make_shared<IccControllerHolder>(fileId, filePath);
290 ctrlHolder->fileLoaded = std::move(const_cast<AppExecFwk::InnerEvent::Pointer &>(event));
291 AppExecFwk::InnerEvent::Pointer process =
292 BuildCallerInfo(MSG_SIM_OBTAIN_SIZE_OF_FIXED_ELEMENTARY_FILE_DONE, ctrlHolder);
293 if (telRilManager_ != nullptr) {
294 SimIoRequestInfo msg;
295 msg.command = CONTROLLER_REQ_GET_RESPONSE;
296 msg.fileId = fileId;
297 msg.p1 = 0;
298 msg.p2 = 0;
299 msg.p3 = GET_RESPONSE_ELEMENTARY_FILE_SIZE_BYTES;
300 msg.data = IccFileController::NULLSTR;
301 msg.path = filePath;
302 msg.pin2 = "";
303 telRilManager_->GetSimIO(slotId_, msg, process);
304 }
305 }
306
ObtainAllLinearFixedFile(int fileId,const AppExecFwk::InnerEvent::Pointer & event)307 void IccFileController::ObtainAllLinearFixedFile(int fileId, const AppExecFwk::InnerEvent::Pointer &event)
308 {
309 ObtainAllLinearFixedFile(fileId, ObtainElementFilePath(fileId), event);
310 }
311
ObtainLinearFileSize(int fileId,const std::string & path,const AppExecFwk::InnerEvent::Pointer & event)312 void IccFileController::ObtainLinearFileSize(
313 int fileId, const std::string &path, const AppExecFwk::InnerEvent::Pointer &event)
314 {
315 std::string filePath = CheckRightPath(path, fileId);
316 std::shared_ptr<IccControllerHolder> ctrlHolder = std::make_shared<IccControllerHolder>(fileId, filePath);
317 ctrlHolder->fileLoaded = std::move(const_cast<AppExecFwk::InnerEvent::Pointer &>(event));
318 AppExecFwk::InnerEvent::Pointer process =
319 BuildCallerInfo(MSG_SIM_OBTAIN_SIZE_OF_LINEAR_ELEMENTARY_FILE_DONE, ctrlHolder);
320 if (telRilManager_ != nullptr) {
321 SimIoRequestInfo msg;
322 msg.command = CONTROLLER_REQ_GET_RESPONSE;
323 msg.fileId = fileId;
324 msg.p1 = 0;
325 msg.p2 = 0;
326 msg.p3 = GET_RESPONSE_ELEMENTARY_FILE_SIZE_BYTES;
327 msg.data = IccFileController::NULLSTR;
328 msg.path = filePath;
329 msg.pin2 = "";
330 telRilManager_->GetSimIO(slotId_, msg, process);
331 }
332 }
333
ObtainLinearFileSize(int fileId,const AppExecFwk::InnerEvent::Pointer & event)334 void IccFileController::ObtainLinearFileSize(int fileId, const AppExecFwk::InnerEvent::Pointer &event)
335 {
336 ObtainLinearFileSize(fileId, ObtainElementFilePath(fileId), event);
337 }
338
UpdateLinearFixedFile(int fileId,const std::string & path,int fileNum,std::string data,int dataLength,const std::string pin2,const AppExecFwk::InnerEvent::Pointer & onComplete)339 void IccFileController::UpdateLinearFixedFile(int fileId, const std::string &path, int fileNum, std::string data,
340 int dataLength, const std::string pin2, const AppExecFwk::InnerEvent::Pointer &onComplete)
341 {
342 std::string filePath = CheckRightPath(path, fileId);
343 std::shared_ptr<IccControllerHolder> ctrlHolder = std::make_shared<IccControllerHolder>(fileId);
344 ctrlHolder->fileLoaded = std::move(const_cast<AppExecFwk::InnerEvent::Pointer &>(onComplete));
345 AppExecFwk::InnerEvent::Pointer process = BuildCallerInfo(MSG_SIM_UPDATE_LINEAR_FIXED_FILE_DONE, ctrlHolder);
346 if (telRilManager_ != nullptr) {
347 SimIoRequestInfo msg;
348 msg.command = CONTROLLER_REQ_UPDATE_RECORD;
349 msg.fileId = fileId;
350 msg.p1 = fileNum;
351 msg.p2 = ICC_FILE_CURRENT_MODE;
352 msg.p3 = dataLength;
353 msg.data = data;
354 msg.path = filePath;
355 msg.pin2 = pin2;
356 telRilManager_->GetSimIO(slotId_, msg, process);
357 }
358 }
359
UpdateLinearFixedFile(int fileId,int fileNum,const std::string data,int dataLength,const std::string pin2,const AppExecFwk::InnerEvent::Pointer & onComplete)360 void IccFileController::UpdateLinearFixedFile(int fileId, int fileNum, const std::string data, int dataLength,
361 const std::string pin2, const AppExecFwk::InnerEvent::Pointer &onComplete)
362 {
363 std::shared_ptr<IccControllerHolder> ctrlHolder = std::make_shared<IccControllerHolder>(fileId);
364 ctrlHolder->fileLoaded = std::move(const_cast<AppExecFwk::InnerEvent::Pointer &>(onComplete));
365 AppExecFwk::InnerEvent::Pointer process = BuildCallerInfo(MSG_SIM_UPDATE_LINEAR_FIXED_FILE_DONE, ctrlHolder);
366 if (telRilManager_ != nullptr) {
367 SimIoRequestInfo msg;
368 msg.command = CONTROLLER_REQ_UPDATE_RECORD;
369 msg.fileId = fileId;
370 msg.p1 = fileNum;
371 msg.p2 = ICC_FILE_CURRENT_MODE;
372 msg.p3 = dataLength;
373 msg.data = data;
374 msg.path = ObtainElementFilePath(fileId);
375 msg.pin2 = pin2;
376 telRilManager_->GetSimIO(slotId_, msg, process);
377 }
378 }
379
UpdateBinaryFile(int fileId,const std::string data,int dataLength,const AppExecFwk::InnerEvent::Pointer & onComplete)380 void IccFileController::UpdateBinaryFile(
381 int fileId, const std::string data, int dataLength, const AppExecFwk::InnerEvent::Pointer &onComplete)
382 {
383 std::shared_ptr<IccControllerHolder> ctrlHolder = std::make_shared<IccControllerHolder>(fileId);
384 ctrlHolder->fileLoaded = std::move(const_cast<AppExecFwk::InnerEvent::Pointer &>(onComplete));
385 AppExecFwk::InnerEvent::Pointer process =
386 BuildCallerInfo(MSG_SIM_UPDATE_TRANSPARENT_ELEMENTARY_FILE_DONE, ctrlHolder);
387 if (telRilManager_ != nullptr) {
388 SimIoRequestInfo msg;
389 msg.command = CONTROLLER_REQ_UPDATE_BINARY;
390 msg.fileId = fileId;
391 msg.p1 = 0;
392 msg.p2 = 0;
393 msg.p3 = dataLength;
394 msg.data = data;
395 msg.path = ObtainElementFilePath(fileId);
396 msg.pin2 = "";
397 telRilManager_->GetSimIO(slotId_, msg, process);
398 }
399 }
400
SendResponse(std::shared_ptr<IccControllerHolder> holder,const IccFileData * fd)401 void IccFileController::SendResponse(std::shared_ptr<IccControllerHolder> holder, const IccFileData *fd)
402 {
403 if (holder == nullptr || fd == nullptr) {
404 TELEPHONY_LOGE("IccFileController::SendResponse result is null");
405 return;
406 }
407 AppExecFwk::InnerEvent::Pointer &response = holder->fileLoaded;
408 bool isNull = (response == nullptr);
409 auto owner = response->GetOwner();
410 std::unique_ptr<FileToControllerMsg> cmdData = response->GetUniqueObject<FileToControllerMsg>();
411 int id = response->GetInnerEventId();
412 bool needShare = (id == MSG_SIM_OBTAIN_ICC_FILE_DONE);
413 std::unique_ptr<ControllerToFileMsg> objectUnique = nullptr;
414 std::shared_ptr<ControllerToFileMsg> objectShare = nullptr;
415 TELEPHONY_LOGI("IccFileController::SendResponse start response %{public}d %{public}d", isNull, needShare);
416 if (needShare) {
417 objectShare = std::make_shared<ControllerToFileMsg>(cmdData.get(), fd);
418 } else {
419 objectUnique = std::make_unique<ControllerToFileMsg>(cmdData.get(), fd);
420 }
421
422 if ((objectUnique == nullptr) && (objectShare == nullptr)) {
423 TELEPHONY_LOGE("IccFileController::SendResponse create ControllerToFileMsg is null");
424 return;
425 }
426
427 isNull = (owner == nullptr);
428 TELEPHONY_LOGI("IccFileController::SendResponse owner: %{public}d evtId: %{public}d", isNull, id);
429 if (needShare) {
430 owner->SendEvent(id, objectShare);
431 } else {
432 owner->SendEvent(id, objectUnique);
433 }
434 TELEPHONY_LOGI("IccFileController::SendResponse send end");
435 }
436
SendEfLinearResult(const AppExecFwk::InnerEvent::Pointer & response,const int val[],int len)437 void IccFileController::SendEfLinearResult(
438 const AppExecFwk::InnerEvent::Pointer &response, const int val[], int len)
439 {
440 std::shared_ptr<AppExecFwk::EventHandler> handler = response->GetOwner();
441 std::unique_ptr<FileToControllerMsg> cmdData = response->GetUniqueObject<FileToControllerMsg>();
442 std::shared_ptr<EfLinearResult> object = std::make_shared<EfLinearResult>(cmdData.get());
443 object->valueData[0] = val[0];
444 object->valueData[1] = val[1];
445 object->valueData[MAX_FILE_INDEX] = val[MAX_FILE_INDEX];
446 int id = response->GetInnerEventId();
447 int eventParam = 0;
448 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(id, object, eventParam);
449 handler->SendEvent(event);
450 }
451
SendMultiRecordResult(const AppExecFwk::InnerEvent::Pointer & response,std::vector<std::string> & strValue)452 void IccFileController::SendMultiRecordResult(
453 const AppExecFwk::InnerEvent::Pointer &response, std::vector<std::string> &strValue)
454 {
455 std::shared_ptr<AppExecFwk::EventHandler> handler = response->GetOwner();
456 std::unique_ptr<FileToControllerMsg> cmdData = response->GetUniqueObject<FileToControllerMsg>();
457 std::shared_ptr<MultiRecordResult> object = std::make_shared<MultiRecordResult>(cmdData.get());
458 object->fileResults.assign(strValue.begin(), strValue.end());
459 object->resultLength = strValue.size();
460 int id = response->GetInnerEventId();
461 int eventParam = 0;
462 TELEPHONY_LOGI("IccFileController::SendMultiRecordResult send end");
463 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(id, object, eventParam);
464 handler->SendEvent(event);
465 }
466
BuildCallerInfo(int eventId,std::shared_ptr<IccControllerHolder> & holderObject)467 AppExecFwk::InnerEvent::Pointer IccFileController::BuildCallerInfo(
468 int eventId, std::shared_ptr<IccControllerHolder> &holderObject)
469 {
470 std::unique_ptr<IccToRilMsg> msgTo = std::make_unique<IccToRilMsg>(holderObject);
471 if (msgTo == nullptr) {
472 TELEPHONY_LOGE("IccFileController::BuildCallerInfo1 create null pointer");
473 return AppExecFwk::InnerEvent::Pointer(nullptr, nullptr);
474 }
475 int64_t eventParam = 0;
476 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(eventId, msgTo, eventParam);
477 event->SetOwner(shared_from_this());
478 return event;
479 }
480
BuildCallerInfo(int eventId,int arg1,int arg2,std::shared_ptr<IccControllerHolder> & holderObject)481 AppExecFwk::InnerEvent::Pointer IccFileController::BuildCallerInfo(
482 int eventId, int arg1, int arg2, std::shared_ptr<IccControllerHolder> &holderObject)
483 {
484 std::unique_ptr<IccToRilMsg> msgTo = std::make_unique<IccToRilMsg>(holderObject);
485 if (msgTo == nullptr) {
486 TELEPHONY_LOGE("IccFileController::BuildCallerInfo2 create null pointer");
487 return AppExecFwk::InnerEvent::Pointer(nullptr, nullptr);
488 }
489 msgTo->arg1 = arg1;
490 msgTo->arg2 = arg2;
491 int64_t eventParam = 0;
492 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(eventId, msgTo, eventParam);
493 event->SetOwner(shared_from_this());
494 return event;
495 }
496
BuildCallerInfo(int eventId,int arg1,int arg2,const AppExecFwk::InnerEvent::Pointer & msg)497 AppExecFwk::InnerEvent::Pointer IccFileController::BuildCallerInfo(
498 int eventId, int arg1, int arg2, const AppExecFwk::InnerEvent::Pointer &msg)
499 {
500 std::shared_ptr<IccControllerHolder> ctrlHolder = std::make_shared<IccControllerHolder>(arg1);
501 ctrlHolder->fileLoaded = std::move(const_cast<AppExecFwk::InnerEvent::Pointer &>(msg));
502 bool isNull = ctrlHolder->fileLoaded->GetOwner() == nullptr;
503 TELEPHONY_LOGI("IccFileController::BuildCallerInfo stage init owner: %{public}d", isNull);
504 std::unique_ptr<IccToRilMsg> msgTo = std::make_unique<IccToRilMsg>(ctrlHolder);
505 if (msgTo == nullptr) {
506 TELEPHONY_LOGE("IccFileController::BuildCallerInfo3 create null pointer");
507 return AppExecFwk::InnerEvent::Pointer(nullptr, nullptr);
508 }
509 TELEPHONY_LOGI("IccFileController::BuildCallerInfo stage end");
510 msgTo->arg1 = arg1;
511 msgTo->arg2 = arg2;
512 int64_t eventParam = 0;
513 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(eventId, msgTo, eventParam);
514 event->SetOwner(shared_from_this());
515 return event;
516 }
517
ParseFileSize(int val[],int len,const unsigned char * data)518 void IccFileController::ParseFileSize(int val[], int len, const unsigned char *data)
519 {
520 if (data == nullptr) {
521 TELEPHONY_LOGE("ParseFileSize null data");
522 return;
523 }
524 if (len > MAX_FILE_INDEX) {
525 GetFileAndDataSize(data, val[0], val[1]);
526 val[MAX_FILE_INDEX] = val[1] / val[0];
527 }
528 TELEPHONY_LOGI("ParseFileSize result %{public}d, %{public}d %{public}d", val[0], val[1], val[MAX_FILE_INDEX]);
529 }
IsValidSizeData(const unsigned char * data)530 bool IccFileController::IsValidSizeData(const unsigned char *data)
531 {
532 if (ICC_ELEMENTARY_FILE != data[TYPE_OF_FILE]) {
533 TELEPHONY_LOGE("IccFileTypeMismatch ERROR TYPE_OF_FILE");
534 return false;
535 }
536 if (ELEMENTARY_FILE_TYPE_LINEAR_FIXED != data[STRUCTURE_OF_DATA]) {
537 TELEPHONY_LOGE("IccFileTypeMismatch ERROR STRUCTURE_OF_DATA");
538 return false;
539 }
540 return true;
541 }
GetFileAndDataSize(const unsigned char * data,int & fileSize,int & dataSize)542 void IccFileController::GetFileAndDataSize(const unsigned char *data, int &fileSize, int &dataSize)
543 {
544 if (data != nullptr) {
545 fileSize = data[LENGTH_OF_RECORD] & BYTE_NUM;
546 dataSize = ((data[SIZE_ONE_OF_FILE] & BYTE_NUM) << OFFSET) + (data[SIZE_TWO_OF_FILE] & BYTE_NUM);
547 }
548 }
549
SetRilManager(std::shared_ptr<Telephony::ITelRilManager> ril)550 void IccFileController::SetRilManager(std::shared_ptr<Telephony::ITelRilManager> ril)
551 {
552 telRilManager_ = ril;
553 if (telRilManager_ == nullptr) {
554 TELEPHONY_LOGE("IccFileController set NULL TelRilManager!!");
555 }
556 }
557
CheckRightPath(const std::string & path,int fileId)558 std::string IccFileController::CheckRightPath(const std::string &path, int fileId)
559 {
560 if (path.empty()) {
561 return ObtainElementFilePath(fileId);
562 } else {
563 return path;
564 }
565 }
566
ProcessErrorResponse(const AppExecFwk::InnerEvent::Pointer & event)567 bool IccFileController::ProcessErrorResponse(const AppExecFwk::InnerEvent::Pointer &event)
568 {
569 std::shared_ptr<IccFromRilMsg> rcvMsg = event->GetSharedObject<IccFromRilMsg>();
570 if (rcvMsg == nullptr) {
571 return false;
572 }
573 AppExecFwk::InnerEvent::Pointer &response = rcvMsg->controlHolder->fileLoaded;
574 auto owner = response->GetOwner();
575 int id = response->GetInnerEventId();
576 std::unique_ptr<FileToControllerMsg> cmdData = response->GetUniqueObject<FileToControllerMsg>();
577 bool needShare = (id == MSG_SIM_OBTAIN_ICC_FILE_DONE);
578 std::unique_ptr<ControllerToFileMsg> objectUnique = nullptr;
579 std::shared_ptr<ControllerToFileMsg> objectShare = nullptr;
580 TELEPHONY_LOGI("ProcessErrorResponse start response %{public}d", needShare);
581 if (needShare) {
582 objectShare = std::make_shared<ControllerToFileMsg>(cmdData.get(), nullptr);
583 objectShare->exception = rcvMsg->fileData.exception;
584 } else {
585 objectUnique = std::make_unique<ControllerToFileMsg>(cmdData.get(), nullptr);
586 objectUnique->exception = rcvMsg->fileData.exception;
587 }
588
589 if ((objectUnique == nullptr) && (objectShare == nullptr)) {
590 TELEPHONY_LOGE("ProcessErrorResponse create ControllerToFileMsg is null");
591 return true;
592 }
593
594 TELEPHONY_LOGI("ProcessErrorResponse owner: evtId: %{public}d", id);
595 if (needShare) {
596 owner->SendEvent(id, objectShare);
597 } else {
598 owner->SendEvent(id, objectUnique);
599 }
600 TELEPHONY_LOGI("ProcessErrorResponse send end");
601 return true;
602 }
603
IsFixedNumberType(int efId)604 bool IccFileController::IsFixedNumberType(int efId)
605 {
606 bool fixed = false;
607 switch (efId) {
608 case ELEMENTARY_FILE_ADN:
609 case ELEMENTARY_FILE_FDN:
610 case ELEMENTARY_FILE_USIM_ADN:
611 case ELEMENTARY_FILE_USIM_IAP:
612 fixed = true;
613 return fixed;
614 default:
615 break;
616 }
617 return fixed;
618 }
619
~IccFileController()620 IccFileController::~IccFileController() {}
621 } // namespace Telephony
622 } // namespace OHOS
623