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 "tel_cellular_data_log.h"
18 #include "tel_cellular_data_impl.h"
19 
20 #include <memory>
21 
22 #include "cellular_data_client.h"
23 #include "cellular_data_types.h"
24 #include "cstddef"
25 #include "iosfwd"
26 #include "napi_util.h"
27 #include "node_api.h"
28 #include "string"
29 #include "telephony_napi_common_error.h"
30 #include "telephony_types.h"
31 
32 namespace OHOS {
33 namespace Telephony {
34 
IsCellularDataManagerInited()35     static bool IsCellularDataManagerInited()
36     {
37         return CellularDataClient::GetInstance().IsConnect();
38     }
39 
IsValidSlotId(int32_t slotId)40     static inline bool IsValidSlotId(int32_t slotId)
41     {
42         return ((slotId >= DEFAULT_SIM_SLOT_ID) && (slotId < SIM_SLOT_COUNT));
43     }
44 
WrapCellularDataType(const int32_t cellularDataType)45     static int32_t WrapCellularDataType(const int32_t cellularDataType)
46     {
47         switch (cellularDataType) {
48             case static_cast<int32_t>(DataConnectionStatus::DATA_STATE_DISCONNECTED): {
49                 return static_cast<int32_t>(DataConnectState::DATA_STATE_DISCONNECTED);
50             }
51             case static_cast<int32_t>(DataConnectionStatus::DATA_STATE_CONNECTING): {
52                 return static_cast<int32_t>(DataConnectState::DATA_STATE_CONNECTING);
53             }
54             case static_cast<int32_t>(DataConnectionStatus::DATA_STATE_CONNECTED): {
55                 return static_cast<int32_t>(DataConnectState::DATA_STATE_CONNECTED);
56             }
57             case static_cast<int32_t>(DataConnectionStatus::DATA_STATE_SUSPENDED): {
58                 return static_cast<int32_t>(DataConnectState::DATA_STATE_SUSPENDED);
59             }
60             default: {
61                 return static_cast<int32_t>(DataConnectState::DATA_STATE_UNKNOWN);
62             }
63         }
64     }
65 
WrapGetCellularDataFlowTypeType(const int32_t cellularDataType)66     static int32_t WrapGetCellularDataFlowTypeType(const int32_t cellularDataType)
67     {
68         switch (cellularDataType) {
69             case static_cast<int32_t>(CellDataFlowType::DATA_FLOW_TYPE_NONE): {
70                 return static_cast<int32_t>(CellDataFlowType::DATA_FLOW_TYPE_NONE);
71             }
72             case static_cast<int32_t>(CellDataFlowType::DATA_FLOW_TYPE_DOWN): {
73                 return static_cast<int32_t>(CellDataFlowType::DATA_FLOW_TYPE_DOWN);
74             }
75             case static_cast<int32_t>(CellDataFlowType::DATA_FLOW_TYPE_UP): {
76                 return static_cast<int32_t>(CellDataFlowType::DATA_FLOW_TYPE_UP);
77             }
78             case static_cast<int32_t>(CellDataFlowType::DATA_FLOW_TYPE_UP_DOWN): {
79                 return static_cast<int32_t>(CellDataFlowType::DATA_FLOW_TYPE_UP_DOWN);
80             }
81             case static_cast<int32_t>(CellDataFlowType::DATA_FLOW_TYPE_DORMANT): {
82                 return static_cast<int32_t>(CellDataFlowType::DATA_FLOW_TYPE_DORMANT);
83             }
84             default: {
85                 return static_cast<int32_t>(CellDataFlowType::DATA_FLOW_TYPE_NONE);
86             }
87         }
88     }
89 
ConvertCJErrCode(int32_t errCode)90     static int32_t ConvertCJErrCode(int32_t errCode)
91     {
92         switch (errCode) {
93             case TELEPHONY_ERR_ARGUMENT_MISMATCH:
94             case TELEPHONY_ERR_ARGUMENT_INVALID:
95             case TELEPHONY_ERR_ARGUMENT_NULL:
96             case TELEPHONY_ERR_SLOTID_INVALID:
97             case ERROR_SLOT_ID_INVALID:
98                 // 83000001
99                 return CJ_ERROR_TELEPHONY_ARGUMENT_ERROR;
100             case TELEPHONY_ERR_DESCRIPTOR_MISMATCH:
101             case TELEPHONY_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL:
102             case TELEPHONY_ERR_WRITE_DATA_FAIL:
103             case TELEPHONY_ERR_READ_DATA_FAIL:
104             case TELEPHONY_ERR_WRITE_REPLY_FAIL:
105             case TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL:
106             case TELEPHONY_ERR_REGISTER_CALLBACK_FAIL:
107             case TELEPHONY_ERR_CALLBACK_ALREADY_REGISTERED:
108             case TELEPHONY_ERR_UNINIT:
109             case TELEPHONY_ERR_UNREGISTER_CALLBACK_FAIL:
110                 // 83000002
111                 return CJ_ERROR_TELEPHONY_SERVICE_ERROR;
112             case TELEPHONY_ERR_VCARD_FILE_INVALID:
113             case TELEPHONY_ERR_FAIL:
114             case TELEPHONY_ERR_MEMCPY_FAIL:
115             case TELEPHONY_ERR_MEMSET_FAIL:
116             case TELEPHONY_ERR_STRCPY_FAIL:
117             case TELEPHONY_ERR_LOCAL_PTR_NULL:
118             case TELEPHONY_ERR_SUBSCRIBE_BROADCAST_FAIL:
119             case TELEPHONY_ERR_PUBLISH_BROADCAST_FAIL:
120             case TELEPHONY_ERR_STRTOINT_FAIL:
121             case TELEPHONY_ERR_ADD_DEATH_RECIPIENT_FAIL:
122             case TELEPHONY_ERR_RIL_CMD_FAIL:
123             case TELEPHONY_ERR_DATABASE_WRITE_FAIL:
124             case TELEPHONY_ERR_DATABASE_READ_FAIL:
125             case TELEPHONY_ERR_UNKNOWN_NETWORK_TYPE:
126                 // 83000003
127                 return CJ_ERROR_TELEPHONY_SYSTEM_ERROR;
128             case TELEPHONY_ERR_NO_SIM_CARD:
129                 // 83000004
130                 return CJ_ERROR_TELEPHONY_NO_SIM_CARD;
131             case TELEPHONY_ERR_AIRPLANE_MODE_ON:
132                 // 83000005
133                 return CJ_ERROR_TELEPHONY_AIRPLANE_MODE_ON;
134             case TELEPHONY_ERR_NETWORK_NOT_IN_SERVICE:
135                 // 83000006
136                 return CJ_ERROR_TELEPHONY_NETWORK_NOT_IN_SERVICE;
137             case TELEPHONY_ERR_PERMISSION_ERR:
138                 // 201
139                 return CJ_ERROR_TELEPHONY_PERMISSION_DENIED;
140             case TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API:
141                 // 202
142                 return CJ_ERROR_TELEPHONY_PERMISSION_DENIED;
143             default:
144                 return errCode;
145         }
146     }
147 
GetDefaultCellularDataSlotId()148     int32_t CellularDataImpl::GetDefaultCellularDataSlotId()
149     {
150         return CellularDataClient::GetInstance().GetDefaultCellularDataSlotId();
151     }
152 
GetCellularDataFlowType(int32_t &errCode)153     int32_t CellularDataImpl::GetCellularDataFlowType(int32_t &errCode)
154     {
155         int32_t dataState = 0;
156         if (IsCellularDataManagerInited()) {
157             dataState = CellularDataClient::GetInstance().GetCellularDataFlowType();
158             dataState = WrapGetCellularDataFlowTypeType(dataState);
159             errCode = ERROR_NONE;
160         } else {
161             errCode = ERROR_SERVICE_UNAVAILABLE;
162         }
163         return dataState;
164     }
165 
GetCellularDataState(int32_t &errCode)166     int32_t CellularDataImpl::GetCellularDataState(int32_t &errCode)
167     {
168         int32_t dataState = 0;
169         if (IsCellularDataManagerInited()) {
170             dataState = CellularDataClient::GetInstance().GetCellularDataState();
171             dataState = WrapCellularDataType(dataState);
172             errCode = ERROR_NONE;
173         } else {
174             errCode = ERROR_SERVICE_UNAVAILABLE;
175         }
176         return dataState;
177     }
178 
IsCellularDataEnabled(int32_t &errCode)179     bool CellularDataImpl::IsCellularDataEnabled(int32_t &errCode)
180     {
181         bool enabled = false;
182         if (IsCellularDataManagerInited()) {
183             errCode = CellularDataClient::GetInstance().IsCellularDataEnabled(enabled);
184         } else {
185             errCode = ERROR_SERVICE_UNAVAILABLE;
186         }
187         errCode = ConvertCJErrCode(errCode);
188         return enabled;
189     }
190 
IsCellularDataRoamingEnabled(int32_t slotId, int32_t &errCode)191     bool CellularDataImpl::IsCellularDataRoamingEnabled(int32_t slotId, int32_t &errCode)
192     {
193         bool enabled = false;
194         if (!IsValidSlotId(slotId)) {
195             LOGE("CellularDataImpl::IsCellularDataRoamingEnabled slotId is invalid");
196             errCode = ConvertCJErrCode(ERROR_SLOT_ID_INVALID);
197             return enabled;
198         }
199 
200         if (IsCellularDataManagerInited()) {
201             errCode = CellularDataClient::GetInstance().IsCellularDataRoamingEnabled(slotId, enabled);
202         } else {
203             errCode = ERROR_SERVICE_UNAVAILABLE;
204         }
205         errCode = ConvertCJErrCode(errCode);
206         return enabled;
207     }
208 
GetDefaultCellularDataSimId()209     int32_t CellularDataImpl::GetDefaultCellularDataSimId()
210     {
211         int32_t simId = 0;
212         CellularDataClient::GetInstance().GetDefaultCellularDataSimId(simId);
213         return simId;
214     }
215 }
216 }