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
35namespace OHOS {
36namespace Telephony {
37using namespace NetManagerStandard;
38
39bool g_registerResult = SystemAbility::MakeAndRegisterAbility(&DelayedRefSingleton<CellularDataService>::GetInstance());
40CellularDataService::CellularDataService()
41    : SystemAbility(TELEPHONY_CELLULAR_DATA_SYS_ABILITY_ID, true), registerToService_(false),
42      state_(ServiceRunningState::STATE_NOT_START)
43{}
44
45CellularDataService::~CellularDataService() = default;
46
47void 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
67void CellularDataService::OnStop()
68{
69    TELEPHONY_LOGI("ready to stop service.");
70    state_ = ServiceRunningState::STATE_NOT_START;
71    registerToService_ = false;
72    UnRegisterAllNetSpecifier();
73}
74
75int32_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
100int32_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
120bool 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
149int32_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
162int32_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
182int32_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
202int32_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
218int32_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
229int32_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
244int32_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
257int32_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
278void CellularDataService::ClearCellularDataControllers()
279{
280    std::lock_guard<std::mutex> guard(mapLock_);
281    cellularDataControllers_.clear();
282}
283
284void 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
303void 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
317void 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
337int32_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
353int32_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
373int32_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
393int32_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
413int32_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
437void 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
447void CellularDataService::UnRegisterAllNetSpecifier()
448{
449    CellularDataNetAgent::GetInstance().UnregisterAllNetSupplier();
450    CellularDataNetAgent::GetInstance().UnregisterPolicyCallback();
451}
452
453int32_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
469int32_t CellularDataService::GetDefaultCellularDataSlotId()
470{
471    return CoreManagerInner::GetInstance().GetDefaultCellularDataSlotId();
472}
473
474int32_t CellularDataService::GetDefaultCellularDataSimId(int32_t &simId)
475{
476    return CoreManagerInner::GetInstance().GetDefaultCellularDataSimId(simId);
477}
478
479int32_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
510int32_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
526std::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
534std::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
542std::string CellularDataService::GetCellularDataSlotIdDump()
543{
544    std::ostringstream oss;
545    oss << "slotId:" << GetDefaultCellularDataSlotId();
546    return oss.str();
547}
548
549std::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
565std::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
579int32_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
593int32_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
605int32_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
614int32_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
630int32_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
642int32_t CellularDataService::GetServiceRunningState()
643{
644    return static_cast<int32_t>(state_);
645}
646
647int64_t CellularDataService::GetSpendTime()
648{
649    return endTime_ - beginTime_;
650}
651
652int32_t CellularDataService::RegisterSimAccountCallback(const sptr<SimAccountCallback> callback)
653{
654    return CoreManagerInner::GetInstance().RegisterSimAccountCallback(GetTokenID(), callback);
655}
656
657int32_t CellularDataService::UnregisterSimAccountCallback()
658{
659    return CoreManagerInner::GetInstance().UnregisterSimAccountCallback(GetTokenID());
660}
661
662int32_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
677int32_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
688int32_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
699std::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
716int32_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
744int32_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
771int32_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
785int32_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
806int32_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