• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "enum_convert.h"
17 
18 namespace OHOS {
19 namespace Telephony {
GetBoolValue(int32_t value)20 std::string GetBoolValue(int32_t value)
21 {
22     std::string result = "";
23     if (value == 0) {
24         result = "FALSE";
25     } else {
26         result = "TRUE";
27     }
28     return result;
29 }
30 
GetSimState(int32_t state)31 std::string GetSimState(int32_t state)
32 {
33     std::string result = "";
34     switch (static_cast<TelephonySimState>(state)) {
35         case TelephonySimState::SIM_STATE_UNKNOWN:
36             result = "SIM_STATE_UNKNOWN";
37             break;
38         case TelephonySimState::SIM_STATE_NOT_PRESENT:
39             result = "SIM_STATE_NOT_PRESENT";
40             break;
41         case TelephonySimState::SIM_STATE_LOCKED:
42             result = "SIM_STATE_LOCKED";
43             break;
44         case TelephonySimState::SIM_STATE_NOT_READY:
45             result = "SIM_STATE_NOT_READY";
46             break;
47         case TelephonySimState::SIM_STATE_READY:
48             result = "SIM_STATE_READY";
49             break;
50         case TelephonySimState::SIM_STATE_LOADED:
51             result = "SIM_STATE_LOADED";
52             break;
53         default:
54             break;
55     }
56     return result;
57 }
58 
GetCallState(int32_t state)59 std::string GetCallState(int32_t state)
60 {
61     std::string result = "CALL_STATUS_IDLE";
62     switch (static_cast<TelephonyCallState>(state)) {
63         case TelephonyCallState::CALL_STATUS_ACTIVE:
64             result = "CALL_STATUS_ACTIVE";
65             break;
66         case TelephonyCallState::CALL_STATUS_HOLDING:
67             result = "CALL_STATUS_HOLDING";
68             break;
69         case TelephonyCallState::CALL_STATUS_DIALING:
70             result = "CALL_STATUS_DIALING";
71             break;
72         case TelephonyCallState::CALL_STATUS_ALERTING:
73             result = "CALL_STATUS_ALERTING";
74             break;
75         case TelephonyCallState::CALL_STATUS_INCOMING:
76             result = "CALL_STATUS_INCOMING";
77             break;
78         case TelephonyCallState::CALL_STATUS_WAITING:
79             result = "CALL_STATUS_WAITING";
80             break;
81         case TelephonyCallState::CALL_STATUS_DISCONNECTED:
82             result = "CALL_STATUS_DISCONNECTED";
83             break;
84         case TelephonyCallState::CALL_STATUS_DISCONNECTING:
85             result = "CALL_STATUS_DISCONNECTING";
86             break;
87         case TelephonyCallState::CALL_STATUS_IDLE:
88             result = "CALL_STATUS_IDLE";
89             break;
90         default:
91             break;
92     }
93     return result;
94 }
95 
GetCardType(int32_t type)96 std::string GetCardType(int32_t type)
97 {
98     std::string result = "";
99     switch (static_cast<TelephonyCardType>(type)) {
100         case TelephonyCardType::UNKNOWN_CARD:
101             result = "UNKNOWN_CARD";
102             break;
103         case TelephonyCardType::SINGLE_MODE_SIM_CARD:
104             result = "SINGLE_MODE_SIM_CARD";
105             break;
106         case TelephonyCardType::SINGLE_MODE_USIM_CARD:
107             result = "SINGLE_MODE_USIM_CARD";
108             break;
109         case TelephonyCardType::SINGLE_MODE_RUIM_CARD:
110             result = "SINGLE_MODE_RUIM_CARD";
111             break;
112         case TelephonyCardType::DUAL_MODE_CG_CARD:
113             result = "DUAL_MODE_CG_CARD";
114             break;
115         case TelephonyCardType::CT_NATIONAL_ROAMING_CARD:
116             result = "CT_NATIONAL_ROAMING_CARD";
117             break;
118         case TelephonyCardType::CU_DUAL_MODE_CARD:
119             result = "CU_DUAL_MODE_CARD";
120             break;
121         case TelephonyCardType::DUAL_MODE_TELECOM_LTE_CARD:
122             result = "DUAL_MODE_TELECOM_LTE_CARD";
123             break;
124         case TelephonyCardType::DUAL_MODE_UG_CARD:
125             result = "DUAL_MODE_UG_CARD";
126             break;
127         case TelephonyCardType::SINGLE_MODE_ISIM_CARD:
128             result = "SINGLE_MODE_ISIM_CARD";
129             break;
130         default:
131             break;
132     }
133     return result;
134 }
135 
GetCellularDataConnectionState(int32_t state)136 std::string GetCellularDataConnectionState(int32_t state)
137 {
138     std::string result = "";
139     switch (static_cast<TelephonyDataConnectionStatus>(state)) {
140         case TelephonyDataConnectionStatus::DATA_STATE_DISCONNECTED:
141             result = "DATA_STATE_DISCONNECTED";
142             break;
143         case TelephonyDataConnectionStatus::DATA_STATE_CONNECTING:
144             result = "DATA_STATE_CONNECTING";
145             break;
146         case TelephonyDataConnectionStatus::DATA_STATE_CONNECTED:
147             result = "DATA_STATE_CONNECTED";
148             break;
149         case TelephonyDataConnectionStatus::DATA_STATE_SUSPENDED:
150             result = "DATA_STATE_SUSPENDED";
151             break;
152         default:
153             break;
154     }
155     return result;
156 }
157 
GetCellularDataFlow(int32_t flowData)158 std::string GetCellularDataFlow(int32_t flowData)
159 {
160     std::string result = "";
161     switch (static_cast<TelephonyCellDataFlowType>(flowData)) {
162         case TelephonyCellDataFlowType::DATA_FLOW_TYPE_NONE:
163             result = "DATA_FLOW_TYPE_NONE";
164             break;
165         case TelephonyCellDataFlowType::DATA_FLOW_TYPE_DOWN:
166             result = "DATA_FLOW_TYPE_DOWN";
167             break;
168         case TelephonyCellDataFlowType::DATA_FLOW_TYPE_UP:
169             result = "DATA_FLOW_TYPE_UP";
170             break;
171         case TelephonyCellDataFlowType::DATA_FLOW_TYPE_UP_DOWN:
172             result = "DATA_FLOW_TYPE_UP_DOWN";
173             break;
174         case TelephonyCellDataFlowType::DATA_FLOW_TYPE_DORMANT:
175             result = "DATA_FLOW_TYPE_DORMANT";
176             break;
177         default:
178             break;
179     }
180     return result;
181 }
182 
GetCellularDataConnectionNetworkType(int32_t type)183 std::string GetCellularDataConnectionNetworkType(int32_t type)
184 {
185     std::string result = "";
186     switch (static_cast<TelephonyRadioTech>(type)) {
187         case TelephonyRadioTech::RADIO_TECHNOLOGY_UNKNOWN:
188             result = "RADIO_TECHNOLOGY_UNKNOWN";
189             break;
190         case TelephonyRadioTech::RADIO_TECHNOLOGY_GSM:
191             result = "RADIO_TECHNOLOGY_GSM";
192             break;
193         case TelephonyRadioTech::RADIO_TECHNOLOGY_1XRTT:
194             result = "RADIO_TECHNOLOGY_1XRTT";
195             break;
196         case TelephonyRadioTech::RADIO_TECHNOLOGY_WCDMA:
197             result = "RADIO_TECHNOLOGY_WCDMA";
198             break;
199         case TelephonyRadioTech::RADIO_TECHNOLOGY_HSPA:
200             result = "RADIO_TECHNOLOGY_HSPA";
201             break;
202         case TelephonyRadioTech::RADIO_TECHNOLOGY_HSPAP:
203             result = "RADIO_TECHNOLOGY_HSPAP";
204             break;
205         case TelephonyRadioTech::RADIO_TECHNOLOGY_TD_SCDMA:
206             result = "RADIO_TECHNOLOGY_TD_SCDMA";
207             break;
208         case TelephonyRadioTech::RADIO_TECHNOLOGY_EVDO:
209             result = "RADIO_TECHNOLOGY_EVDO";
210             break;
211         case TelephonyRadioTech::RADIO_TECHNOLOGY_EHRPD:
212             result = "RADIO_TECHNOLOGY_EHRPD";
213             break;
214         case TelephonyRadioTech::RADIO_TECHNOLOGY_LTE:
215             result = "RADIO_TECHNOLOGY_LTE";
216             break;
217         case TelephonyRadioTech::RADIO_TECHNOLOGY_LTE_CA:
218             result = "RADIO_TECHNOLOGY_LTE_CA";
219             break;
220         case TelephonyRadioTech::RADIO_TECHNOLOGY_IWLAN:
221             result = "RADIO_TECHNOLOGY_IWLAN";
222             break;
223         case TelephonyRadioTech::RADIO_TECHNOLOGY_NR:
224             result = "RADIO_TECHNOLOGY_NR";
225             break;
226         default:
227             break;
228     }
229     return result;
230 }
231 
GetLockReason(int32_t reason)232 std::string GetLockReason(int32_t reason)
233 {
234     std::string result = "";
235     switch (static_cast<TelephonyLockReason>(reason)) {
236         case TelephonyLockReason::SIM_NONE:
237             result = "SIM_NONE";
238             break;
239         case TelephonyLockReason::SIM_PIN:
240             result = "SIM_PIN";
241             break;
242         case TelephonyLockReason::SIM_PUK:
243             result = "SIM_PUK";
244             break;
245         case TelephonyLockReason::SIM_PN_PIN:
246             result = "SIM_PN_PIN";
247             break;
248         case TelephonyLockReason::SIM_PN_PUK:
249             result = "SIM_PN_PUK";
250             break;
251         case TelephonyLockReason::SIM_PU_PIN:
252             result = "SIM_PU_PIN";
253             break;
254         case TelephonyLockReason::SIM_PU_PUK:
255             result = "SIM_PU_PUK";
256             break;
257         case TelephonyLockReason::SIM_PP_PIN:
258             result = "SIM_PP_PIN";
259             break;
260         case TelephonyLockReason::SIM_PP_PUK:
261             result = "SIM_PP_PUK";
262             break;
263         case TelephonyLockReason::SIM_PC_PIN:
264             result = "SIM_PC_PIN";
265             break;
266         case TelephonyLockReason::SIM_PC_PUK:
267             result = "SIM_PC_PUK";
268             break;
269         case TelephonyLockReason::SIM_SIM_PIN:
270             result = "SIM_SIM_PIN";
271             break;
272         case TelephonyLockReason::SIM_SIM_PUK:
273             result = "SIM_SIM_PUK";
274             break;
275         default:
276             break;
277     }
278     return result;
279 }
280 } // namespace Telephony
281 } // namespace OHOS
282