1 /*
2 * Copyright (C) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "data_switch_settings.h"
17
18 #include "cellular_data_constant.h"
19 #include "cellular_data_error.h"
20 #include "cellular_data_settings_rdb_helper.h"
21 #include "core_manager_inner.h"
22 #include "telephony_log_wrapper.h"
23 #include "telephony_ext_wrapper.h"
24
25 namespace OHOS {
26 namespace Telephony {
DataSwitchSettings(int32_t slotId)27 DataSwitchSettings::DataSwitchSettings(int32_t slotId) : slotId_(slotId) {}
28
LoadSwitchValue()29 void DataSwitchSettings::LoadSwitchValue()
30 {
31 bool dataEnabled = false;
32 bool dataRoamingEnabled = false;
33 QueryUserDataStatus(dataEnabled);
34 QueryUserDataRoamingStatus(dataRoamingEnabled);
35 TELEPHONY_LOGI("slotId:%{public}d userDataOn_:%{public}d userDataRoaming_:%{public}d policyDataOn_:%{public}d",
36 slotId_, userDataOn_, userDataRoaming_, policyDataOn_);
37 }
38
IsInternalDataOn() const39 bool DataSwitchSettings::IsInternalDataOn() const
40 {
41 return internalDataOn_;
42 }
43
SetInternalDataOn(bool internalDataOn)44 void DataSwitchSettings::SetInternalDataOn(bool internalDataOn)
45 {
46 internalDataOn_ = internalDataOn;
47 }
48
SetUserDataOn(bool userDataOn)49 int32_t DataSwitchSettings::SetUserDataOn(bool userDataOn)
50 {
51 // For the VSIM card, no need to save switch state.
52 if (slotId_ == CELLULAR_DATA_VSIM_SLOT_ID) {
53 TELEPHONY_LOGI("SetUserDataOn, no need for slot %{public}d", slotId_);
54 return TELEPHONY_ERR_SUCCESS;
55 }
56 std::shared_ptr<CellularDataSettingsRdbHelper> settingsRdbHelper = CellularDataSettingsRdbHelper::GetInstance();
57 if (settingsRdbHelper == nullptr) {
58 TELEPHONY_LOGE("settingsRdbHelper == nullptr!");
59 return TELEPHONY_ERR_LOCAL_PTR_NULL;
60 }
61 int value = (userDataOn ? static_cast<int>(DataSwitchCode::CELLULAR_DATA_ENABLED)
62 : static_cast<int>(DataSwitchCode::CELLULAR_DATA_DISABLED));
63 TELEPHONY_LOGI("value:%{public}d", value);
64 Uri userDataEnableUri(CELLULAR_DATA_SETTING_DATA_ENABLE_URI);
65 int32_t result = settingsRdbHelper->PutValue(userDataEnableUri, CELLULAR_DATA_COLUMN_ENABLE, value);
66 if (result == TELEPHONY_ERR_SUCCESS) {
67 userDataOn_ = userDataOn;
68 }
69 return result;
70 }
71
SetIntelliSwitchOn(bool userSwitchOn)72 int32_t DataSwitchSettings::SetIntelliSwitchOn(bool userSwitchOn)
73 {
74 std::shared_ptr<CellularDataSettingsRdbHelper> settingsRdbHelper = CellularDataSettingsRdbHelper::GetInstance();
75 if (settingsRdbHelper == nullptr) {
76 TELEPHONY_LOGE("settingsRdbHelper == nullptr!");
77 return TELEPHONY_ERR_LOCAL_PTR_NULL;
78 }
79 int value = (userSwitchOn ? static_cast<int>(IntelligenceSwitchCode::INTELLIGENCE_SWITCH_ENABLED)
80 : static_cast<int>(IntelligenceSwitchCode::INTELLIGENCE_SWITCH_DISABLED));
81 TELEPHONY_LOGI("value:%{public}d", value);
82 Uri intelliSwitchEnableUri(CELLULAR_DATA_SETTING_INTELLIGENCE_SWITCH_URI);
83 int32_t result = settingsRdbHelper->PutValue(intelliSwitchEnableUri, INTELLIGENCE_SWITCH_COLUMN_ENABLE, value);
84 if (result == TELEPHONY_ERR_SUCCESS) {
85 intelliSwitchOn_ = userSwitchOn;
86 }
87 return result;
88 }
89
QueryUserDataStatus(bool & dataEnabled)90 int32_t DataSwitchSettings::QueryUserDataStatus(bool &dataEnabled)
91 {
92 // For the VSIM card, the cellular data switch is always ON.
93 if (slotId_ == CELLULAR_DATA_VSIM_SLOT_ID) {
94 userDataOn_ = true;
95 dataEnabled = true;
96 return TELEPHONY_ERR_SUCCESS;
97 }
98 std::shared_ptr<CellularDataSettingsRdbHelper> settingsRdbHelper = CellularDataSettingsRdbHelper::GetInstance();
99 if (settingsRdbHelper == nullptr) {
100 TELEPHONY_LOGE("settingsRdbHelper is nullptr!");
101 return TELEPHONY_ERR_LOCAL_PTR_NULL;
102 }
103 Uri userDataEnableUri(CELLULAR_DATA_SETTING_DATA_ENABLE_URI);
104 int32_t userDataEnable = static_cast<int32_t>(DataSwitchCode::CELLULAR_DATA_ENABLED);
105 int32_t ret = settingsRdbHelper->GetValue(userDataEnableUri, CELLULAR_DATA_COLUMN_ENABLE, userDataEnable);
106 if (ret != TELEPHONY_ERR_SUCCESS) {
107 TELEPHONY_LOGE("Slot%{public}d: Get data Value failed!", slotId_);
108 return TELEPHONY_ERR_LOCAL_PTR_NULL;
109 }
110 userDataOn_ = (userDataEnable == static_cast<int32_t>(DataSwitchCode::CELLULAR_DATA_ENABLED));
111 dataEnabled = userDataOn_;
112 return TELEPHONY_ERR_SUCCESS;
113 }
114
QueryIntelligenceSwitchStatus(bool & switchEnabled)115 int32_t DataSwitchSettings::QueryIntelligenceSwitchStatus(bool &switchEnabled)
116 {
117 std::shared_ptr<CellularDataSettingsRdbHelper> settingsRdbHelper = CellularDataSettingsRdbHelper::GetInstance();
118 if (settingsRdbHelper == nullptr) {
119 TELEPHONY_LOGE("settingsRdbHelper is nullptr!");
120 return TELEPHONY_ERR_LOCAL_PTR_NULL;
121 }
122 Uri intelliSwitchEnableUri(CELLULAR_DATA_SETTING_INTELLIGENCE_SWITCH_URI);
123 int32_t intelliSwitchEnable = static_cast<int32_t>(IntelligenceSwitchCode::INTELLIGENCE_SWITCH_DISABLED);
124 int32_t ret = settingsRdbHelper->GetValue(intelliSwitchEnableUri,
125 INTELLIGENCE_SWITCH_COLUMN_ENABLE, intelliSwitchEnable);
126 if (ret != TELEPHONY_ERR_SUCCESS) {
127 TELEPHONY_LOGE("GetValue failed!");
128 }
129 intelliSwitchOn_ =
130 (intelliSwitchEnable == static_cast<int32_t>(IntelligenceSwitchCode::INTELLIGENCE_SWITCH_ENABLED));
131 switchEnabled = intelliSwitchOn_;
132 return TELEPHONY_ERR_SUCCESS;
133 }
134
SetUserDataRoamingOn(bool dataRoamingEnabled)135 int32_t DataSwitchSettings::SetUserDataRoamingOn(bool dataRoamingEnabled)
136 {
137 // For the VSIM card, no need to save switch state.
138 if (slotId_ == CELLULAR_DATA_VSIM_SLOT_ID) {
139 TELEPHONY_LOGI("SetUserDataRoamingOn, no need for slot %{public}d", slotId_);
140 return TELEPHONY_ERR_SUCCESS;
141 }
142 std::shared_ptr<CellularDataSettingsRdbHelper> settingsRdbHelper = CellularDataSettingsRdbHelper::GetInstance();
143 if (settingsRdbHelper == nullptr) {
144 TELEPHONY_LOGE("settingsRdbHelper is nullptr!");
145 return TELEPHONY_ERR_LOCAL_PTR_NULL;
146 }
147 int32_t simId = CoreManagerInner::GetInstance().GetSimId(slotId_);
148 if (simId <= INVALID_SIM_ID) {
149 TELEPHONY_LOGE("Slot%{public}d: failed due to invalid sim id %{public}d", slotId_, simId);
150 return TELEPHONY_ERR_SLOTID_INVALID;
151 }
152 int value = (dataRoamingEnabled ? static_cast<int>(RoamingSwitchCode::CELLULAR_DATA_ROAMING_ENABLED)
153 : static_cast<int>(RoamingSwitchCode::CELLULAR_DATA_ROAMING_DISABLED));
154 TELEPHONY_LOGI("value:%{public}d", value);
155 Uri userDataRoamingUri(std::string(CELLULAR_DATA_SETTING_DATA_ROAMING_URI) + std::to_string(simId));
156 int32_t result = settingsRdbHelper->PutValue(
157 userDataRoamingUri, std::string(CELLULAR_DATA_COLUMN_ROAMING) + std::to_string(simId), value);
158 if (result == TELEPHONY_ERR_SUCCESS) {
159 userDataRoaming_ = dataRoamingEnabled;
160 }
161 return result;
162 }
163
QueryUserDataRoamingStatus(bool & dataRoamingEnabled)164 int32_t DataSwitchSettings::QueryUserDataRoamingStatus(bool &dataRoamingEnabled)
165 {
166 // For the VSIM card, the cellular data roaming switch is always ON.
167 if (slotId_ == CELLULAR_DATA_VSIM_SLOT_ID) {
168 userDataRoaming_ = true;
169 dataRoamingEnabled = true;
170 return TELEPHONY_ERR_SUCCESS;
171 }
172 std::shared_ptr<CellularDataSettingsRdbHelper> settingsRdbHelper = CellularDataSettingsRdbHelper::GetInstance();
173 if (settingsRdbHelper == nullptr) {
174 TELEPHONY_LOGE("settingsRdbHelper is nullptr!");
175 return TELEPHONY_ERR_LOCAL_PTR_NULL;
176 }
177 int32_t simId = CoreManagerInner::GetInstance().GetSimId(slotId_);
178 if (simId <= INVALID_SIM_ID) {
179 TELEPHONY_LOGE("Slot%{public}d: invalid sim id %{public}d", slotId_, simId);
180 return TELEPHONY_ERR_LOCAL_PTR_NULL;
181 }
182 Uri userDataRoamingUri(std::string(CELLULAR_DATA_SETTING_DATA_ROAMING_URI) + std::to_string(simId));
183 int32_t userDataRoamingValue = static_cast<int32_t>(RoamingSwitchCode::CELLULAR_DATA_ROAMING_DISABLED);
184 int32_t ret = settingsRdbHelper->GetValue(
185 userDataRoamingUri, std::string(CELLULAR_DATA_COLUMN_ROAMING) + std::to_string(simId), userDataRoamingValue);
186 if (ret != TELEPHONY_ERR_SUCCESS) {
187 TELEPHONY_LOGE("GetValue failed!");
188 return ret;
189 }
190 userDataRoaming_ = (userDataRoamingValue == static_cast<int32_t>(RoamingSwitchCode::CELLULAR_DATA_ROAMING_ENABLED));
191 dataRoamingEnabled = userDataRoaming_;
192 return TELEPHONY_ERR_SUCCESS;
193 }
194
IsPolicyDataOn() const195 bool DataSwitchSettings::IsPolicyDataOn() const
196 {
197 return policyDataOn_;
198 }
199
SetPolicyDataOn(bool policyDataOn)200 void DataSwitchSettings::SetPolicyDataOn(bool policyDataOn)
201 {
202 policyDataOn_ = policyDataOn;
203 }
204
IsCarrierDataOn() const205 bool DataSwitchSettings::IsCarrierDataOn() const
206 {
207 return carrierDataOn_;
208 }
209
SetCarrierDataOn(bool carrierDataOn)210 void DataSwitchSettings::SetCarrierDataOn(bool carrierDataOn)
211 {
212 carrierDataOn_ = carrierDataOn;
213 }
214
IsAllowActiveData() const215 bool DataSwitchSettings::IsAllowActiveData() const
216 {
217 if (userDataOn_ && policyDataOn_ && internalDataOn_) {
218 return true;
219 } else {
220 TELEPHONY_LOGD("Activation not allowed[user:%{public}d policy:%{public}d internal:%{public}d]", userDataOn_,
221 policyDataOn_, internalDataOn_);
222 return false;
223 }
224 }
225
IsUserDataOn()226 bool DataSwitchSettings::IsUserDataOn()
227 {
228 return userDataOn_;
229 }
230
IsUserDataRoamingOn()231 bool DataSwitchSettings::IsUserDataRoamingOn()
232 {
233 #ifdef OHOS_BUILD_ENABLE_TELEPHONY_EXT
234 if (TELEPHONY_EXT_WRAPPER.getUserDataRoamingExpend_) {
235 return TELEPHONY_EXT_WRAPPER.getUserDataRoamingExpend_(slotId_, userDataRoaming_);
236 }
237 #endif
238 return userDataRoaming_;
239 }
240
UpdateUserDataRoamingOn(bool dataRoaming)241 void DataSwitchSettings::UpdateUserDataRoamingOn(bool dataRoaming)
242 {
243 userDataRoaming_ = dataRoaming;
244 }
245 } // namespace Telephony
246 } // namespace OHOS