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 "cellular_data_service.h"
17
18 #include "cellular_data_dump_helper.h"
19 #include "cellular_data_error.h"
20 #include "cellular_data_hisysevent.h"
21 #include "cellular_data_net_agent.h"
22 #include "core_manager_inner.h"
23 #include "data_connection_monitor.h"
24 #include "net_specifier.h"
25 #include "string_ex.h"
26 #include "system_ability_definition.h"
27 #include "telephony_ext_wrapper.h"
28 #include "telephony_common_utils.h"
29 #include "telephony_log_wrapper.h"
30 #include "telephony_permission.h"
31 #include "data_service_ext_wrapper.h"
32
33 namespace OHOS {
34 namespace Telephony {
35 using namespace NetManagerStandard;
36
37 bool g_registerResult = SystemAbility::MakeAndRegisterAbility(&DelayedRefSingleton<CellularDataService>::GetInstance());
CellularDataService()38 CellularDataService::CellularDataService()
39 : SystemAbility(TELEPHONY_CELLULAR_DATA_SYS_ABILITY_ID, true), registerToService_(false),
40 state_(ServiceRunningState::STATE_NOT_START)
41 {}
42
43 CellularDataService::~CellularDataService() = default;
44
OnStart()45 void CellularDataService::OnStart()
46 {
47 beginTime_ =
48 std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
49 .count();
50 if (state_ == ServiceRunningState::STATE_RUNNING) {
51 TELEPHONY_LOGE("CellularDataService has already started.");
52 return;
53 }
54 if (!Init()) {
55 TELEPHONY_LOGE("failed to init CellularDataService");
56 return;
57 }
58 state_ = ServiceRunningState::STATE_RUNNING;
59 endTime_ =
60 std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
61 .count();
62 TELEPHONY_LOGI("start service success.");
63 }
64
OnStop()65 void CellularDataService::OnStop()
66 {
67 TELEPHONY_LOGI("ready to stop service.");
68 state_ = ServiceRunningState::STATE_NOT_START;
69 registerToService_ = false;
70 UnRegisterAllNetSpecifier();
71 }
72
Dump(std::int32_t fd,const std::vector<std::u16string> & args)73 int32_t CellularDataService::Dump(std::int32_t fd, const std::vector<std::u16string> &args)
74 {
75 std::vector<std::string> argsInStr;
76 std::string result;
77 CellularDataDumpHelper dumpHelper;
78 if (fd < 0) {
79 TELEPHONY_LOGE("Dump fd invalid");
80 return TELEPHONY_ERR_FAIL;
81 }
82 for (const std::u16string &arg : args) {
83 TELEPHONY_LOGI("Dump args: %s", Str16ToStr8(arg).c_str());
84 argsInStr.emplace_back(Str16ToStr8(arg));
85 }
86 if (dumpHelper.Dump(argsInStr, result)) {
87 int32_t ret = dprintf(fd, "%s", result.c_str());
88 if (ret < 0) {
89 TELEPHONY_LOGE("dprintf to dump fd failed");
90 return TELEPHONY_ERR_FAIL;
91 }
92 return TELEPHONY_SUCCESS;
93 }
94 TELEPHONY_LOGW("dumpHelper failed");
95 return TELEPHONY_ERR_FAIL;
96 }
97
Init()98 bool CellularDataService::Init()
99 {
100 #ifdef OHOS_BUILD_ENABLE_TELEPHONY_EXT
101 TELEPHONY_EXT_WRAPPER.InitTelephonyExtWrapper();
102 #endif
103 #ifdef OHOS_BUILD_ENABLE_DATA_SERVICE_EXT
104 DATA_SERVICE_EXT_WRAPPER.InitDataServiceExtWrapper();
105 #endif
106 InitModule();
107 if (!registerToService_) {
108 bool ret = Publish(DelayedRefSingleton<CellularDataService>::GetInstance().AsObject());
109 if (!ret) {
110 TELEPHONY_LOGE("Publish failed!");
111 return false;
112 }
113 registerToService_ = true;
114 }
115 for (const std::pair<const int32_t, std::shared_ptr<CellularDataController>> &it : cellularDataControllers_) {
116 if (it.second != nullptr) {
117 it.second->AsynchronousRegister();
118 } else {
119 TELEPHONY_LOGE("CellularDataController is null");
120 }
121 }
122 return true;
123 }
124
IsCellularDataEnabled(bool & dataEnabled)125 int32_t CellularDataService::IsCellularDataEnabled(bool &dataEnabled)
126 {
127 if (!TelephonyPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
128 return TELEPHONY_ERR_PERMISSION_ERR;
129 }
130 if (cellularDataControllers_[DEFAULT_SIM_SLOT_ID] == nullptr) {
131 TELEPHONY_LOGE("cellularDataControllers_[0] is null");
132 return TELEPHONY_ERR_LOCAL_PTR_NULL;
133 }
134 return cellularDataControllers_[DEFAULT_SIM_SLOT_ID]->IsCellularDataEnabled(dataEnabled);
135 }
136
EnableCellularData(bool enable)137 int32_t CellularDataService::EnableCellularData(bool enable)
138 {
139 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
140 TELEPHONY_LOGE("Non-system applications use system APIs!");
141 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
142 }
143 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
144 int32_t slotId = CellularDataService::GetDefaultCellularDataSlotId();
145 CellularDataHiSysEvent::WriteDataActivateFaultEvent(
146 slotId, enable, CellularDataErrorCode::DATA_ERROR_PERMISSION_ERROR, Permission::SET_TELEPHONY_STATE);
147 return TELEPHONY_ERR_PERMISSION_ERR;
148 }
149 if (cellularDataControllers_[DEFAULT_SIM_SLOT_ID] == nullptr) {
150 TELEPHONY_LOGE("cellularDataControllers_[0] is null");
151 return TELEPHONY_ERR_LOCAL_PTR_NULL;
152 }
153 return cellularDataControllers_[DEFAULT_SIM_SLOT_ID]->SetCellularDataEnable(enable);
154 }
155
EnableIntelligenceSwitch(bool enable)156 int32_t CellularDataService::EnableIntelligenceSwitch(bool enable)
157 {
158 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
159 TELEPHONY_LOGE("Non-system applications use system APIs!");
160 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
161 }
162 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
163 int32_t slotId = CellularDataService::GetDefaultCellularDataSlotId();
164 CellularDataHiSysEvent::WriteDataActivateFaultEvent(
165 slotId, enable, CellularDataErrorCode::DATA_ERROR_PERMISSION_ERROR, Permission::SET_TELEPHONY_STATE);
166 return TELEPHONY_ERR_PERMISSION_ERR;
167 }
168 if (cellularDataControllers_[DEFAULT_SIM_SLOT_ID] == nullptr) {
169 TELEPHONY_LOGE("cellularDataControllers_[0] is null");
170 return TELEPHONY_ERR_LOCAL_PTR_NULL;
171 }
172 return cellularDataControllers_[DEFAULT_SIM_SLOT_ID]->SetIntelligenceSwitchEnable(enable);
173 }
174
GetCellularDataState()175 int32_t CellularDataService::GetCellularDataState()
176 {
177 int32_t slotId = CellularDataService::GetDefaultCellularDataSlotId();
178 std::map<int32_t, std::shared_ptr<CellularDataController>>::const_iterator item =
179 cellularDataControllers_.find(slotId);
180 if (item == cellularDataControllers_.end() || item->second == nullptr) {
181 TELEPHONY_LOGE("cellularDataControllers_[%{public}d] is null", slotId);
182 return CELLULAR_DATA_INVALID_PARAM;
183 }
184 int32_t dataState = CellularDataStateAdapter(item->second->GetCellularDataState());
185 DisConnectionReason reason = item->second->GetDisConnectionReason();
186 if (reason == DisConnectionReason::REASON_GSM_AND_CALLING_ONLY && item->second->IsRestrictedMode()) {
187 dataState = static_cast<int32_t>(DataConnectionStatus::DATA_STATE_SUSPENDED);
188 }
189 return dataState;
190 }
191
GetApnState(int32_t slotId,const std::string & apnType)192 int32_t CellularDataService::GetApnState(int32_t slotId, const std::string &apnType)
193 {
194 std::map<int32_t, std::shared_ptr<CellularDataController>>::const_iterator item =
195 cellularDataControllers_.find(slotId);
196 if (item == cellularDataControllers_.end() || item->second == nullptr) {
197 TELEPHONY_LOGE("cellularDataControllers_[%{public}d] is null", slotId);
198 return CELLULAR_DATA_INVALID_PARAM;
199 }
200 int32_t apnState = static_cast<int32_t>(item->second->GetCellularDataState(apnType));
201 return apnState;
202 }
203
GetDataRecoveryState()204 int32_t CellularDataService::GetDataRecoveryState()
205 {
206 int32_t state = 0;
207 for (auto controler : cellularDataControllers_) {
208 int32_t curState = controler.second->GetDataRecoveryState();
209 state = (curState > state) ? curState : state;
210 }
211 return state;
212 }
213
IsCellularDataRoamingEnabled(const int32_t slotId,bool & dataRoamingEnabled)214 int32_t CellularDataService::IsCellularDataRoamingEnabled(const int32_t slotId, bool &dataRoamingEnabled)
215 {
216 if (!TelephonyPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
217 return TELEPHONY_ERR_PERMISSION_ERR;
218 }
219 if (!CheckParamValid(slotId)) {
220 TELEPHONY_LOGE("cellularDataControllers_[%{public}d] is null", slotId);
221 return CELLULAR_DATA_INVALID_PARAM;
222 }
223 return cellularDataControllers_[slotId]->IsCellularDataRoamingEnabled(dataRoamingEnabled);
224 }
225
EnableCellularDataRoaming(const int32_t slotId,bool enable)226 int32_t CellularDataService::EnableCellularDataRoaming(const int32_t slotId, bool enable)
227 {
228 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
229 TELEPHONY_LOGE("Non-system applications use system APIs!");
230 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
231 }
232 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
233 return TELEPHONY_ERR_PERMISSION_ERR;
234 }
235 if (!CheckParamValid(slotId)) {
236 TELEPHONY_LOGE("cellularDataControllers_[%{public}d] is null", slotId);
237 return TELEPHONY_ERR_SLOTID_INVALID;
238 }
239 int32_t result = cellularDataControllers_[slotId]->SetCellularDataRoamingEnabled(enable);
240 if (result == TELEPHONY_ERR_SUCCESS) {
241 CellularDataHiSysEvent::WriteRoamingConnectStateBehaviorEvent(enable);
242 }
243 return result;
244 }
245
InitModule()246 void CellularDataService::InitModule()
247 {
248 CellularDataNetAgent &netAgent = CellularDataNetAgent::GetInstance();
249 netAgent.ClearNetSupplier();
250 cellularDataControllers_.clear();
251 std::vector<uint64_t> netCapabilities;
252 netCapabilities.push_back(NetCap::NET_CAPABILITY_INTERNET);
253 netCapabilities.push_back(NetCap::NET_CAPABILITY_MMS);
254 int32_t simNum = CoreManagerInner::GetInstance().GetMaxSimCount();
255 for (int32_t i = 0; i < simNum; ++i) {
256 std::shared_ptr<CellularDataController> cellularDataController = std::make_shared<CellularDataController>(i);
257 if (cellularDataController == nullptr) {
258 TELEPHONY_LOGE("CellularDataService init module failed cellularDataController is null.");
259 continue;
260 }
261 cellularDataControllers_.insert(
262 std::pair<int32_t, std::shared_ptr<CellularDataController>>(i, cellularDataController));
263 for (uint64_t capability : netCapabilities) {
264 NetSupplier netSupplier = { 0 };
265 netSupplier.supplierId = 0;
266 netSupplier.slotId = i;
267 netSupplier.simId = INVALID_SIM_ID;
268 netSupplier.capability = capability;
269 netAgent.AddNetSupplier(netSupplier);
270 }
271 }
272 }
273
CheckParamValid(const int32_t slotId)274 bool CellularDataService::CheckParamValid(const int32_t slotId)
275 {
276 if (slotId < 0) {
277 return false;
278 }
279 std::map<int32_t, std::shared_ptr<CellularDataController>>::const_iterator item =
280 cellularDataControllers_.find(slotId);
281 if (item == cellularDataControllers_.end()) {
282 return false;
283 }
284 if (item->second == nullptr) {
285 return false;
286 }
287 return true;
288 }
289
ReleaseNet(const NetRequest & request)290 int32_t CellularDataService::ReleaseNet(const NetRequest &request)
291 {
292 std::string requestIdent = request.ident.substr(strlen(IDENT_PREFIX));
293 if (!IsValidDecValue(requestIdent)) {
294 return CELLULAR_DATA_INVALID_PARAM;
295 }
296 int32_t simId = std::stoi(requestIdent);
297 int32_t slotId = CoreManagerInner::GetInstance().GetSlotId(simId);
298 if (!CheckParamValid(slotId)) {
299 return CELLULAR_DATA_INVALID_PARAM;
300 }
301 bool result = cellularDataControllers_[slotId]->ReleaseNet(request);
302 return static_cast<int32_t>(result ? RequestNetCode::REQUEST_SUCCESS : RequestNetCode::REQUEST_FAILED);
303 }
304
RequestNet(const NetRequest & request)305 int32_t CellularDataService::RequestNet(const NetRequest &request)
306 {
307 std::string requestIdent = request.ident.substr(strlen(IDENT_PREFIX));
308 if (!IsValidDecValue(requestIdent)) {
309 return CELLULAR_DATA_INVALID_PARAM;
310 }
311 int32_t simId = std::stoi(requestIdent);
312 int32_t slotId = CoreManagerInner::GetInstance().GetSlotId(simId);
313 if (!CheckParamValid(slotId)) {
314 return CELLULAR_DATA_INVALID_PARAM;
315 }
316 bool result = cellularDataControllers_[slotId]->RequestNet(request);
317 return static_cast<int32_t>(result ? RequestNetCode::REQUEST_SUCCESS : RequestNetCode::REQUEST_FAILED);
318 }
319
DispatchEvent(const int32_t slotId,const AppExecFwk::InnerEvent::Pointer & event)320 void CellularDataService::DispatchEvent(const int32_t slotId, const AppExecFwk::InnerEvent::Pointer &event)
321 {
322 if (!CheckParamValid(slotId)) {
323 TELEPHONY_LOGI("dispatch event slotId invalid");
324 return;
325 }
326 cellularDataControllers_[slotId]->ProcessEvent(event);
327 }
328
UnRegisterAllNetSpecifier()329 void CellularDataService::UnRegisterAllNetSpecifier()
330 {
331 CellularDataNetAgent::GetInstance().UnregisterAllNetSupplier();
332 CellularDataNetAgent::GetInstance().UnregisterPolicyCallback();
333 }
334
HandleApnChanged(const int32_t slotId)335 int32_t CellularDataService::HandleApnChanged(const int32_t slotId)
336 {
337 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
338 TELEPHONY_LOGE("permission denied!");
339 return TELEPHONY_ERR_PERMISSION_ERR;
340 }
341 if (!CheckParamValid(slotId)) {
342 TELEPHONY_LOGE("cellularDataControllers_[%{public}d] is null", slotId);
343 return CELLULAR_DATA_INVALID_PARAM;
344 }
345 bool result = cellularDataControllers_[slotId]->HandleApnChanged();
346 return result ? static_cast<int32_t>(DataRespondCode::SET_SUCCESS)
347 : static_cast<int32_t>(DataRespondCode::SET_FAILED);
348 }
349
GetDefaultCellularDataSlotId()350 int32_t CellularDataService::GetDefaultCellularDataSlotId()
351 {
352 return CoreManagerInner::GetInstance().GetDefaultCellularDataSlotId();
353 }
354
GetDefaultCellularDataSimId(int32_t & simId)355 int32_t CellularDataService::GetDefaultCellularDataSimId(int32_t &simId)
356 {
357 return CoreManagerInner::GetInstance().GetDefaultCellularDataSimId(simId);
358 }
359
SetDefaultCellularDataSlotId(const int32_t slotId)360 int32_t CellularDataService::SetDefaultCellularDataSlotId(const int32_t slotId)
361 {
362 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
363 TELEPHONY_LOGE("Non-system applications use system APIs!");
364 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
365 }
366 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
367 return TELEPHONY_ERR_PERMISSION_ERR;
368 }
369 bool hasSim = false;
370 CoreManagerInner::GetInstance().HasSimCard(slotId, hasSim);
371 if (!hasSim) {
372 TELEPHONY_LOGE("has no sim!");
373 return TELEPHONY_ERR_NO_SIM_CARD;
374 }
375 if (!CoreManagerInner::GetInstance().IsSimActive(slotId)) {
376 TELEPHONY_LOGE("sim is not active!");
377 return TELEPHONY_ERR_SLOTID_INVALID;
378 }
379 int32_t formerSlotId = GetDefaultCellularDataSlotId();
380 if (formerSlotId < 0) {
381 TELEPHONY_LOGI("No old card slot id.");
382 }
383 int32_t result = CoreManagerInner::GetInstance().SetDefaultCellularDataSlotId(slotId);
384 if (result != TELEPHONY_ERR_SUCCESS) {
385 TELEPHONY_LOGE("set slot id fail");
386 return result;
387 }
388 return TELEPHONY_ERR_SUCCESS;
389 }
390
GetCellularDataFlowType()391 int32_t CellularDataService::GetCellularDataFlowType()
392 {
393 int32_t slotId = CellularDataService::GetDefaultCellularDataSlotId();
394 std::map<int32_t, std::shared_ptr<CellularDataController>>::const_iterator item =
395 cellularDataControllers_.find(slotId);
396 if (item == cellularDataControllers_.end() || item->second == nullptr) {
397 TELEPHONY_LOGE("cellularDataControllers_[%{public}d] is null", slotId);
398 return CELLULAR_DATA_INVALID_PARAM;
399 }
400 DisConnectionReason reason = item->second->GetDisConnectionReason();
401 if (reason == DisConnectionReason::REASON_GSM_AND_CALLING_ONLY && item->second->IsRestrictedMode()) {
402 return static_cast<int32_t>(CellDataFlowType::DATA_FLOW_TYPE_DORMANT);
403 }
404 int32_t result = item->second->GetCellularDataFlowType();
405 return result;
406 }
407
GetBeginTime()408 std::string CellularDataService::GetBeginTime()
409 {
410 std::ostringstream oss;
411 oss << beginTime_;
412 TELEPHONY_LOGI("bindTime := %{public}s", oss.str().c_str());
413 return oss.str();
414 }
415
GetEndTime()416 std::string CellularDataService::GetEndTime()
417 {
418 std::ostringstream oss;
419 oss << endTime_;
420 TELEPHONY_LOGI("endTime := %{public}s", oss.str().c_str());
421 return oss.str();
422 }
423
GetCellularDataSlotIdDump()424 std::string CellularDataService::GetCellularDataSlotIdDump()
425 {
426 std::ostringstream oss;
427 oss << "slotId:" << GetDefaultCellularDataSlotId();
428 return oss.str();
429 }
430
GetStateMachineCurrentStatusDump()431 std::string CellularDataService::GetStateMachineCurrentStatusDump()
432 {
433 std::ostringstream oss;
434 int32_t slotId = GetDefaultCellularDataSlotId();
435 if (!CheckParamValid(slotId)) {
436 oss << "default slotId: " << slotId;
437 return oss.str();
438 }
439 ApnProfileState statusDefault = cellularDataControllers_[slotId]->GetCellularDataState(DATA_CONTEXT_ROLE_DEFAULT);
440 ApnProfileState statusIms = cellularDataControllers_[slotId]->GetCellularDataState(DATA_CONTEXT_ROLE_IMS);
441 oss << "Default connect state: " << static_cast<int32_t>(statusDefault);
442 oss << "Ims connect state: " << static_cast<int32_t>(statusIms);
443 return oss.str();
444 }
445
GetFlowDataInfoDump()446 std::string CellularDataService::GetFlowDataInfoDump()
447 {
448 std::ostringstream oss;
449 int32_t slotId = GetDefaultCellularDataSlotId();
450 if (!CheckParamValid(slotId)) {
451 oss << "default slotId: " << slotId;
452 return oss.str();
453 }
454 int32_t dataFlowInfo = cellularDataControllers_[slotId]->GetCellularDataFlowType();
455 oss << "data flow info: " << dataFlowInfo;
456 return oss.str();
457 }
458
StrategySwitch(int32_t slotId,bool enable)459 int32_t CellularDataService::StrategySwitch(int32_t slotId, bool enable)
460 {
461 if (!CheckParamValid(slotId)) {
462 TELEPHONY_LOGE("cellularDataControllers_[%{public}d] is null", slotId);
463 return CELLULAR_DATA_INVALID_PARAM;
464 }
465 int32_t result = cellularDataControllers_[slotId]->SetPolicyDataOn(enable);
466 if (result == static_cast<int32_t>(DataRespondCode::SET_SUCCESS) && enable) {
467 CellularDataHiSysEvent::WriteDataDeactiveBehaviorEvent(slotId, DataDisconnectCause::HIGN_PRIORITY_NETWORK);
468 }
469 return result;
470 }
471
HasInternetCapability(const int32_t slotId,const int32_t cid)472 int32_t CellularDataService::HasInternetCapability(const int32_t slotId, const int32_t cid)
473 {
474 if (!CheckParamValid(slotId)) {
475 TELEPHONY_LOGE("cellularDataControllers_[%{public}d] is null", slotId);
476 return CELLULAR_DATA_INVALID_PARAM;
477 }
478 bool result = cellularDataControllers_[slotId]->HasInternetCapability(cid);
479 return result ? static_cast<int32_t>(RequestNetCode::REQUEST_SUCCESS)
480 : static_cast<int32_t>(RequestNetCode::REQUEST_FAILED);
481 }
482
ClearCellularDataConnections(const int32_t slotId)483 int32_t CellularDataService::ClearCellularDataConnections(const int32_t slotId)
484 {
485 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
486 TELEPHONY_LOGE("Permission denied!");
487 return TELEPHONY_ERR_PERMISSION_ERR;
488 }
489 return ClearAllConnections(slotId, DisConnectionReason::REASON_CLEAR_CONNECTION);
490 }
491
ClearAllConnections(const int32_t slotId,DisConnectionReason reason)492 int32_t CellularDataService::ClearAllConnections(const int32_t slotId, DisConnectionReason reason)
493 {
494 std::map<int32_t, std::shared_ptr<CellularDataController>>::const_iterator item =
495 cellularDataControllers_.find(slotId);
496 if (item == cellularDataControllers_.end() || item->second == nullptr) {
497 TELEPHONY_LOGE("cellularDataControllers_[%{public}d] is null", slotId);
498 return CELLULAR_DATA_INVALID_PARAM;
499 }
500 bool result = item->second->ClearAllConnections(reason);
501 return result ? static_cast<int32_t>(RequestNetCode::REQUEST_SUCCESS)
502 : static_cast<int32_t>(RequestNetCode::REQUEST_FAILED);
503 }
504
ChangeConnectionForDsds(const int32_t slotId,bool enable)505 int32_t CellularDataService::ChangeConnectionForDsds(const int32_t slotId, bool enable)
506 {
507 std::map<int32_t, std::shared_ptr<CellularDataController>>::const_iterator item =
508 cellularDataControllers_.find(slotId);
509 if (item == cellularDataControllers_.end() || item->second == nullptr) {
510 TELEPHONY_LOGE("cellularDataControllers_[%{public}d] is null", slotId);
511 return CELLULAR_DATA_INVALID_PARAM;
512 }
513 bool result = item->second->ChangeConnectionForDsds(enable);
514 return result ? static_cast<int32_t>(RequestNetCode::REQUEST_SUCCESS)
515 : static_cast<int32_t>(RequestNetCode::REQUEST_FAILED);
516 }
517
GetServiceRunningState()518 int32_t CellularDataService::GetServiceRunningState()
519 {
520 return static_cast<int32_t>(state_);
521 }
522
GetSpendTime()523 int64_t CellularDataService::GetSpendTime()
524 {
525 return endTime_ - beginTime_;
526 }
527
RegisterSimAccountCallback(const sptr<SimAccountCallback> & callback)528 int32_t CellularDataService::RegisterSimAccountCallback(const sptr<SimAccountCallback> &callback)
529 {
530 return CoreManagerInner::GetInstance().RegisterSimAccountCallback(GetBundleName(), callback);
531 }
532
UnregisterSimAccountCallback()533 int32_t CellularDataService::UnregisterSimAccountCallback()
534 {
535 return CoreManagerInner::GetInstance().UnregisterSimAccountCallback(GetBundleName());
536 }
537
GetDataConnApnAttr(int32_t slotId,ApnItem::Attribute & apnAttr)538 int32_t CellularDataService::GetDataConnApnAttr(int32_t slotId, ApnItem::Attribute &apnAttr)
539 {
540 if (!CheckParamValid(slotId)) {
541 TELEPHONY_LOGE("cellularDataControllers_[%{public}d] is null", slotId);
542 return CELLULAR_DATA_INVALID_PARAM;
543 }
544 cellularDataControllers_[slotId]->GetDataConnApnAttr(apnAttr);
545 return TELEPHONY_ERR_SUCCESS;
546 }
547
GetDataConnIpType(int32_t slotId,std::string & ipType)548 int32_t CellularDataService::GetDataConnIpType(int32_t slotId, std::string &ipType)
549 {
550 if (!CheckParamValid(slotId)) {
551 TELEPHONY_LOGE("cellularDataControllers_[%{public}d] is null", slotId);
552 return CELLULAR_DATA_INVALID_PARAM;
553 }
554 ipType = cellularDataControllers_[slotId]->GetDataConnIpType();
555 return TELEPHONY_ERR_SUCCESS;
556 }
557
IsNeedDoRecovery(int32_t slotId,bool needDoRecovery)558 int32_t CellularDataService::IsNeedDoRecovery(int32_t slotId, bool needDoRecovery)
559 {
560 if (!CheckParamValid(slotId)) {
561 TELEPHONY_LOGE("cellularDataControllers_[%{public}d] is null", slotId);
562 return CELLULAR_DATA_INVALID_PARAM;
563 }
564 cellularDataControllers_[slotId]->IsNeedDoRecovery(needDoRecovery);
565 return TELEPHONY_ERR_SUCCESS;
566 }
567 } // namespace Telephony
568 } // namespace OHOS
569