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 bool userDataOnTmp = userDataOn_;
65 userDataOn_ = userDataOn;
66 Uri userDataEnableUri(CELLULAR_DATA_SETTING_DATA_ENABLE_URI);
67 int32_t result = settingsRdbHelper->PutValue(userDataEnableUri, CELLULAR_DATA_COLUMN_ENABLE, value);
68 if (result != TELEPHONY_ERR_SUCCESS) {
69 userDataOn_ = userDataOnTmp;
70 }
71 return result;
72 }
73
SetAnySimDetected(int32_t simDetected)74 int32_t DataSwitchSettings::SetAnySimDetected(int32_t simDetected)
75 {
76 std::shared_ptr<CellularDataSettingsRdbHelper> settingsRdbHelper = CellularDataSettingsRdbHelper::GetInstance();
77 if (settingsRdbHelper == nullptr) {
78 TELEPHONY_LOGE("settingsRdbHelper == nullptr!");
79 return TELEPHONY_ERR_LOCAL_PTR_NULL;
80 }
81 Uri anySimDetectedUri(CELLULAR_DATA_SETTING_ANY_SIM_DETECTED_URI);
82 int32_t result = settingsRdbHelper->PutValue(anySimDetectedUri, SIM_DETECTED_COLUMN_ENABLE, simDetected);
83 TELEPHONY_LOGI("DataSwitchSettings::SetAnySimDetected result:%{public}d", result);
84 return result;
85 }
86
SetIntelliSwitchOn(bool userSwitchOn)87 int32_t DataSwitchSettings::SetIntelliSwitchOn(bool userSwitchOn)
88 {
89 std::shared_ptr<CellularDataSettingsRdbHelper> settingsRdbHelper = CellularDataSettingsRdbHelper::GetInstance();
90 if (settingsRdbHelper == nullptr) {
91 TELEPHONY_LOGE("settingsRdbHelper == nullptr!");
92 return TELEPHONY_ERR_LOCAL_PTR_NULL;
93 }
94 int value = (userSwitchOn ? static_cast<int>(IntelligenceSwitchCode::INTELLIGENCE_SWITCH_ENABLED)
95 : static_cast<int>(IntelligenceSwitchCode::INTELLIGENCE_SWITCH_DISABLED));
96 TELEPHONY_LOGI("value:%{public}d", value);
97 Uri intelliSwitchEnableUri(CELLULAR_DATA_SETTING_INTELLIGENCE_SWITCH_URI);
98 int32_t result = settingsRdbHelper->PutValue(intelliSwitchEnableUri, INTELLIGENCE_SWITCH_COLUMN_ENABLE, value);
99 if (result == TELEPHONY_ERR_SUCCESS) {
100 intelliSwitchOn_ = userSwitchOn;
101 }
102 return result;
103 }
104
QueryUserDataStatus(bool & dataEnabled)105 int32_t DataSwitchSettings::QueryUserDataStatus(bool &dataEnabled)
106 {
107 // For the VSIM card, the cellular data switch is always ON.
108 if (slotId_ == CELLULAR_DATA_VSIM_SLOT_ID) {
109 userDataOn_ = true;
110 dataEnabled = true;
111 return TELEPHONY_ERR_SUCCESS;
112 }
113 std::shared_ptr<CellularDataSettingsRdbHelper> settingsRdbHelper = CellularDataSettingsRdbHelper::GetInstance();
114 if (settingsRdbHelper == nullptr) {
115 TELEPHONY_LOGE("settingsRdbHelper is nullptr!");
116 return TELEPHONY_ERR_LOCAL_PTR_NULL;
117 }
118 Uri userDataEnableUri(CELLULAR_DATA_SETTING_DATA_ENABLE_URI);
119 int32_t userDataEnable = static_cast<int32_t>(DataSwitchCode::CELLULAR_DATA_ENABLED);
120 lastQryRet_ = settingsRdbHelper->GetValue(userDataEnableUri, CELLULAR_DATA_COLUMN_ENABLE, userDataEnable);
121 if (lastQryRet_ != TELEPHONY_ERR_SUCCESS) {
122 TELEPHONY_LOGE("Slot%{public}d: Get data Value failed!", slotId_);
123 return TELEPHONY_ERR_LOCAL_PTR_NULL;
124 }
125 userDataOn_ = (userDataEnable == static_cast<int32_t>(DataSwitchCode::CELLULAR_DATA_ENABLED));
126 dataEnabled = userDataOn_;
127 return TELEPHONY_ERR_SUCCESS;
128 }
129
QueryAnySimDetectedStatus(int32_t simDetected)130 int32_t DataSwitchSettings::QueryAnySimDetectedStatus(int32_t simDetected)
131 {
132 std::shared_ptr<CellularDataSettingsRdbHelper> settingsRdbHelper = CellularDataSettingsRdbHelper::GetInstance();
133 if (settingsRdbHelper == nullptr) {
134 TELEPHONY_LOGE("settingsRdbHelper is nullptr!");
135 return TELEPHONY_ERR_LOCAL_PTR_NULL;
136 }
137 Uri anySimDetectedUri(CELLULAR_DATA_SETTING_ANY_SIM_DETECTED_URI);
138 int32_t ret = settingsRdbHelper->GetValue(anySimDetectedUri, SIM_DETECTED_COLUMN_ENABLE, simDetected);
139 TELEPHONY_LOGI("DataSwitchSettings::QueryAnySimDetectedStatus ret:%{public}d", ret);
140 return ret;
141 }
142
QueryIntelligenceSwitchStatus(bool & switchEnabled)143 int32_t DataSwitchSettings::QueryIntelligenceSwitchStatus(bool &switchEnabled)
144 {
145 std::shared_ptr<CellularDataSettingsRdbHelper> settingsRdbHelper = CellularDataSettingsRdbHelper::GetInstance();
146 if (settingsRdbHelper == nullptr) {
147 TELEPHONY_LOGE("settingsRdbHelper is nullptr!");
148 return TELEPHONY_ERR_LOCAL_PTR_NULL;
149 }
150 Uri intelliSwitchEnableUri(CELLULAR_DATA_SETTING_INTELLIGENCE_SWITCH_URI);
151 int32_t intelliSwitchEnable = static_cast<int32_t>(IntelligenceSwitchCode::INTELLIGENCE_SWITCH_DISABLED);
152 int32_t ret = settingsRdbHelper->GetValue(intelliSwitchEnableUri,
153 INTELLIGENCE_SWITCH_COLUMN_ENABLE, intelliSwitchEnable);
154 if (ret != TELEPHONY_ERR_SUCCESS) {
155 TELEPHONY_LOGE("GetValue failed!");
156 }
157 intelliSwitchOn_ =
158 (intelliSwitchEnable == static_cast<int32_t>(IntelligenceSwitchCode::INTELLIGENCE_SWITCH_ENABLED));
159 switchEnabled = intelliSwitchOn_;
160 return TELEPHONY_ERR_SUCCESS;
161 }
162
SetUserDataRoamingOn(bool dataRoamingEnabled)163 int32_t DataSwitchSettings::SetUserDataRoamingOn(bool dataRoamingEnabled)
164 {
165 // For the VSIM card, no need to save switch state.
166 if (slotId_ == CELLULAR_DATA_VSIM_SLOT_ID) {
167 TELEPHONY_LOGI("SetUserDataRoamingOn, no need for slot %{public}d", slotId_);
168 return TELEPHONY_ERR_SUCCESS;
169 }
170 std::shared_ptr<CellularDataSettingsRdbHelper> settingsRdbHelper = CellularDataSettingsRdbHelper::GetInstance();
171 if (settingsRdbHelper == nullptr) {
172 TELEPHONY_LOGE("settingsRdbHelper is nullptr!");
173 return TELEPHONY_ERR_LOCAL_PTR_NULL;
174 }
175 int32_t simId = CoreManagerInner::GetInstance().GetSimId(slotId_);
176 if (simId <= INVALID_SIM_ID) {
177 TELEPHONY_LOGE("Slot%{public}d: failed due to invalid sim id %{public}d", slotId_, simId);
178 return TELEPHONY_ERR_SLOTID_INVALID;
179 }
180 int value = (dataRoamingEnabled ? static_cast<int>(RoamingSwitchCode::CELLULAR_DATA_ROAMING_ENABLED)
181 : static_cast<int>(RoamingSwitchCode::CELLULAR_DATA_ROAMING_DISABLED));
182 TELEPHONY_LOGI("value:%{public}d", value);
183 Uri userDataRoamingUri(std::string(CELLULAR_DATA_SETTING_DATA_ROAMING_URI) + std::to_string(simId));
184 int32_t result = settingsRdbHelper->PutValue(
185 userDataRoamingUri, std::string(CELLULAR_DATA_COLUMN_ROAMING) + std::to_string(simId), value);
186 if (result == TELEPHONY_ERR_SUCCESS) {
187 userDataRoaming_ = dataRoamingEnabled;
188 }
189 return result;
190 }
191
QueryUserDataRoamingStatus(bool & dataRoamingEnabled)192 int32_t DataSwitchSettings::QueryUserDataRoamingStatus(bool &dataRoamingEnabled)
193 {
194 // For the VSIM card, the cellular data roaming switch is always ON.
195 if (slotId_ == CELLULAR_DATA_VSIM_SLOT_ID) {
196 userDataRoaming_ = true;
197 dataRoamingEnabled = true;
198 return TELEPHONY_ERR_SUCCESS;
199 }
200 std::shared_ptr<CellularDataSettingsRdbHelper> settingsRdbHelper = CellularDataSettingsRdbHelper::GetInstance();
201 if (settingsRdbHelper == nullptr) {
202 TELEPHONY_LOGE("settingsRdbHelper is nullptr!");
203 return TELEPHONY_ERR_LOCAL_PTR_NULL;
204 }
205 int32_t simId = CoreManagerInner::GetInstance().GetSimId(slotId_);
206 if (simId <= INVALID_SIM_ID) {
207 TELEPHONY_LOGE("Slot%{public}d: invalid sim id %{public}d", slotId_, simId);
208 return TELEPHONY_ERR_LOCAL_PTR_NULL;
209 }
210 Uri userDataRoamingUri(std::string(CELLULAR_DATA_SETTING_DATA_ROAMING_URI) + std::to_string(simId));
211 int32_t userDataRoamingValue = static_cast<int32_t>(RoamingSwitchCode::CELLULAR_DATA_ROAMING_DISABLED);
212 int32_t ret = settingsRdbHelper->GetValue(
213 userDataRoamingUri, std::string(CELLULAR_DATA_COLUMN_ROAMING) + std::to_string(simId), userDataRoamingValue);
214 if (ret != TELEPHONY_ERR_SUCCESS) {
215 TELEPHONY_LOGE("GetValue failed!");
216 return ret;
217 }
218 userDataRoaming_ = (userDataRoamingValue == static_cast<int32_t>(RoamingSwitchCode::CELLULAR_DATA_ROAMING_ENABLED));
219 dataRoamingEnabled = userDataRoaming_;
220 return TELEPHONY_ERR_SUCCESS;
221 }
222
IsPolicyDataOn() const223 bool DataSwitchSettings::IsPolicyDataOn() const
224 {
225 return policyDataOn_;
226 }
227
SetPolicyDataOn(bool policyDataOn)228 void DataSwitchSettings::SetPolicyDataOn(bool policyDataOn)
229 {
230 policyDataOn_ = policyDataOn;
231 }
232
IsCarrierDataOn() const233 bool DataSwitchSettings::IsCarrierDataOn() const
234 {
235 return carrierDataOn_;
236 }
237
SetCarrierDataOn(bool carrierDataOn)238 void DataSwitchSettings::SetCarrierDataOn(bool carrierDataOn)
239 {
240 carrierDataOn_ = carrierDataOn;
241 }
242
IsAllowActiveData() const243 bool DataSwitchSettings::IsAllowActiveData() const
244 {
245 if (userDataOn_ && policyDataOn_ && internalDataOn_) {
246 return true;
247 } else {
248 TELEPHONY_LOGD("Activation not allowed[user:%{public}d policy:%{public}d internal:%{public}d]", userDataOn_,
249 policyDataOn_, internalDataOn_);
250 return false;
251 }
252 }
253
IsUserDataOn()254 bool DataSwitchSettings::IsUserDataOn()
255 {
256 return userDataOn_;
257 }
258
IsUserDataRoamingOn()259 bool DataSwitchSettings::IsUserDataRoamingOn()
260 {
261 #ifdef OHOS_BUILD_ENABLE_TELEPHONY_EXT
262 if (TELEPHONY_EXT_WRAPPER.getUserDataRoamingExpend_) {
263 return TELEPHONY_EXT_WRAPPER.getUserDataRoamingExpend_(slotId_, userDataRoaming_);
264 }
265 #endif
266 return userDataRoaming_;
267 }
268
UpdateUserDataRoamingOn(bool dataRoaming)269 void DataSwitchSettings::UpdateUserDataRoamingOn(bool dataRoaming)
270 {
271 userDataRoaming_ = dataRoaming;
272 }
273
GetLastQryRet()274 int32_t DataSwitchSettings::GetLastQryRet()
275 {
276 return lastQryRet_;
277 }
278 } // namespace Telephony
279 } // namespace OHOS