1 /*
2  * Copyright (C) 2021-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 #include "cellular_data_service.h"
17 
18 #include <cinttypes>
19 
20 #include "cellular_data_dump_helper.h"
21 #include "cellular_data_error.h"
22 #include "cellular_data_hisysevent.h"
23 #include "cellular_data_net_agent.h"
24 #include "core_manager_inner.h"
25 #include "data_connection_monitor.h"
26 #include "net_specifier.h"
27 #include "string_ex.h"
28 #include "system_ability_definition.h"
29 #include "telephony_ext_wrapper.h"
30 #include "telephony_common_utils.h"
31 #include "telephony_log_wrapper.h"
32 #include "telephony_permission.h"
33 #include "data_service_ext_wrapper.h"
34 
35 namespace OHOS {
36 namespace Telephony {
37 using namespace NetManagerStandard;
38 
39 bool g_registerResult = SystemAbility::MakeAndRegisterAbility(&DelayedRefSingleton<CellularDataService>::GetInstance());
CellularDataService()40 CellularDataService::CellularDataService()
41     : SystemAbility(TELEPHONY_CELLULAR_DATA_SYS_ABILITY_ID, true), registerToService_(false),
42       state_(ServiceRunningState::STATE_NOT_START)
43 {}
44 
45 CellularDataService::~CellularDataService() = default;
46 
OnStart()47 void CellularDataService::OnStart()
48 {
49     beginTime_ =
50         std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
51             .count();
52     if (state_ == ServiceRunningState::STATE_RUNNING) {
53         TELEPHONY_LOGE("CellularDataService has already started.");
54         return;
55     }
56     if (!Init()) {
57         TELEPHONY_LOGE("failed to init CellularDataService");
58         return;
59     }
60     state_ = ServiceRunningState::STATE_RUNNING;
61     endTime_ =
62         std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
63             .count();
64     TELEPHONY_LOGI("start service success.");
65 }
66 
OnStop()67 void CellularDataService::OnStop()
68 {
69     TELEPHONY_LOGI("ready to stop service.");
70     state_ = ServiceRunningState::STATE_NOT_START;
71     registerToService_ = false;
72     UnRegisterAllNetSpecifier();
73 }
74 
Dump(std::int32_t fd, const std::vector<std::u16string> &args)75 int32_t CellularDataService::Dump(std::int32_t fd, const std::vector<std::u16string> &args)
76 {
77     std::vector<std::string> argsInStr;
78     std::string result;
79     CellularDataDumpHelper dumpHelper;
80     if (fd < 0) {
81         TELEPHONY_LOGE("Dump fd invalid");
82         return TELEPHONY_ERR_FAIL;
83     }
84     for (const std::u16string &arg : args) {
85         TELEPHONY_LOGI("Dump args: %s", Str16ToStr8(arg).c_str());
86         argsInStr.emplace_back(Str16ToStr8(arg));
87     }
88     if (dumpHelper.Dump(argsInStr, result)) {
89         int32_t ret = dprintf(fd, "%s", result.c_str());
90         if (ret < 0) {
91             TELEPHONY_LOGE("dprintf to dump fd failed");
92             return TELEPHONY_ERR_FAIL;
93         }
94         return TELEPHONY_SUCCESS;
95     }
96     TELEPHONY_LOGW("dumpHelper failed");
97     return TELEPHONY_ERR_FAIL;
98 }
99 
GetIntelligenceSwitchState(bool &switchState)100 int32_t CellularDataService::GetIntelligenceSwitchState(bool &switchState)
101 {
102     if (!TelephonyPermission::CheckCallerIsSystemApp()) {
103         TELEPHONY_LOGE("Non-system applications use system APIs!");
104         return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
105     }
106     if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
107         int32_t slotId = CellularDataService::GetDefaultCellularDataSlotId();
108         CellularDataHiSysEvent::WriteDataActivateFaultEvent(
109             slotId, switchState, CellularDataErrorCode::DATA_ERROR_PERMISSION_ERROR, Permission::SET_TELEPHONY_STATE);
110         return TELEPHONY_ERR_PERMISSION_ERR;
111     }
112     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(DEFAULT_SIM_SLOT_ID);
113     if (cellularDataController == nullptr) {
114         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", DEFAULT_SIM_SLOT_ID);
115         return TELEPHONY_ERR_LOCAL_PTR_NULL;
116     }
117     return cellularDataController->GetIntelligenceSwitchState(switchState);
118 }
119 
Init()120 bool CellularDataService::Init()
121 {
122 #ifdef OHOS_BUILD_ENABLE_TELEPHONY_EXT
123     TELEPHONY_EXT_WRAPPER.InitTelephonyExtWrapper();
124 #endif
125 #ifdef OHOS_BUILD_ENABLE_DATA_SERVICE_EXT
126     DATA_SERVICE_EXT_WRAPPER.InitDataServiceExtWrapper();
127 #endif
128     InitModule();
129     if (!registerToService_) {
130         bool ret = Publish(DelayedRefSingleton<CellularDataService>::GetInstance().AsObject());
131         if (!ret) {
132             TELEPHONY_LOGE("Publish failed!");
133             return false;
134         }
135         registerToService_ = true;
136     }
137     std::lock_guard<std::mutex> guard(mapLock_);
138     for (const std::pair<const int32_t, std::shared_ptr<CellularDataController>> &it : cellularDataControllers_) {
139         if (it.second != nullptr) {
140             it.second->AsynchronousRegister();
141         } else {
142             TELEPHONY_LOGE("CellularDataController is null");
143         }
144     }
145     isInitSuccess_ = true;
146     return true;
147 }
148 
IsCellularDataEnabled(bool &dataEnabled)149 int32_t CellularDataService::IsCellularDataEnabled(bool &dataEnabled)
150 {
151     if (!TelephonyPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
152         return TELEPHONY_ERR_PERMISSION_ERR;
153     }
154     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(DEFAULT_SIM_SLOT_ID);
155     if (cellularDataController == nullptr) {
156         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", DEFAULT_SIM_SLOT_ID);
157         return TELEPHONY_ERR_LOCAL_PTR_NULL;
158     }
159     return cellularDataController->IsCellularDataEnabled(dataEnabled);
160 }
161 
EnableCellularData(bool enable)162 int32_t CellularDataService::EnableCellularData(bool enable)
163 {
164     if (!TelephonyPermission::CheckCallerIsSystemApp()) {
165         TELEPHONY_LOGE("Non-system applications use system APIs!");
166         return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
167     }
168     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
169         int32_t slotId = CellularDataService::GetDefaultCellularDataSlotId();
170         CellularDataHiSysEvent::WriteDataActivateFaultEvent(
171             slotId, enable, CellularDataErrorCode::DATA_ERROR_PERMISSION_ERROR, Permission::SET_TELEPHONY_STATE);
172         return TELEPHONY_ERR_PERMISSION_ERR;
173     }
174     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(DEFAULT_SIM_SLOT_ID);
175     if (cellularDataController == nullptr) {
176         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", DEFAULT_SIM_SLOT_ID);
177         return TELEPHONY_ERR_LOCAL_PTR_NULL;
178     }
179     return cellularDataController->SetCellularDataEnable(enable);
180 }
181 
EnableIntelligenceSwitch(bool enable)182 int32_t CellularDataService::EnableIntelligenceSwitch(bool enable)
183 {
184     if (!TelephonyPermission::CheckCallerIsSystemApp()) {
185         TELEPHONY_LOGE("Non-system applications use system APIs!");
186         return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
187     }
188     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
189         int32_t slotId = CellularDataService::GetDefaultCellularDataSlotId();
190         CellularDataHiSysEvent::WriteDataActivateFaultEvent(
191             slotId, enable, CellularDataErrorCode::DATA_ERROR_PERMISSION_ERROR, Permission::SET_TELEPHONY_STATE);
192         return TELEPHONY_ERR_PERMISSION_ERR;
193     }
194     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(DEFAULT_SIM_SLOT_ID);
195     if (cellularDataController == nullptr) {
196         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", DEFAULT_SIM_SLOT_ID);
197         return TELEPHONY_ERR_LOCAL_PTR_NULL;
198     }
199     return cellularDataController->SetIntelligenceSwitchEnable(enable);
200 }
201 
GetCellularDataState()202 int32_t CellularDataService::GetCellularDataState()
203 {
204     int32_t slotId = CellularDataService::GetDefaultCellularDataSlotId();
205     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
206     if (cellularDataController == nullptr) {
207         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
208         return CELLULAR_DATA_INVALID_PARAM;
209     }
210     int32_t dataState = CellularDataStateAdapter(cellularDataController->GetCellularDataState());
211     DisConnectionReason reason = cellularDataController->GetDisConnectionReason();
212     if (reason == DisConnectionReason::REASON_GSM_AND_CALLING_ONLY && cellularDataController->IsRestrictedMode()) {
213         dataState = static_cast<int32_t>(DataConnectionStatus::DATA_STATE_SUSPENDED);
214     }
215     return dataState;
216 }
217 
GetApnState(int32_t slotId, const std::string &apnType)218 int32_t CellularDataService::GetApnState(int32_t slotId, const std::string &apnType)
219 {
220     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
221     if (cellularDataController == nullptr) {
222         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
223         return CELLULAR_DATA_INVALID_PARAM;
224     }
225     int32_t apnState = static_cast<int32_t>(cellularDataController->GetCellularDataState(apnType));
226     return apnState;
227 }
228 
GetDataRecoveryState()229 int32_t CellularDataService::GetDataRecoveryState()
230 {
231     int32_t state = 0;
232     std::lock_guard<std::mutex> guard(mapLock_);
233     for (const auto &controller : cellularDataControllers_) {
234         auto cellularDataController = controller.second;
235         if (cellularDataController == nullptr) {
236             continue;
237         }
238         int32_t curState = cellularDataController->GetDataRecoveryState();
239         state = (curState > state) ? curState : state;
240     }
241     return state;
242 }
243 
IsCellularDataRoamingEnabled(const int32_t slotId, bool &dataRoamingEnabled)244 int32_t CellularDataService::IsCellularDataRoamingEnabled(const int32_t slotId, bool &dataRoamingEnabled)
245 {
246     if (!TelephonyPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
247         return TELEPHONY_ERR_PERMISSION_ERR;
248     }
249     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
250     if (cellularDataController == nullptr) {
251         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
252         return CELLULAR_DATA_INVALID_PARAM;
253     }
254     return cellularDataController->IsCellularDataRoamingEnabled(dataRoamingEnabled);
255 }
256 
EnableCellularDataRoaming(const int32_t slotId, bool enable)257 int32_t CellularDataService::EnableCellularDataRoaming(const int32_t slotId, bool enable)
258 {
259     if (!TelephonyPermission::CheckCallerIsSystemApp()) {
260         TELEPHONY_LOGE("Non-system applications use system APIs!");
261         return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
262     }
263     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
264         return TELEPHONY_ERR_PERMISSION_ERR;
265     }
266     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
267     if (cellularDataController == nullptr) {
268         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
269         return TELEPHONY_ERR_SLOTID_INVALID;
270     }
271     int32_t result = cellularDataController->SetCellularDataRoamingEnabled(enable);
272     if (result == TELEPHONY_ERR_SUCCESS) {
273         CellularDataHiSysEvent::WriteRoamingConnectStateBehaviorEvent(enable);
274     }
275     return result;
276 }
277 
ClearCellularDataControllers()278 void CellularDataService::ClearCellularDataControllers()
279 {
280     std::lock_guard<std::mutex> guard(mapLock_);
281     cellularDataControllers_.clear();
282 }
283 
InitModule()284 void CellularDataService::InitModule()
285 {
286     CellularDataNetAgent &netAgent = CellularDataNetAgent::GetInstance();
287     netAgent.ClearNetSupplier();
288     ClearCellularDataControllers();
289     std::vector<uint64_t> netCapabilities;
290     netCapabilities.push_back(NetCap::NET_CAPABILITY_INTERNET);
291     netCapabilities.push_back(NetCap::NET_CAPABILITY_MMS);
292     netCapabilities.push_back(NetCap::NET_CAPABILITY_INTERNAL_DEFAULT);
293     netCapabilities.push_back(NetCap::NET_CAPABILITY_SUPL);
294     netCapabilities.push_back(NetCap::NET_CAPABILITY_DUN);
295     netCapabilities.push_back(NetCap::NET_CAPABILITY_IA);
296     netCapabilities.push_back(NetCap::NET_CAPABILITY_XCAP);
297     int32_t simNum = CoreManagerInner::GetInstance().GetMaxSimCount();
298     for (int32_t i = 0; i < simNum; ++i) {
299         AddNetSupplier(i, netAgent, netCapabilities);
300     }
301 }
302 
AddCellularDataControllers(int32_t slotId, std::shared_ptr<CellularDataController> cellularDataController)303 void CellularDataService::AddCellularDataControllers(int32_t slotId,
304     std::shared_ptr<CellularDataController> cellularDataController)
305 {
306     std::lock_guard<std::mutex> guard(mapLock_);
307     cellularDataControllers_.insert(
308         std::pair<int32_t, std::shared_ptr<CellularDataController>>(slotId, cellularDataController));
309     if (slotId == CELLULAR_DATA_VSIM_SLOT_ID) {
310         // The SIM card is registered in the Init function. After the AsynchronousRegister function is invoked,
311         // the initialization is successful based on the delay message.
312         // The preceding functions need to be manually called because the VSIM initialization is delayed.
313         cellularDataController->AsynchronousRegister();
314     }
315 }
316 
AddNetSupplier(int32_t slotId, CellularDataNetAgent &netAgent, std::vector<uint64_t> &netCapabilities)317 void CellularDataService::AddNetSupplier(int32_t slotId, CellularDataNetAgent &netAgent,
318     std::vector<uint64_t> &netCapabilities)
319 {
320     std::shared_ptr<CellularDataController> cellularDataController = std::make_shared<CellularDataController>(slotId);
321     if (cellularDataController == nullptr) {
322         TELEPHONY_LOGE("CellularDataService init module failed cellularDataController is null.");
323         return;
324     }
325     AddCellularDataControllers(slotId, cellularDataController);
326     for (uint64_t capability : netCapabilities) {
327         NetSupplier netSupplier = { 0 };
328         netSupplier.supplierId = 0;
329         netSupplier.slotId = slotId;
330         netSupplier.simId = INVALID_SIM_ID;
331         netSupplier.capability = capability;
332         netSupplier.regState = SUPPLIER_INVALID_REG_STATE;
333         netAgent.AddNetSupplier(netSupplier);
334     }
335 }
336 
InitCellularDataController(int32_t slotId)337 int32_t CellularDataService::InitCellularDataController(int32_t slotId)
338 {
339     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
340         TELEPHONY_LOGE("permission denied!");
341         return TELEPHONY_ERR_PERMISSION_ERR;
342     }
343     if (slotId != CELLULAR_DATA_VSIM_SLOT_ID) {
344         return CELLULAR_DATA_INVALID_PARAM;
345     }
346     CellularDataNetAgent &netAgent = CellularDataNetAgent::GetInstance();
347     std::vector<uint64_t> netCapabilities;
348     netCapabilities.push_back(NetCap::NET_CAPABILITY_INTERNET);
349     AddNetSupplier(slotId, netAgent, netCapabilities);
350     return TELEPHONY_ERR_SUCCESS;
351 }
352 
ReleaseNet(const NetRequest &request)353 int32_t CellularDataService::ReleaseNet(const NetRequest &request)
354 {
355     size_t identPreLen = strlen(IDENT_PREFIX);
356     if (request.ident.length() < identPreLen) {
357         return CELLULAR_DATA_INVALID_PARAM;
358     }
359     std::string requestIdent = request.ident.substr(identPreLen);
360     if (!IsValidDecValue(requestIdent)) {
361         return CELLULAR_DATA_INVALID_PARAM;
362     }
363     int32_t simId = std::stoi(requestIdent);
364     int32_t slotId = CoreManagerInner::GetInstance().GetSlotId(simId);
365     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
366     if (cellularDataController == nullptr) {
367         return CELLULAR_DATA_INVALID_PARAM;
368     }
369     bool result = cellularDataController->ReleaseNet(request);
370     return static_cast<int32_t>(result ? RequestNetCode::REQUEST_SUCCESS : RequestNetCode::REQUEST_FAILED);
371 }
372 
RemoveUid(const NetRequest &request)373 int32_t CellularDataService::RemoveUid(const NetRequest &request)
374 {
375     size_t identPreLen = strlen(IDENT_PREFIX);
376     if (request.ident.length() < identPreLen) {
377         return CELLULAR_DATA_INVALID_PARAM;
378     }
379     std::string requestIdent = request.ident.substr(identPreLen);
380     if (!IsValidDecValue(requestIdent)) {
381         return CELLULAR_DATA_INVALID_PARAM;
382     }
383     int32_t simId = atoi(requestIdent.c_str());
384     int32_t slotId = CoreManagerInner::GetInstance().GetSlotId(simId);
385     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
386     if (cellularDataController == nullptr) {
387         return CELLULAR_DATA_INVALID_PARAM;
388     }
389     bool result = cellularDataController->RemoveUid(request);
390     return static_cast<int32_t>(result ? RequestNetCode::REQUEST_SUCCESS : RequestNetCode::REQUEST_FAILED);
391 }
392 
AddUid(const NetRequest &request)393 int32_t CellularDataService::AddUid(const NetRequest &request)
394 {
395     size_t identPreLen = strlen(IDENT_PREFIX);
396     if (request.ident.length() < identPreLen) {
397         return CELLULAR_DATA_INVALID_PARAM;
398     }
399     std::string requestIdent = request.ident.substr(identPreLen);
400     if (!IsValidDecValue(requestIdent)) {
401         return CELLULAR_DATA_INVALID_PARAM;
402     }
403     int32_t simId = atoi(requestIdent.c_str());
404     int32_t slotId = CoreManagerInner::GetInstance().GetSlotId(simId);
405     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
406     if (cellularDataController == nullptr) {
407         return CELLULAR_DATA_INVALID_PARAM;
408     }
409     bool result = cellularDataController->AddUid(request);
410     return static_cast<int32_t>(result ? RequestNetCode::REQUEST_SUCCESS : RequestNetCode::REQUEST_FAILED);
411 }
412 
RequestNet(const NetRequest &request)413 int32_t CellularDataService::RequestNet(const NetRequest &request)
414 {
415     size_t identPreLen = strlen(IDENT_PREFIX);
416     if (request.ident.length() < identPreLen) {
417         return CELLULAR_DATA_INVALID_PARAM;
418     }
419     std::string requestIdent = request.ident.substr(identPreLen);
420     if (!IsValidDecValue(requestIdent)) {
421         return CELLULAR_DATA_INVALID_PARAM;
422     }
423     int32_t simId = std::stoi(requestIdent);
424     if (TELEPHONY_EXT_WRAPPER.isCardAllowData_ &&
425         !TELEPHONY_EXT_WRAPPER.isCardAllowData_(simId, request.capability)) {
426         return static_cast<int32_t>(RequestNetCode::REQUEST_FAILED);
427     }
428     int32_t slotId = CoreManagerInner::GetInstance().GetSlotId(simId);
429     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
430     if (cellularDataController == nullptr) {
431         return CELLULAR_DATA_INVALID_PARAM;
432     }
433     bool result = cellularDataController->RequestNet(request);
434     return static_cast<int32_t>(result ? RequestNetCode::REQUEST_SUCCESS : RequestNetCode::REQUEST_FAILED);
435 }
436 
DispatchEvent(const int32_t slotId, const AppExecFwk::InnerEvent::Pointer &event)437 void CellularDataService::DispatchEvent(const int32_t slotId, const AppExecFwk::InnerEvent::Pointer &event)
438 {
439     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
440     if (cellularDataController == nullptr) {
441         TELEPHONY_LOGI("dispatch event slotId invalid");
442         return;
443     }
444     cellularDataController->ProcessEvent(event);
445 }
446 
UnRegisterAllNetSpecifier()447 void CellularDataService::UnRegisterAllNetSpecifier()
448 {
449     CellularDataNetAgent::GetInstance().UnregisterAllNetSupplier();
450     CellularDataNetAgent::GetInstance().UnregisterPolicyCallback();
451 }
452 
HandleApnChanged(const int32_t slotId)453 int32_t CellularDataService::HandleApnChanged(const int32_t slotId)
454 {
455     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
456         TELEPHONY_LOGE("permission denied!");
457         return TELEPHONY_ERR_PERMISSION_ERR;
458     }
459     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
460     if (cellularDataController == nullptr) {
461         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
462         return CELLULAR_DATA_INVALID_PARAM;
463     }
464     bool result = cellularDataController->HandleApnChanged();
465     return result ? static_cast<int32_t>(DataRespondCode::SET_SUCCESS)
466                   : static_cast<int32_t>(DataRespondCode::SET_FAILED);
467 }
468 
GetDefaultCellularDataSlotId()469 int32_t CellularDataService::GetDefaultCellularDataSlotId()
470 {
471     return CoreManagerInner::GetInstance().GetDefaultCellularDataSlotId();
472 }
473 
GetDefaultCellularDataSimId(int32_t &simId)474 int32_t CellularDataService::GetDefaultCellularDataSimId(int32_t &simId)
475 {
476     return CoreManagerInner::GetInstance().GetDefaultCellularDataSimId(simId);
477 }
478 
SetDefaultCellularDataSlotId(const int32_t slotId)479 int32_t CellularDataService::SetDefaultCellularDataSlotId(const int32_t slotId)
480 {
481     if (!TelephonyPermission::CheckCallerIsSystemApp()) {
482         TELEPHONY_LOGE("Non-system applications use system APIs!");
483         return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
484     }
485     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
486         return TELEPHONY_ERR_PERMISSION_ERR;
487     }
488     bool hasSim = false;
489     CoreManagerInner::GetInstance().HasSimCard(slotId, hasSim);
490     if (!hasSim) {
491         TELEPHONY_LOGE("has no sim!");
492         return TELEPHONY_ERR_NO_SIM_CARD;
493     }
494     if (!CoreManagerInner::GetInstance().IsSimActive(slotId)) {
495         TELEPHONY_LOGE("sim is not active!");
496         return TELEPHONY_ERR_SLOTID_INVALID;
497     }
498     int32_t formerSlotId = GetDefaultCellularDataSlotId();
499     if (formerSlotId < 0) {
500         TELEPHONY_LOGI("No old card slot id.");
501     }
502     int32_t result = CoreManagerInner::GetInstance().SetDefaultCellularDataSlotId(slotId);
503     if (result != TELEPHONY_ERR_SUCCESS) {
504         TELEPHONY_LOGE("set slot id fail");
505         return result;
506     }
507     return TELEPHONY_ERR_SUCCESS;
508 }
509 
GetCellularDataFlowType()510 int32_t CellularDataService::GetCellularDataFlowType()
511 {
512     int32_t slotId = CellularDataService::GetDefaultCellularDataSlotId();
513     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
514     if (cellularDataController == nullptr) {
515         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
516         return CELLULAR_DATA_INVALID_PARAM;
517     }
518     DisConnectionReason reason = cellularDataController->GetDisConnectionReason();
519     if (reason == DisConnectionReason::REASON_GSM_AND_CALLING_ONLY && cellularDataController->IsRestrictedMode()) {
520         return static_cast<int32_t>(CellDataFlowType::DATA_FLOW_TYPE_DORMANT);
521     }
522     int32_t result = cellularDataController->GetCellularDataFlowType();
523     return result;
524 }
525 
GetBeginTime()526 std::string CellularDataService::GetBeginTime()
527 {
528     std::ostringstream oss;
529     oss << beginTime_;
530     TELEPHONY_LOGI("bindTime :=  %{public}s", oss.str().c_str());
531     return oss.str();
532 }
533 
GetEndTime()534 std::string CellularDataService::GetEndTime()
535 {
536     std::ostringstream oss;
537     oss << endTime_;
538     TELEPHONY_LOGI("endTime :=  %{public}s", oss.str().c_str());
539     return oss.str();
540 }
541 
GetCellularDataSlotIdDump()542 std::string CellularDataService::GetCellularDataSlotIdDump()
543 {
544     std::ostringstream oss;
545     oss << "slotId:" << GetDefaultCellularDataSlotId();
546     return oss.str();
547 }
548 
GetStateMachineCurrentStatusDump()549 std::string CellularDataService::GetStateMachineCurrentStatusDump()
550 {
551     std::ostringstream oss;
552     int32_t slotId = GetDefaultCellularDataSlotId();
553     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
554     if (cellularDataController == nullptr) {
555         oss << "default slotId: " << slotId;
556         return oss.str();
557     }
558     ApnProfileState statusDefault = cellularDataController->GetCellularDataState(DATA_CONTEXT_ROLE_DEFAULT);
559     ApnProfileState statusIms = cellularDataController->GetCellularDataState(DATA_CONTEXT_ROLE_IMS);
560     oss << "Default connect state: " << static_cast<int32_t>(statusDefault);
561     oss << "Ims connect state:  " << static_cast<int32_t>(statusIms);
562     return oss.str();
563 }
564 
GetFlowDataInfoDump()565 std::string CellularDataService::GetFlowDataInfoDump()
566 {
567     std::ostringstream oss;
568     int32_t slotId = GetDefaultCellularDataSlotId();
569     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
570     if (cellularDataController == nullptr) {
571         oss << "default slotId: " << slotId;
572         return oss.str();
573     }
574     int32_t dataFlowInfo = cellularDataController->GetCellularDataFlowType();
575     oss << "data flow info: " << dataFlowInfo;
576     return oss.str();
577 }
578 
StrategySwitch(int32_t slotId, bool enable)579 int32_t CellularDataService::StrategySwitch(int32_t slotId, bool enable)
580 {
581     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
582     if (cellularDataController == nullptr) {
583         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
584         return CELLULAR_DATA_INVALID_PARAM;
585     }
586     int32_t result = cellularDataController->SetPolicyDataOn(enable);
587     if (result == static_cast<int32_t>(DataRespondCode::SET_SUCCESS) && enable) {
588         CellularDataHiSysEvent::WriteDataDeactiveBehaviorEvent(slotId, DataDisconnectCause::HIGN_PRIORITY_NETWORK);
589     }
590     return result;
591 }
592 
HasInternetCapability(const int32_t slotId, const int32_t cid)593 int32_t CellularDataService::HasInternetCapability(const int32_t slotId, const int32_t cid)
594 {
595     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
596     if (cellularDataController == nullptr) {
597         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
598         return CELLULAR_DATA_INVALID_PARAM;
599     }
600     bool result = cellularDataController->HasInternetCapability(cid);
601     return result ? static_cast<int32_t>(RequestNetCode::REQUEST_SUCCESS)
602                   : static_cast<int32_t>(RequestNetCode::REQUEST_FAILED);
603 }
604 
ClearCellularDataConnections(const int32_t slotId)605 int32_t CellularDataService::ClearCellularDataConnections(const int32_t slotId)
606 {
607     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
608         TELEPHONY_LOGE("Permission denied!");
609         return TELEPHONY_ERR_PERMISSION_ERR;
610     }
611     return ClearAllConnections(slotId, DisConnectionReason::REASON_CLEAR_CONNECTION);
612 }
613 
ClearAllConnections(const int32_t slotId, DisConnectionReason reason)614 int32_t CellularDataService::ClearAllConnections(const int32_t slotId, DisConnectionReason reason)
615 {
616     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
617         TELEPHONY_LOGE("Permission denied!");
618         return TELEPHONY_ERR_PERMISSION_ERR;
619     }
620     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
621     if (cellularDataController == nullptr) {
622         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
623         return CELLULAR_DATA_INVALID_PARAM;
624     }
625     bool result = cellularDataController->ClearAllConnections(reason);
626     return result ? static_cast<int32_t>(RequestNetCode::REQUEST_SUCCESS)
627                   : static_cast<int32_t>(RequestNetCode::REQUEST_FAILED);
628 }
629 
ChangeConnectionForDsds(const int32_t slotId, bool enable)630 int32_t CellularDataService::ChangeConnectionForDsds(const int32_t slotId, bool enable)
631 {
632     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
633     if (cellularDataController == nullptr) {
634         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
635         return CELLULAR_DATA_INVALID_PARAM;
636     }
637     bool result = cellularDataController->ChangeConnectionForDsds(enable);
638     return result ? static_cast<int32_t>(RequestNetCode::REQUEST_SUCCESS)
639                   : static_cast<int32_t>(RequestNetCode::REQUEST_FAILED);
640 }
641 
GetServiceRunningState()642 int32_t CellularDataService::GetServiceRunningState()
643 {
644     return static_cast<int32_t>(state_);
645 }
646 
GetSpendTime()647 int64_t CellularDataService::GetSpendTime()
648 {
649     return endTime_ - beginTime_;
650 }
651 
RegisterSimAccountCallback(const sptr<SimAccountCallback> callback)652 int32_t CellularDataService::RegisterSimAccountCallback(const sptr<SimAccountCallback> callback)
653 {
654     return CoreManagerInner::GetInstance().RegisterSimAccountCallback(GetTokenID(), callback);
655 }
656 
UnregisterSimAccountCallback()657 int32_t CellularDataService::UnregisterSimAccountCallback()
658 {
659     return CoreManagerInner::GetInstance().UnregisterSimAccountCallback(GetTokenID());
660 }
661 
GetDataConnApnAttr(int32_t slotId, ApnItem::Attribute &apnAttr)662 int32_t CellularDataService::GetDataConnApnAttr(int32_t slotId, ApnItem::Attribute &apnAttr)
663 {
664     if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
665         TELEPHONY_LOGE("Permission denied!");
666         return TELEPHONY_ERR_PERMISSION_ERR;
667     }
668     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
669     if (cellularDataController == nullptr) {
670         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
671         return CELLULAR_DATA_INVALID_PARAM;
672     }
673     cellularDataController->GetDataConnApnAttr(apnAttr);
674     return TELEPHONY_ERR_SUCCESS;
675 }
676 
GetDataConnIpType(int32_t slotId, std::string &ipType)677 int32_t CellularDataService::GetDataConnIpType(int32_t slotId, std::string &ipType)
678 {
679     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
680     if (cellularDataController == nullptr) {
681         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
682         return CELLULAR_DATA_INVALID_PARAM;
683     }
684     ipType = cellularDataController->GetDataConnIpType();
685     return TELEPHONY_ERR_SUCCESS;
686 }
687 
IsNeedDoRecovery(int32_t slotId, bool needDoRecovery)688 int32_t CellularDataService::IsNeedDoRecovery(int32_t slotId, bool needDoRecovery)
689 {
690     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
691     if (cellularDataController == nullptr) {
692         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
693         return CELLULAR_DATA_INVALID_PARAM;
694     }
695     cellularDataController->IsNeedDoRecovery(needDoRecovery);
696     return TELEPHONY_ERR_SUCCESS;
697 }
698 
GetCellularDataController(int32_t slotId)699 std::shared_ptr<CellularDataController> CellularDataService::GetCellularDataController(int32_t slotId)
700 {
701     if (slotId < 0 || !isInitSuccess_) {
702         TELEPHONY_LOGE("Invalid slotId or Init is not success. slotId=%{public}d, isInitSuccess=%{public}d",
703             slotId, (int32_t)isInitSuccess_);
704         return nullptr;
705     }
706     std::lock_guard<std::mutex> guard(mapLock_);
707     std::map<int32_t, std::shared_ptr<CellularDataController>>::const_iterator item =
708         cellularDataControllers_.find(slotId);
709     if (item == cellularDataControllers_.end() || item->second == nullptr) {
710         return nullptr;
711     }
712 
713     return item->second;
714 }
715 
EstablishAllApnsIfConnectable(const int32_t slotId)716 int32_t CellularDataService::EstablishAllApnsIfConnectable(const int32_t slotId)
717 {
718     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
719         TELEPHONY_LOGE("Permission denied!");
720         return TELEPHONY_ERR_PERMISSION_ERR;
721     }
722 
723     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
724     if (cellularDataController == nullptr) {
725         TELEPHONY_LOGE("slot%{public}d cellularDataControllers is null", slotId);
726         return CELLULAR_DATA_INVALID_PARAM;
727     }
728 
729     bool hasSim = false;
730     CoreManagerInner::GetInstance().HasSimCard(slotId, hasSim);
731     if (!hasSim) {
732         TELEPHONY_LOGE("slot%{public}d has no sim", slotId);
733         return TELEPHONY_ERR_NO_SIM_CARD;
734     }
735     if (!CoreManagerInner::GetInstance().IsSimActive(slotId)) {
736         TELEPHONY_LOGE("slot%{public}d sim not active", slotId);
737         return TELEPHONY_ERR_SLOTID_INVALID;
738     }
739 
740     bool result = cellularDataController->EstablishAllApnsIfConnectable();
741     return result ? TELEPHONY_ERR_SUCCESS : TELEPHONY_ERR_FAIL;
742 }
743 
ReleaseCellularDataConnection(int32_t slotId)744 int32_t CellularDataService::ReleaseCellularDataConnection(int32_t slotId)
745 {
746     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
747         TELEPHONY_LOGE("Permission denied!");
748         return TELEPHONY_ERR_PERMISSION_ERR;
749     }
750 
751     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
752     if (cellularDataController == nullptr) {
753         TELEPHONY_LOGE("slot%{public}d cellularDataControllers is null", slotId);
754         return CELLULAR_DATA_INVALID_PARAM;
755     }
756 
757     bool hasSim = false;
758     CoreManagerInner::GetInstance().HasSimCard(slotId, hasSim);
759     if (!hasSim) {
760         TELEPHONY_LOGE("slot%{public}d has no sim", slotId);
761         return TELEPHONY_ERR_NO_SIM_CARD;
762     }
763     if (!CoreManagerInner::GetInstance().IsSimActive(slotId)) {
764         TELEPHONY_LOGE("slot%{public}d sim not active", slotId);
765         return TELEPHONY_ERR_SLOTID_INVALID;
766     }
767 
768     return cellularDataController->ReleaseCellularDataConnection() ? TELEPHONY_ERR_SUCCESS : TELEPHONY_ERR_FAIL;
769 }
770 
GetCellularDataSupplierId(int32_t slotId, uint64_t capability, uint32_t &supplierId)771 int32_t CellularDataService::GetCellularDataSupplierId(int32_t slotId, uint64_t capability, uint32_t &supplierId)
772 {
773     if (!TelephonyPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
774         TELEPHONY_LOGE("Permission denied!");
775         return TELEPHONY_ERR_PERMISSION_ERR;
776     }
777     if (capability < NetCap::NET_CAPABILITY_MMS || capability > NetCap::NET_CAPABILITY_INTERNAL_DEFAULT) {
778         TELEPHONY_LOGE("Invalid capability = (%{public}" PRIu64 ")", capability);
779         return CELLULAR_DATA_INVALID_PARAM;
780     }
781     supplierId = static_cast<uint32_t>(CellularDataNetAgent::GetInstance().GetSupplierId(slotId, capability));
782     return TELEPHONY_ERR_SUCCESS;
783 }
784 
CorrectNetSupplierNoAvailable(int32_t slotId)785 int32_t CellularDataService::CorrectNetSupplierNoAvailable(int32_t slotId)
786 {
787     if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
788         TELEPHONY_LOGE("Permission denied!");
789         return TELEPHONY_ERR_PERMISSION_ERR;
790     }
791     std::shared_ptr<CellularDataController> cellularDataController = GetCellularDataController(slotId);
792     if (cellularDataController == nullptr) {
793         TELEPHONY_LOGE("cellularDataControllers is null, slotId=%{public}d", slotId);
794         return CELLULAR_DATA_INVALID_PARAM;
795     }
796     int32_t apnState = static_cast<int32_t>(cellularDataController->GetCellularDataState(DATA_CONTEXT_ROLE_DEFAULT));
797     if (apnState == ApnProfileState::PROFILE_STATE_CONNECTED) {
798         TELEPHONY_LOGE("Default apn state is connected, do not set available false");
799         return TELEPHONY_ERR_FAIL;
800     }
801     TELEPHONY_LOGI("correct default supplier available is false, apn state = %{public}d", apnState);
802     bool result = cellularDataController->UpdateNetworkInfo();
803     return result ? TELEPHONY_ERR_SUCCESS : TELEPHONY_ERR_FAIL;
804 }
805 
GetSupplierRegisterState(uint32_t supplierId, int32_t &regState)806 int32_t CellularDataService::GetSupplierRegisterState(uint32_t supplierId, int32_t &regState)
807 {
808     if (!TelephonyPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
809         TELEPHONY_LOGE("Permission denied!");
810         return TELEPHONY_ERR_PERMISSION_ERR;
811     }
812     bool result = CellularDataNetAgent::GetInstance().GetSupplierRegState(supplierId, regState);
813     return result ? TELEPHONY_ERR_SUCCESS : TELEPHONY_ERR_FAIL;
814 }
815 } // namespace Telephony
816 } // namespace OHOS
817