• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2024 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 
17 #include "telephony_sim_impl.h"
18 
19 #include "core_service_client.h"
20 #include "telephony_log_wrapper.h"
21 
22 namespace OHOS {
23 namespace Telephony {
24 
MallocCString(const std::string & origin)25     inline char* MallocCString(const std::string& origin)
26     {
27         if (origin.empty()) {
28             return nullptr;
29         }
30         auto lenth = origin.length() + 1;
31         char* res = static_cast<char*>(malloc(sizeof(char) * lenth));
32         if (res == nullptr) {
33             return nullptr;
34         }
35         return std::char_traits<char>::copy(res, origin.c_str(), lenth);
36     }
37 
ConvertCJErrCode(int32_t errCode)38     static int32_t ConvertCJErrCode(int32_t errCode)
39     {
40         switch (errCode) {
41             case TELEPHONY_ERR_ARGUMENT_MISMATCH:
42             case TELEPHONY_ERR_ARGUMENT_INVALID:
43             case TELEPHONY_ERR_ARGUMENT_NULL:
44             case TELEPHONY_ERR_SLOTID_INVALID:
45             case ERROR_SLOT_ID_INVALID:
46                 // 83000001
47                 return CJ_ERROR_TELEPHONY_ARGUMENT_ERROR;
48             case TELEPHONY_ERR_DESCRIPTOR_MISMATCH:
49             case TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL:
50             case TELEPHONY_ERR_WRITE_DATA_FAIL:
51             case TELEPHONY_ERR_WRITE_REPLY_FAIL:
52             case TELEPHONY_ERR_READ_DATA_FAIL:
53             case TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL:
54             case TELEPHONY_ERR_REGISTER_CALLBACK_FAIL:
55             case TELEPHONY_ERR_CALLBACK_ALREADY_REGISTERED:
56             case TELEPHONY_ERR_UNINIT:
57             case TELEPHONY_ERR_UNREGISTER_CALLBACK_FAIL:
58                 // 83000002
59                 return CJ_ERROR_TELEPHONY_SERVICE_ERROR;
60             case TELEPHONY_ERR_VCARD_FILE_INVALID:
61             case TELEPHONY_ERR_FAIL:
62             case TELEPHONY_ERR_MEMCPY_FAIL:
63             case TELEPHONY_ERR_MEMSET_FAIL:
64             case TELEPHONY_ERR_STRCPY_FAIL:
65             case TELEPHONY_ERR_LOCAL_PTR_NULL:
66             case TELEPHONY_ERR_SUBSCRIBE_BROADCAST_FAIL:
67             case TELEPHONY_ERR_PUBLISH_BROADCAST_FAIL:
68             case TELEPHONY_ERR_ADD_DEATH_RECIPIENT_FAIL:
69             case TELEPHONY_ERR_STRTOINT_FAIL:
70             case TELEPHONY_ERR_RIL_CMD_FAIL:
71             case TELEPHONY_ERR_DATABASE_WRITE_FAIL:
72             case TELEPHONY_ERR_DATABASE_READ_FAIL:
73             case TELEPHONY_ERR_UNKNOWN_NETWORK_TYPE:
74             case ERROR_SERVICE_UNAVAILABLE:
75             case ERROR_NATIVE_API_EXECUTE_FAIL:
76                 // 83000003
77                 return CJ_ERROR_TELEPHONY_SYSTEM_ERROR;
78             case TELEPHONY_ERR_NO_SIM_CARD:
79                 // 83000004
80                 return CJ_ERROR_TELEPHONY_NO_SIM_CARD;
81             case TELEPHONY_ERR_AIRPLANE_MODE_ON:
82                 // 83000005
83                 return CJ_ERROR_TELEPHONY_AIRPLANE_MODE_ON;
84             case TELEPHONY_ERR_NETWORK_NOT_IN_SERVICE:
85                 // 83000006
86                 return CJ_ERROR_TELEPHONY_NETWORK_NOT_IN_SERVICE;
87             case TELEPHONY_ERR_PERMISSION_ERR:
88                 // 201
89                 return CJ_ERROR_TELEPHONY_PERMISSION_DENIED;
90             case TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API:
91                 // 202
92                 return CJ_ERROR_TELEPHONY_PERMISSION_DENIED;
93             default:
94                 return errCode;
95         }
96     }
97 
IsValidSlotId(int32_t slotId)98     static inline bool IsValidSlotId(int32_t slotId)
99     {
100         return ((slotId >= DEFAULT_SIM_SLOT_ID) && (slotId < SIM_SLOT_COUNT));
101     }
102 
IsValidSlotIdEx(int32_t slotId)103     static inline bool IsValidSlotIdEx(int32_t slotId)
104     {
105         // One more slot for VSim.
106         return ((slotId >= DEFAULT_SIM_SLOT_ID) && (slotId < SIM_SLOT_COUNT + 1));
107     }
108 
ToUtf8(std::u16string str16)109     static std::string ToUtf8(std::u16string str16)
110     {
111         std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
112         // 将std::u16string转换为std::string
113         std::string result = convert.to_bytes(str16);
114         return result;
115     }
116 
IsSimActive(int32_t slotId,int32_t & errCode)117     bool TelephonySimImpl::IsSimActive(int32_t slotId, int32_t &errCode)
118     {
119         bool result = false;
120         if (!IsValidSlotId(slotId)) {
121             TELEPHONY_LOGE("NativeIsSimActive slotId is invalid");
122             errCode = ConvertCJErrCode(ERROR_SLOT_ID_INVALID);
123             return result;
124         }
125         result = DelayedRefSingleton<CoreServiceClient>::GetInstance().IsSimActive(slotId);
126         return result;
127     }
128 
getDefaultVoiceSlotId()129     int32_t TelephonySimImpl::getDefaultVoiceSlotId()
130     {
131         int32_t slotId = -1;
132         slotId = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetDefaultVoiceSlotId();
133         return slotId;
134     }
135 
hasOperatorPrivileges(int32_t slotId,int32_t & errCode)136     bool TelephonySimImpl::hasOperatorPrivileges(int32_t slotId, int32_t &errCode)
137     {
138         bool hasOperatorPrivileges = false;
139         if (!IsValidSlotId(slotId)) {
140             TELEPHONY_LOGE("NativeHasOperatorPrivileges slotId is invalid");
141             errCode = ConvertCJErrCode(ERROR_SLOT_ID_INVALID);
142             return hasOperatorPrivileges;
143         }
144         errCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().HasOperatorPrivileges(
145             slotId, hasOperatorPrivileges);
146         errCode = ConvertCJErrCode(errCode);
147         return hasOperatorPrivileges;
148     }
149 
getISOCountryCodeForSim(int32_t slotId,int32_t & errCode)150     char* TelephonySimImpl::getISOCountryCodeForSim(int32_t slotId, int32_t &errCode)
151     {
152         if (!IsValidSlotId(slotId)) {
153             TELEPHONY_LOGE("NativeGetIsoForSim slotId is invalid");
154             errCode = ConvertCJErrCode(ERROR_SLOT_ID_INVALID);
155             return nullptr;
156         }
157         std::u16string countryCode = u"";
158         std::string operatorName;
159         errCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetISOCountryCodeForSim(
160             slotId, countryCode);
161         operatorName = errCode == ERROR_NONE ? ToUtf8(countryCode) : "";
162         errCode = ConvertCJErrCode(errCode);
163         char* result = MallocCString(operatorName);
164         return result;
165     }
166 
getSimOperatorNumeric(int32_t slotId,int32_t & errCode)167     char* TelephonySimImpl::getSimOperatorNumeric(int32_t slotId, int32_t &errCode)
168     {
169         if (!IsValidSlotId(slotId)) {
170             TELEPHONY_LOGE("NativeGetSimOperatorNumeric slotId is invalid");
171             errCode = ConvertCJErrCode(ERROR_SLOT_ID_INVALID);
172             return nullptr;
173         }
174         std::u16string u16OperatorNumeric = u"";
175         errCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetSimOperatorNumeric(
176             slotId, u16OperatorNumeric);
177         std::string operatorNumeric = errCode == ERROR_NONE ? ToUtf8(u16OperatorNumeric) : "";
178         errCode = ConvertCJErrCode(errCode);
179         char* result = MallocCString(operatorNumeric);
180         return result;
181     }
182 
getSimSpn(int32_t slotId,int32_t & errCode)183     char* TelephonySimImpl::getSimSpn(int32_t slotId, int32_t &errCode)
184     {
185         if (!IsValidSlotId(slotId)) {
186             TELEPHONY_LOGE("NativeGetSimSpn slotId is invalid");
187             errCode = ConvertCJErrCode(ERROR_SLOT_ID_INVALID);
188             return nullptr;
189         }
190         std::u16string u16Spn = u"";
191         errCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetSimSpn(slotId, u16Spn);
192         std::string spn = errCode == ERROR_NONE ? ToUtf8(u16Spn) : "";
193         errCode = ConvertCJErrCode(errCode);
194         char* result = MallocCString(spn);
195         return result;
196     }
197 
getSimState(int32_t slotId,int32_t & errCode)198     int32_t TelephonySimImpl::getSimState(int32_t slotId, int32_t &errCode)
199     {
200         SimState simState = SimState::SIM_STATE_UNKNOWN;
201         if (!IsValidSlotId(slotId)) {
202             TELEPHONY_LOGE("slotId is invalid");
203             errCode = ConvertCJErrCode(ERROR_SLOT_ID_INVALID);
204             return static_cast<int32_t>(simState);
205         }
206         errCode =
207             DelayedRefSingleton<CoreServiceClient>::GetInstance().GetSimState(slotId, simState);
208         errCode = ConvertCJErrCode(errCode);
209         return static_cast<int32_t>(simState);
210     }
211 
getCardType(int32_t slotId,int32_t & errCode)212     int32_t TelephonySimImpl::getCardType(int32_t slotId, int32_t &errCode)
213     {
214         CardType cardType = CardType::UNKNOWN_CARD;
215         if (!IsValidSlotId(slotId)) {
216             TELEPHONY_LOGE("NativeGetCardType slotId is invalid");
217             errCode = ConvertCJErrCode(ERROR_SLOT_ID_INVALID);
218             return static_cast<int32_t>(cardType);
219         }
220         errCode =
221             DelayedRefSingleton<CoreServiceClient>::GetInstance().GetCardType(slotId, cardType);
222         errCode = ConvertCJErrCode(errCode);
223         return static_cast<int32_t>(cardType);
224     }
225 
hasSimCard(int32_t slotId,int32_t & errCode)226     bool TelephonySimImpl::hasSimCard(int32_t slotId, int32_t &errCode)
227     {
228         bool hasSimCard = false;
229         if (!IsValidSlotIdEx(slotId)) {
230             TELEPHONY_LOGE("slotId is invalid");
231             errCode = ConvertCJErrCode(ERROR_SLOT_ID_INVALID);
232             return hasSimCard;
233         }
234         errCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().HasSimCard(slotId, hasSimCard);
235         errCode = ConvertCJErrCode(errCode);
236         return hasSimCard;
237     }
238 
IccAccountInfoConversion(CIccAccountInfo & accountInfo,const IccAccountInfo & iccAccountInfo)239     static void IccAccountInfoConversion(CIccAccountInfo &accountInfo, const IccAccountInfo &iccAccountInfo)
240     {
241         accountInfo.simId = iccAccountInfo.simId;
242         accountInfo.slotIndex = iccAccountInfo.slotIndex;
243         accountInfo.isEsim = iccAccountInfo.isEsim;
244         accountInfo.isActive = iccAccountInfo.isActive;
245         accountInfo.iccId = MallocCString(ToUtf8(iccAccountInfo.iccId));
246         accountInfo.showName = MallocCString(ToUtf8(iccAccountInfo.showName));
247         accountInfo.showNumber = MallocCString(ToUtf8(iccAccountInfo.showNumber));
248     }
249 
getSimAccountInfo(int32_t slotId,int32_t & errCode)250     CIccAccountInfo TelephonySimImpl::getSimAccountInfo(int32_t slotId, int32_t &errCode)
251     {
252         CIccAccountInfo accountInfo = {
253             .simId = 0,
254             .slotIndex = 0,
255             .isEsim = false,
256             .isActive = false,
257             .iccId = nullptr,
258             .showName = nullptr,
259             .showNumber = nullptr
260         };
261         if (!IsValidSlotIdEx(slotId)) {
262             TELEPHONY_LOGE("NativeGetSimAccountInfo slotId is invalid");
263             errCode = ConvertCJErrCode(ERROR_SLOT_ID_INVALID);
264             return accountInfo;
265         }
266         IccAccountInfo operInfo;
267         errCode =
268             DelayedRefSingleton<CoreServiceClient>::GetInstance().GetSimAccountInfo(slotId, operInfo);
269         if (errCode == ERROR_NONE) {
270             IccAccountInfoConversion(accountInfo, operInfo);
271         }
272         errCode = ConvertCJErrCode(errCode);
273         return accountInfo;
274     }
275 
getActiveSimAccountInfoList(int32_t & errCode)276     CArryIccAccountInfo TelephonySimImpl::getActiveSimAccountInfoList(int32_t &errCode)
277     {
278         std::vector<IccAccountInfo> activeInfo;
279         CArryIccAccountInfo accountInfoList = {
280             .head = nullptr,
281             .size = 0
282         };
283         errCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetActiveSimAccountInfoList(activeInfo);
284         if (errCode == ERROR_NONE) {
285             size_t infoSize = activeInfo.size();
286             CIccAccountInfo* head = nullptr;
287             if (infoSize > 0) {
288                 head = reinterpret_cast<CIccAccountInfo *>(malloc(sizeof(CIccAccountInfo) * infoSize));
289             }
290             if (head == nullptr && infoSize > 0) {
291                 TELEPHONY_LOGE("NativeGetSimAccountInfo malloc failed!");
292                 return accountInfoList;
293             }
294             for (size_t i = 0; i < infoSize; i++) {
295                 IccAccountInfoConversion(head[i], activeInfo.at(i));
296             }
297             accountInfoList.head = head;
298             accountInfoList.size = static_cast<int64_t>(infoSize);
299         }
300         errCode = ConvertCJErrCode(errCode);
301         return accountInfoList;
302     }
303 
getMaxSimCount()304     int32_t TelephonySimImpl::getMaxSimCount()
305     {
306         return DelayedRefSingleton<CoreServiceClient>::GetInstance().GetMaxSimCount();
307     }
308 
getOpKey(int32_t slotId,int32_t & errCode)309     char* TelephonySimImpl::getOpKey(int32_t slotId, int32_t &errCode)
310     {
311         if (!IsValidSlotId(slotId)) {
312             TELEPHONY_LOGE("NativeGetOpKey slotId is invalid");
313             errCode = ConvertCJErrCode(ERROR_SLOT_ID_INVALID);
314             return nullptr;
315         }
316         std::u16string u16Opkey = u"";
317         errCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetOpKey(slotId, u16Opkey);
318         std::string opkey = errCode == ERROR_NONE ? ToUtf8(u16Opkey) : "";
319         errCode = ConvertCJErrCode(errCode);
320         char* result = MallocCString(opkey);
321         return result;
322     }
323 
getOpName(int32_t slotId,int32_t & errCode)324     char* TelephonySimImpl::getOpName(int32_t slotId, int32_t &errCode)
325     {
326         if (!IsValidSlotId(slotId)) {
327             TELEPHONY_LOGE("NativeGetOpName slotId is invalid");
328             errCode = ConvertCJErrCode(ERROR_SLOT_ID_INVALID);
329             return nullptr;
330         }
331         std::u16string u16OpName = u"";
332         errCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetOpName(slotId, u16OpName);
333         std::string opName = errCode == ERROR_NONE ? ToUtf8(u16OpName) : "";
334         errCode = ConvertCJErrCode(errCode);
335         char* result = MallocCString(opName);
336         return result;
337     }
338 
getDefaultVoiceSimId(int32_t & errCode)339     int32_t TelephonySimImpl::getDefaultVoiceSimId(int32_t &errCode)
340     {
341         int32_t simId = 0;
342         errCode = DelayedRefSingleton<CoreServiceClient>::GetInstance().GetDefaultVoiceSimId(simId);
343         errCode = ConvertCJErrCode(errCode);
344         return simId;
345     }
346 }
347 }