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