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 
GetIntelligenceSwitchState(bool & switchState)98 int32_t CellularDataService::GetIntelligenceSwitchState(bool &switchState)
99 {
100     if (!TelephonyPermission::CheckCallerIsSystemApp()) {
101         TELEPHONY_LOGE("Non-system applications use system APIs!");
102         return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
103     }
104     if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
105         int32_t slotId = CellularDataService::GetDefaultCellularDataSlotId();
106         CellularDataHiSysEvent::WriteDataActivateFaultEvent(
107             slotId, switchState, CellularDataErrorCode::DATA_ERROR_PERMISSION_ERROR, Permission::SET_TELEPHONY_STATE);
108         return TELEPHONY_ERR_PERMISSION_ERR;
109     }
110     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(DEFAULT_SIM_SLOT_ID);
111     if (cellularDataController == nullptr) {
112         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", DEFAULT_SIM_SLOT_ID);
113         return TELEPHONY_ERR_LOCAL_PTR_NULL;
114     }
115     return cellularDataController->GetIntelligenceSwitchState(switchState);
116 }
117 
Init()118 bool CellularDataService::Init()
119 {
120 #ifdef OHOS_BUILD_ENABLE_TELEPHONY_EXT
121     TELEPHONY_EXT_WRAPPER.InitTelephonyExtWrapper();
122 #endif
123 #ifdef OHOS_BUILD_ENABLE_DATA_SERVICE_EXT
124     DATA_SERVICE_EXT_WRAPPER.InitDataServiceExtWrapper();
125 #endif
126     InitModule();
127     if (!registerToService_) {
128         bool ret = Publish(DelayedRefSingleton<CellularDataService>::GetInstance().AsObject());
129         if (!ret) {
130             TELEPHONY_LOGE("Publish failed!");
131             return false;
132         }
133         registerToService_ = true;
134     }
135     std::lock_guard<std::mutex> guard(mapLock_);
136     for (const std::pair<const int32_t, std::shared_ptr<CellularDataController>> &it : cellularDataControllers_) {
137         if (it.second != nullptr) {
138             it.second->AsynchronousRegister();
139         } else {
140             TELEPHONY_LOGE("CellularDataController is null");
141         }
142     }
143     isInitSuccess_ = true;
144     return true;
145 }
146 
IsCellularDataEnabled(bool & dataEnabled)147 int32_t CellularDataService::IsCellularDataEnabled(bool &dataEnabled)
148 {
149     if (!TelephonyPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
150         return TELEPHONY_ERR_PERMISSION_ERR;
151     }
152     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(DEFAULT_SIM_SLOT_ID);
153     if (cellularDataController == nullptr) {
154         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", DEFAULT_SIM_SLOT_ID);
155         return TELEPHONY_ERR_LOCAL_PTR_NULL;
156     }
157     return cellularDataController->IsCellularDataEnabled(dataEnabled);
158 }
159 
EnableCellularData(bool enable)160 int32_t CellularDataService::EnableCellularData(bool enable)
161 {
162     if (!TelephonyPermission::CheckCallerIsSystemApp()) {
163         TELEPHONY_LOGE("Non-system applications use system APIs!");
164         return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
165     }
166     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
167         int32_t slotId = CellularDataService::GetDefaultCellularDataSlotId();
168         CellularDataHiSysEvent::WriteDataActivateFaultEvent(
169             slotId, enable, CellularDataErrorCode::DATA_ERROR_PERMISSION_ERROR, Permission::SET_TELEPHONY_STATE);
170         return TELEPHONY_ERR_PERMISSION_ERR;
171     }
172     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(DEFAULT_SIM_SLOT_ID);
173     if (cellularDataController == nullptr) {
174         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", DEFAULT_SIM_SLOT_ID);
175         return TELEPHONY_ERR_LOCAL_PTR_NULL;
176     }
177     return cellularDataController->SetCellularDataEnable(enable);
178 }
179 
EnableIntelligenceSwitch(bool enable)180 int32_t CellularDataService::EnableIntelligenceSwitch(bool enable)
181 {
182     if (!TelephonyPermission::CheckCallerIsSystemApp()) {
183         TELEPHONY_LOGE("Non-system applications use system APIs!");
184         return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
185     }
186     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
187         int32_t slotId = CellularDataService::GetDefaultCellularDataSlotId();
188         CellularDataHiSysEvent::WriteDataActivateFaultEvent(
189             slotId, enable, CellularDataErrorCode::DATA_ERROR_PERMISSION_ERROR, Permission::SET_TELEPHONY_STATE);
190         return TELEPHONY_ERR_PERMISSION_ERR;
191     }
192     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(DEFAULT_SIM_SLOT_ID);
193     if (cellularDataController == nullptr) {
194         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", DEFAULT_SIM_SLOT_ID);
195         return TELEPHONY_ERR_LOCAL_PTR_NULL;
196     }
197     return cellularDataController->SetIntelligenceSwitchEnable(enable);
198 }
199 
GetCellularDataState()200 int32_t CellularDataService::GetCellularDataState()
201 {
202     int32_t slotId = CellularDataService::GetDefaultCellularDataSlotId();
203     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
204     if (cellularDataController == nullptr) {
205         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
206         return CELLULAR_DATA_INVALID_PARAM;
207     }
208     int32_t dataState = CellularDataStateAdapter(cellularDataController->GetCellularDataState());
209     DisConnectionReason reason = cellularDataController->GetDisConnectionReason();
210     if (reason == DisConnectionReason::REASON_GSM_AND_CALLING_ONLY && cellularDataController->IsRestrictedMode()) {
211         dataState = static_cast<int32_t>(DataConnectionStatus::DATA_STATE_SUSPENDED);
212     }
213     return dataState;
214 }
215 
GetApnState(int32_t slotId,const std::string & apnType)216 int32_t CellularDataService::GetApnState(int32_t slotId, const std::string &apnType)
217 {
218     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
219     if (cellularDataController == nullptr) {
220         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
221         return CELLULAR_DATA_INVALID_PARAM;
222     }
223     int32_t apnState = static_cast<int32_t>(cellularDataController->GetCellularDataState(apnType));
224     return apnState;
225 }
226 
GetDataRecoveryState()227 int32_t CellularDataService::GetDataRecoveryState()
228 {
229     int32_t state = 0;
230     std::lock_guard<std::mutex> guard(mapLock_);
231     for (const auto &controller : cellularDataControllers_) {
232         auto cellularDataController = controller.second;
233         if (cellularDataController == nullptr) {
234             continue;
235         }
236         int32_t curState = cellularDataController->GetDataRecoveryState();
237         state = (curState > state) ? curState : state;
238     }
239     return state;
240 }
241 
IsCellularDataRoamingEnabled(const int32_t slotId,bool & dataRoamingEnabled)242 int32_t CellularDataService::IsCellularDataRoamingEnabled(const int32_t slotId, bool &dataRoamingEnabled)
243 {
244     if (!TelephonyPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
245         return TELEPHONY_ERR_PERMISSION_ERR;
246     }
247     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
248     if (cellularDataController == nullptr) {
249         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
250         return CELLULAR_DATA_INVALID_PARAM;
251     }
252     return cellularDataController->IsCellularDataRoamingEnabled(dataRoamingEnabled);
253 }
254 
EnableCellularDataRoaming(const int32_t slotId,bool enable)255 int32_t CellularDataService::EnableCellularDataRoaming(const int32_t slotId, bool enable)
256 {
257     if (!TelephonyPermission::CheckCallerIsSystemApp()) {
258         TELEPHONY_LOGE("Non-system applications use system APIs!");
259         return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
260     }
261     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
262         return TELEPHONY_ERR_PERMISSION_ERR;
263     }
264     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
265     if (cellularDataController == nullptr) {
266         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
267         return TELEPHONY_ERR_SLOTID_INVALID;
268     }
269     int32_t result = cellularDataController->SetCellularDataRoamingEnabled(enable);
270     if (result == TELEPHONY_ERR_SUCCESS) {
271         CellularDataHiSysEvent::WriteRoamingConnectStateBehaviorEvent(enable);
272     }
273     return result;
274 }
275 
ClearCellularDataControllers()276 void CellularDataService::ClearCellularDataControllers()
277 {
278     std::lock_guard<std::mutex> guard(mapLock_);
279     cellularDataControllers_.clear();
280 }
281 
InitModule()282 void CellularDataService::InitModule()
283 {
284     CellularDataNetAgent &netAgent = CellularDataNetAgent::GetInstance();
285     netAgent.ClearNetSupplier();
286     ClearCellularDataControllers();
287     std::vector<uint64_t> netCapabilities;
288     netCapabilities.push_back(NetCap::NET_CAPABILITY_INTERNET);
289     netCapabilities.push_back(NetCap::NET_CAPABILITY_MMS);
290     netCapabilities.push_back(NetCap::NET_CAPABILITY_INTERNAL_DEFAULT);
291     netCapabilities.push_back(NetCap::NET_CAPABILITY_SUPL);
292     netCapabilities.push_back(NetCap::NET_CAPABILITY_DUN);
293     netCapabilities.push_back(NetCap::NET_CAPABILITY_IA);
294     netCapabilities.push_back(NetCap::NET_CAPABILITY_XCAP);
295     int32_t simNum = CoreManagerInner::GetInstance().GetMaxSimCount();
296     for (int32_t i = 0; i < simNum; ++i) {
297         AddNetSupplier(i, netAgent, netCapabilities);
298     }
299 }
300 
AddCellularDataControllers(int32_t slotId,std::shared_ptr<CellularDataController> cellularDataController)301 void CellularDataService::AddCellularDataControllers(int32_t slotId,
302     std::shared_ptr<CellularDataController> cellularDataController)
303 {
304     std::lock_guard<std::mutex> guard(mapLock_);
305     cellularDataControllers_.insert(
306         std::pair<int32_t, std::shared_ptr<CellularDataController>>(slotId, cellularDataController));
307     if (slotId == CELLULAR_DATA_VSIM_SLOT_ID) {
308         // The SIM card is registered in the Init function. After the AsynchronousRegister function is invoked,
309         // the initialization is successful based on the delay message.
310         // The preceding functions need to be manually called because the VSIM initialization is delayed.
311         cellularDataController->AsynchronousRegister();
312     }
313 }
314 
AddNetSupplier(int32_t slotId,CellularDataNetAgent & netAgent,std::vector<uint64_t> & netCapabilities)315 void CellularDataService::AddNetSupplier(int32_t slotId, CellularDataNetAgent &netAgent,
316     std::vector<uint64_t> &netCapabilities)
317 {
318     std::shared_ptr<CellularDataController> cellularDataController = std::make_shared<CellularDataController>(slotId);
319     if (cellularDataController == nullptr) {
320         TELEPHONY_LOGE("CellularDataService init module failed cellularDataController is null.");
321         return;
322     }
323     AddCellularDataControllers(slotId, cellularDataController);
324     for (uint64_t capability : netCapabilities) {
325         NetSupplier netSupplier = { 0 };
326         netSupplier.supplierId = 0;
327         netSupplier.slotId = slotId;
328         netSupplier.simId = INVALID_SIM_ID;
329         netSupplier.capability = capability;
330         netAgent.AddNetSupplier(netSupplier);
331     }
332 }
333 
InitCellularDataController(int32_t slotId)334 int32_t CellularDataService::InitCellularDataController(int32_t slotId)
335 {
336     if (slotId != CELLULAR_DATA_VSIM_SLOT_ID) {
337         return CELLULAR_DATA_INVALID_PARAM;
338     }
339     CellularDataNetAgent &netAgent = CellularDataNetAgent::GetInstance();
340     std::vector<uint64_t> netCapabilities;
341     netCapabilities.push_back(NetCap::NET_CAPABILITY_INTERNET);
342     AddNetSupplier(slotId, netAgent, netCapabilities);
343     return TELEPHONY_ERR_SUCCESS;
344 }
345 
ReleaseNet(const NetRequest & request)346 int32_t CellularDataService::ReleaseNet(const NetRequest &request)
347 {
348     std::string requestIdent = request.ident.substr(strlen(IDENT_PREFIX));
349     if (!IsValidDecValue(requestIdent)) {
350         return CELLULAR_DATA_INVALID_PARAM;
351     }
352     int32_t simId = std::stoi(requestIdent);
353     int32_t slotId = CoreManagerInner::GetInstance().GetSlotId(simId);
354     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
355     if (cellularDataController == nullptr) {
356         return CELLULAR_DATA_INVALID_PARAM;
357     }
358     bool result = cellularDataController->ReleaseNet(request);
359     return static_cast<int32_t>(result ? RequestNetCode::REQUEST_SUCCESS : RequestNetCode::REQUEST_FAILED);
360 }
361 
RequestNet(const NetRequest & request)362 int32_t CellularDataService::RequestNet(const NetRequest &request)
363 {
364     std::string requestIdent = request.ident.substr(strlen(IDENT_PREFIX));
365     if (!IsValidDecValue(requestIdent)) {
366         return CELLULAR_DATA_INVALID_PARAM;
367     }
368     int32_t simId = std::stoi(requestIdent);
369     if (TELEPHONY_EXT_WRAPPER.isCardAllowData_ &&
370         !TELEPHONY_EXT_WRAPPER.isCardAllowData_(simId, request.capability)) {
371         return static_cast<int32_t>(RequestNetCode::REQUEST_FAILED);
372     }
373     int32_t slotId = CoreManagerInner::GetInstance().GetSlotId(simId);
374     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
375     if (cellularDataController == nullptr) {
376         return CELLULAR_DATA_INVALID_PARAM;
377     }
378     bool result = cellularDataController->RequestNet(request);
379     return static_cast<int32_t>(result ? RequestNetCode::REQUEST_SUCCESS : RequestNetCode::REQUEST_FAILED);
380 }
381 
DispatchEvent(const int32_t slotId,const AppExecFwk::InnerEvent::Pointer & event)382 void CellularDataService::DispatchEvent(const int32_t slotId, const AppExecFwk::InnerEvent::Pointer &event)
383 {
384     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
385     if (cellularDataController == nullptr) {
386         TELEPHONY_LOGI("dispatch event slotId invalid");
387         return;
388     }
389     cellularDataController->ProcessEvent(event);
390 }
391 
UnRegisterAllNetSpecifier()392 void CellularDataService::UnRegisterAllNetSpecifier()
393 {
394     CellularDataNetAgent::GetInstance().UnregisterAllNetSupplier();
395     CellularDataNetAgent::GetInstance().UnregisterPolicyCallback();
396 }
397 
HandleApnChanged(const int32_t slotId)398 int32_t CellularDataService::HandleApnChanged(const int32_t slotId)
399 {
400     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
401         TELEPHONY_LOGE("permission denied!");
402         return TELEPHONY_ERR_PERMISSION_ERR;
403     }
404     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
405     if (cellularDataController == nullptr) {
406         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
407         return CELLULAR_DATA_INVALID_PARAM;
408     }
409     bool result = cellularDataController->HandleApnChanged();
410     return result ? static_cast<int32_t>(DataRespondCode::SET_SUCCESS)
411                   : static_cast<int32_t>(DataRespondCode::SET_FAILED);
412 }
413 
GetDefaultCellularDataSlotId()414 int32_t CellularDataService::GetDefaultCellularDataSlotId()
415 {
416     return CoreManagerInner::GetInstance().GetDefaultCellularDataSlotId();
417 }
418 
GetDefaultCellularDataSimId(int32_t & simId)419 int32_t CellularDataService::GetDefaultCellularDataSimId(int32_t &simId)
420 {
421     return CoreManagerInner::GetInstance().GetDefaultCellularDataSimId(simId);
422 }
423 
SetDefaultCellularDataSlotId(const int32_t slotId)424 int32_t CellularDataService::SetDefaultCellularDataSlotId(const int32_t slotId)
425 {
426     if (!TelephonyPermission::CheckCallerIsSystemApp()) {
427         TELEPHONY_LOGE("Non-system applications use system APIs!");
428         return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
429     }
430     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
431         return TELEPHONY_ERR_PERMISSION_ERR;
432     }
433     bool hasSim = false;
434     CoreManagerInner::GetInstance().HasSimCard(slotId, hasSim);
435     if (!hasSim) {
436         TELEPHONY_LOGE("has no sim!");
437         return TELEPHONY_ERR_NO_SIM_CARD;
438     }
439     if (!CoreManagerInner::GetInstance().IsSimActive(slotId)) {
440         TELEPHONY_LOGE("sim is not active!");
441         return TELEPHONY_ERR_SLOTID_INVALID;
442     }
443     int32_t formerSlotId = GetDefaultCellularDataSlotId();
444     if (formerSlotId < 0) {
445         TELEPHONY_LOGI("No old card slot id.");
446     }
447     int32_t result = CoreManagerInner::GetInstance().SetDefaultCellularDataSlotId(slotId);
448     if (result != TELEPHONY_ERR_SUCCESS) {
449         TELEPHONY_LOGE("set slot id fail");
450         return result;
451     }
452     return TELEPHONY_ERR_SUCCESS;
453 }
454 
GetCellularDataFlowType()455 int32_t CellularDataService::GetCellularDataFlowType()
456 {
457     int32_t slotId = CellularDataService::GetDefaultCellularDataSlotId();
458     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
459     if (cellularDataController == nullptr) {
460         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
461         return CELLULAR_DATA_INVALID_PARAM;
462     }
463     DisConnectionReason reason = cellularDataController->GetDisConnectionReason();
464     if (reason == DisConnectionReason::REASON_GSM_AND_CALLING_ONLY && cellularDataController->IsRestrictedMode()) {
465         return static_cast<int32_t>(CellDataFlowType::DATA_FLOW_TYPE_DORMANT);
466     }
467     int32_t result = cellularDataController->GetCellularDataFlowType();
468     return result;
469 }
470 
GetBeginTime()471 std::string CellularDataService::GetBeginTime()
472 {
473     std::ostringstream oss;
474     oss << beginTime_;
475     TELEPHONY_LOGI("bindTime :=  %{public}s", oss.str().c_str());
476     return oss.str();
477 }
478 
GetEndTime()479 std::string CellularDataService::GetEndTime()
480 {
481     std::ostringstream oss;
482     oss << endTime_;
483     TELEPHONY_LOGI("endTime :=  %{public}s", oss.str().c_str());
484     return oss.str();
485 }
486 
GetCellularDataSlotIdDump()487 std::string CellularDataService::GetCellularDataSlotIdDump()
488 {
489     std::ostringstream oss;
490     oss << "slotId:" << GetDefaultCellularDataSlotId();
491     return oss.str();
492 }
493 
GetStateMachineCurrentStatusDump()494 std::string CellularDataService::GetStateMachineCurrentStatusDump()
495 {
496     std::ostringstream oss;
497     int32_t slotId = GetDefaultCellularDataSlotId();
498     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
499     if (cellularDataController == nullptr) {
500         oss << "default slotId: " << slotId;
501         return oss.str();
502     }
503     ApnProfileState statusDefault = cellularDataController->GetCellularDataState(DATA_CONTEXT_ROLE_DEFAULT);
504     ApnProfileState statusIms = cellularDataController->GetCellularDataState(DATA_CONTEXT_ROLE_IMS);
505     oss << "Default connect state: " << static_cast<int32_t>(statusDefault);
506     oss << "Ims connect state:  " << static_cast<int32_t>(statusIms);
507     return oss.str();
508 }
509 
GetFlowDataInfoDump()510 std::string CellularDataService::GetFlowDataInfoDump()
511 {
512     std::ostringstream oss;
513     int32_t slotId = GetDefaultCellularDataSlotId();
514     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
515     if (cellularDataController == nullptr) {
516         oss << "default slotId: " << slotId;
517         return oss.str();
518     }
519     int32_t dataFlowInfo = cellularDataController->GetCellularDataFlowType();
520     oss << "data flow info: " << dataFlowInfo;
521     return oss.str();
522 }
523 
StrategySwitch(int32_t slotId,bool enable)524 int32_t CellularDataService::StrategySwitch(int32_t slotId, bool enable)
525 {
526     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
527     if (cellularDataController == nullptr) {
528         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
529         return CELLULAR_DATA_INVALID_PARAM;
530     }
531     int32_t result = cellularDataController->SetPolicyDataOn(enable);
532     if (result == static_cast<int32_t>(DataRespondCode::SET_SUCCESS) && enable) {
533         CellularDataHiSysEvent::WriteDataDeactiveBehaviorEvent(slotId, DataDisconnectCause::HIGN_PRIORITY_NETWORK);
534     }
535     return result;
536 }
537 
HasInternetCapability(const int32_t slotId,const int32_t cid)538 int32_t CellularDataService::HasInternetCapability(const int32_t slotId, const int32_t cid)
539 {
540     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
541     if (cellularDataController == nullptr) {
542         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
543         return CELLULAR_DATA_INVALID_PARAM;
544     }
545     bool result = cellularDataController->HasInternetCapability(cid);
546     return result ? static_cast<int32_t>(RequestNetCode::REQUEST_SUCCESS)
547                   : static_cast<int32_t>(RequestNetCode::REQUEST_FAILED);
548 }
549 
ClearCellularDataConnections(const int32_t slotId)550 int32_t CellularDataService::ClearCellularDataConnections(const int32_t slotId)
551 {
552     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
553         TELEPHONY_LOGE("Permission denied!");
554         return TELEPHONY_ERR_PERMISSION_ERR;
555     }
556     return ClearAllConnections(slotId, DisConnectionReason::REASON_CLEAR_CONNECTION);
557 }
558 
ClearAllConnections(const int32_t slotId,DisConnectionReason reason)559 int32_t CellularDataService::ClearAllConnections(const int32_t slotId, DisConnectionReason reason)
560 {
561     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
562         TELEPHONY_LOGE("Permission denied!");
563         return TELEPHONY_ERR_PERMISSION_ERR;
564     }
565     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
566     if (cellularDataController == nullptr) {
567         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
568         return CELLULAR_DATA_INVALID_PARAM;
569     }
570     bool result = cellularDataController->ClearAllConnections(reason);
571     return result ? static_cast<int32_t>(RequestNetCode::REQUEST_SUCCESS)
572                   : static_cast<int32_t>(RequestNetCode::REQUEST_FAILED);
573 }
574 
ChangeConnectionForDsds(const int32_t slotId,bool enable)575 int32_t CellularDataService::ChangeConnectionForDsds(const int32_t slotId, bool enable)
576 {
577     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
578     if (cellularDataController == nullptr) {
579         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
580         return CELLULAR_DATA_INVALID_PARAM;
581     }
582     bool result = cellularDataController->ChangeConnectionForDsds(enable);
583     return result ? static_cast<int32_t>(RequestNetCode::REQUEST_SUCCESS)
584                   : static_cast<int32_t>(RequestNetCode::REQUEST_FAILED);
585 }
586 
GetServiceRunningState()587 int32_t CellularDataService::GetServiceRunningState()
588 {
589     return static_cast<int32_t>(state_);
590 }
591 
GetSpendTime()592 int64_t CellularDataService::GetSpendTime()
593 {
594     return endTime_ - beginTime_;
595 }
596 
RegisterSimAccountCallback(const sptr<SimAccountCallback> callback)597 int32_t CellularDataService::RegisterSimAccountCallback(const sptr<SimAccountCallback> callback)
598 {
599     return CoreManagerInner::GetInstance().RegisterSimAccountCallback(GetTokenID(), callback);
600 }
601 
UnregisterSimAccountCallback()602 int32_t CellularDataService::UnregisterSimAccountCallback()
603 {
604     return CoreManagerInner::GetInstance().UnregisterSimAccountCallback(GetTokenID());
605 }
606 
GetDataConnApnAttr(int32_t slotId,ApnItem::Attribute & apnAttr)607 int32_t CellularDataService::GetDataConnApnAttr(int32_t slotId, ApnItem::Attribute &apnAttr)
608 {
609     if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
610         TELEPHONY_LOGE("Permission denied!");
611         return TELEPHONY_ERR_PERMISSION_ERR;
612     }
613     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
614     if (cellularDataController == nullptr) {
615         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
616         return CELLULAR_DATA_INVALID_PARAM;
617     }
618     cellularDataController->GetDataConnApnAttr(apnAttr);
619     return TELEPHONY_ERR_SUCCESS;
620 }
621 
GetDataConnIpType(int32_t slotId,std::string & ipType)622 int32_t CellularDataService::GetDataConnIpType(int32_t slotId, std::string &ipType)
623 {
624     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
625     if (cellularDataController == nullptr) {
626         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
627         return CELLULAR_DATA_INVALID_PARAM;
628     }
629     ipType = cellularDataController->GetDataConnIpType();
630     return TELEPHONY_ERR_SUCCESS;
631 }
632 
IsNeedDoRecovery(int32_t slotId,bool needDoRecovery)633 int32_t CellularDataService::IsNeedDoRecovery(int32_t slotId, bool needDoRecovery)
634 {
635     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
636     if (cellularDataController == nullptr) {
637         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
638         return CELLULAR_DATA_INVALID_PARAM;
639     }
640     cellularDataController->IsNeedDoRecovery(needDoRecovery);
641     return TELEPHONY_ERR_SUCCESS;
642 }
643 
GetCellularDataController(int32_t slotId)644 std::shared_ptr<CellularDataController> CellularDataService::GetCellularDataController(int32_t slotId)
645 {
646     if (slotId < 0 || !isInitSuccess_) {
647         TELEPHONY_LOGE("Invalid slotId or Init is not success. slotId=%{public}d, isInitSuccess=%{public}d",
648             slotId, (int32_t)isInitSuccess_);
649         return nullptr;
650     }
651     std::lock_guard<std::mutex> guard(mapLock_);
652     std::map<int32_t, std::shared_ptr<CellularDataController>>::const_iterator item =
653         cellularDataControllers_.find(slotId);
654     if (item == cellularDataControllers_.end() || item->second == nullptr) {
655         return nullptr;
656     }
657 
658     return item->second;
659 }
660 } // namespace Telephony
661 } // namespace OHOS
662