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
24namespace OHOS {
25namespace Telephony {
26DataSwitchSettings::DataSwitchSettings(int32_t slotId) : slotId_(slotId) {}
27
28void DataSwitchSettings::LoadSwitchValue()
29{
30    bool dataEnabled = false;
31    bool dataRoamingEnabled = false;
32    QueryUserDataStatus(dataEnabled);
33    QueryUserDataRoamingStatus(dataRoamingEnabled);
34    TELEPHONY_LOGI("slotId:%{public}d userDataOn_:%{public}d userDataRoaming_:%{public}d policyDataOn_:%{public}d",
35        slotId_, userDataOn_, userDataRoaming_, policyDataOn_);
36}
37
38bool DataSwitchSettings::IsInternalDataOn() const
39{
40    return internalDataOn_;
41}
42
43void DataSwitchSettings::SetInternalDataOn(bool internalDataOn)
44{
45    internalDataOn_ = internalDataOn;
46}
47
48int32_t DataSwitchSettings::SetUserDataOn(bool userDataOn)
49{
50    // For the VSIM card, no need to save switch state.
51    if (slotId_ == CELLULAR_DATA_VSIM_SLOT_ID) {
52        TELEPHONY_LOGI("SetUserDataOn, no need for slot %{public}d", slotId_);
53        return TELEPHONY_ERR_SUCCESS;
54    }
55    std::shared_ptr<CellularDataSettingsRdbHelper> settingsRdbHelper = CellularDataSettingsRdbHelper::GetInstance();
56    if (settingsRdbHelper == nullptr) {
57        TELEPHONY_LOGE("settingsRdbHelper == nullptr!");
58        return TELEPHONY_ERR_LOCAL_PTR_NULL;
59    }
60    int value = (userDataOn ? static_cast<int>(DataSwitchCode::CELLULAR_DATA_ENABLED)
61                            : static_cast<int>(DataSwitchCode::CELLULAR_DATA_DISABLED));
62    TELEPHONY_LOGI("value:%{public}d", value);
63    Uri userDataEnableUri(CELLULAR_DATA_SETTING_DATA_ENABLE_URI);
64    int32_t result = settingsRdbHelper->PutValue(userDataEnableUri, CELLULAR_DATA_COLUMN_ENABLE, value);
65    if (result == TELEPHONY_ERR_SUCCESS) {
66        userDataOn_ = userDataOn;
67    }
68    return result;
69}
70
71int32_t DataSwitchSettings::SetIntelliSwitchOn(bool userSwitchOn)
72{
73    std::shared_ptr<CellularDataSettingsRdbHelper> settingsRdbHelper = CellularDataSettingsRdbHelper::GetInstance();
74    if (settingsRdbHelper == nullptr) {
75        TELEPHONY_LOGE("settingsRdbHelper == nullptr!");
76        return TELEPHONY_ERR_LOCAL_PTR_NULL;
77    }
78    int value = (userSwitchOn ? static_cast<int>(IntelligenceSwitchCode::INTELLIGENCE_SWITCH_ENABLED)
79                            : static_cast<int>(IntelligenceSwitchCode::INTELLIGENCE_SWITCH_DISABLED));
80    TELEPHONY_LOGI("value:%{public}d", value);
81    Uri intelliSwitchEnableUri(CELLULAR_DATA_SETTING_INTELLIGENCE_SWITCH_URI);
82    int32_t result = settingsRdbHelper->PutValue(intelliSwitchEnableUri, INTELLIGENCE_SWITCH_COLUMN_ENABLE, value);
83    if (result == TELEPHONY_ERR_SUCCESS) {
84        intelliSwitchOn_ = userSwitchOn;
85    }
86    return result;
87}
88
89int32_t DataSwitchSettings::QueryUserDataStatus(bool &dataEnabled)
90{
91    // For the VSIM card, the cellular data switch is always ON.
92    if (slotId_ == CELLULAR_DATA_VSIM_SLOT_ID) {
93        userDataOn_ = true;
94        dataEnabled = true;
95        return TELEPHONY_ERR_SUCCESS;
96    }
97    std::shared_ptr<CellularDataSettingsRdbHelper> settingsRdbHelper = CellularDataSettingsRdbHelper::GetInstance();
98    if (settingsRdbHelper == nullptr) {
99        TELEPHONY_LOGE("settingsRdbHelper is nullptr!");
100        return TELEPHONY_ERR_LOCAL_PTR_NULL;
101    }
102    Uri userDataEnableUri(CELLULAR_DATA_SETTING_DATA_ENABLE_URI);
103    int32_t userDataEnable = static_cast<int32_t>(DataSwitchCode::CELLULAR_DATA_ENABLED);
104    int32_t ret = settingsRdbHelper->GetValue(userDataEnableUri, CELLULAR_DATA_COLUMN_ENABLE, userDataEnable);
105    if (ret != TELEPHONY_ERR_SUCCESS) {
106        TELEPHONY_LOGE("Slot%{public}d: Get data Value failed!", slotId_);
107        return TELEPHONY_ERR_LOCAL_PTR_NULL;
108    }
109    userDataOn_ = (userDataEnable == static_cast<int32_t>(DataSwitchCode::CELLULAR_DATA_ENABLED));
110    dataEnabled = userDataOn_;
111    return TELEPHONY_ERR_SUCCESS;
112}
113
114int32_t DataSwitchSettings::QueryIntelligenceSwitchStatus(bool &switchEnabled)
115{
116    std::shared_ptr<CellularDataSettingsRdbHelper> settingsRdbHelper = CellularDataSettingsRdbHelper::GetInstance();
117    if (settingsRdbHelper == nullptr) {
118        TELEPHONY_LOGE("settingsRdbHelper is nullptr!");
119        return TELEPHONY_ERR_LOCAL_PTR_NULL;
120    }
121    Uri intelliSwitchEnableUri(CELLULAR_DATA_SETTING_INTELLIGENCE_SWITCH_URI);
122    int32_t intelliSwitchEnable = static_cast<int32_t>(IntelligenceSwitchCode::INTELLIGENCE_SWITCH_DISABLED);
123    int32_t ret = settingsRdbHelper->GetValue(intelliSwitchEnableUri,
124        INTELLIGENCE_SWITCH_COLUMN_ENABLE, intelliSwitchEnable);
125    if (ret != TELEPHONY_ERR_SUCCESS) {
126        TELEPHONY_LOGE("GetValue failed!");
127    }
128    intelliSwitchOn_ =
129        (intelliSwitchEnable == static_cast<int32_t>(IntelligenceSwitchCode::INTELLIGENCE_SWITCH_ENABLED));
130    switchEnabled = intelliSwitchOn_;
131    return TELEPHONY_ERR_SUCCESS;
132}
133
134int32_t DataSwitchSettings::SetUserDataRoamingOn(bool dataRoamingEnabled)
135{
136    // For the VSIM card, no need to save switch state.
137    if (slotId_ == CELLULAR_DATA_VSIM_SLOT_ID) {
138        TELEPHONY_LOGI("SetUserDataRoamingOn, no need for slot %{public}d", slotId_);
139        return TELEPHONY_ERR_SUCCESS;
140    }
141    std::shared_ptr<CellularDataSettingsRdbHelper> settingsRdbHelper = CellularDataSettingsRdbHelper::GetInstance();
142    if (settingsRdbHelper == nullptr) {
143        TELEPHONY_LOGE("settingsRdbHelper is nullptr!");
144        return TELEPHONY_ERR_LOCAL_PTR_NULL;
145    }
146    int32_t simId = CoreManagerInner::GetInstance().GetSimId(slotId_);
147    if (simId <= INVALID_SIM_ID) {
148        TELEPHONY_LOGE("Slot%{public}d: failed due to invalid sim id %{public}d", slotId_, simId);
149        return TELEPHONY_ERR_SLOTID_INVALID;
150    }
151    int value = (dataRoamingEnabled ? static_cast<int>(RoamingSwitchCode::CELLULAR_DATA_ROAMING_ENABLED)
152                                    : static_cast<int>(RoamingSwitchCode::CELLULAR_DATA_ROAMING_DISABLED));
153    TELEPHONY_LOGI("value:%{public}d", value);
154    Uri userDataRoamingUri(std::string(CELLULAR_DATA_SETTING_DATA_ROAMING_URI) + std::to_string(simId));
155    int32_t result = settingsRdbHelper->PutValue(
156        userDataRoamingUri, std::string(CELLULAR_DATA_COLUMN_ROAMING) + std::to_string(simId), value);
157    if (result == TELEPHONY_ERR_SUCCESS) {
158        userDataRoaming_ = dataRoamingEnabled;
159    }
160    return result;
161}
162
163int32_t DataSwitchSettings::QueryUserDataRoamingStatus(bool &dataRoamingEnabled)
164{
165    // For the VSIM card, the cellular data roaming switch is always ON.
166    if (slotId_ == CELLULAR_DATA_VSIM_SLOT_ID) {
167        userDataRoaming_ = true;
168        dataRoamingEnabled = true;
169        return TELEPHONY_ERR_SUCCESS;
170    }
171    std::shared_ptr<CellularDataSettingsRdbHelper> settingsRdbHelper = CellularDataSettingsRdbHelper::GetInstance();
172    if (settingsRdbHelper == nullptr) {
173        TELEPHONY_LOGE("settingsRdbHelper is nullptr!");
174        return TELEPHONY_ERR_LOCAL_PTR_NULL;
175    }
176    int32_t simId = CoreManagerInner::GetInstance().GetSimId(slotId_);
177    if (simId <= INVALID_SIM_ID) {
178        TELEPHONY_LOGE("Slot%{public}d: invalid sim id %{public}d", slotId_, simId);
179        return TELEPHONY_ERR_LOCAL_PTR_NULL;
180    }
181    Uri userDataRoamingUri(std::string(CELLULAR_DATA_SETTING_DATA_ROAMING_URI) + std::to_string(simId));
182    int32_t userDataRoamingValue = static_cast<int32_t>(RoamingSwitchCode::CELLULAR_DATA_ROAMING_DISABLED);
183    int32_t ret = settingsRdbHelper->GetValue(
184        userDataRoamingUri, std::string(CELLULAR_DATA_COLUMN_ROAMING) + std::to_string(simId), userDataRoamingValue);
185    if (ret != TELEPHONY_ERR_SUCCESS) {
186        TELEPHONY_LOGE("GetValue failed!");
187        return ret;
188    }
189    userDataRoaming_ = (userDataRoamingValue == static_cast<int32_t>(RoamingSwitchCode::CELLULAR_DATA_ROAMING_ENABLED));
190    dataRoamingEnabled = userDataRoaming_;
191    return TELEPHONY_ERR_SUCCESS;
192}
193
194bool DataSwitchSettings::IsPolicyDataOn() const
195{
196    return policyDataOn_;
197}
198
199void DataSwitchSettings::SetPolicyDataOn(bool policyDataOn)
200{
201    policyDataOn_ = policyDataOn;
202}
203
204bool DataSwitchSettings::IsCarrierDataOn() const
205{
206    return carrierDataOn_;
207}
208
209void DataSwitchSettings::SetCarrierDataOn(bool carrierDataOn)
210{
211    carrierDataOn_ = carrierDataOn;
212}
213
214bool DataSwitchSettings::IsAllowActiveData() const
215{
216    if (userDataOn_ && policyDataOn_ && internalDataOn_) {
217        return true;
218    } else {
219        TELEPHONY_LOGD("Activation not allowed[user:%{public}d policy:%{public}d internal:%{public}d]", userDataOn_,
220            policyDataOn_, internalDataOn_);
221        return false;
222    }
223}
224
225bool DataSwitchSettings::IsUserDataOn()
226{
227    return userDataOn_;
228}
229
230bool DataSwitchSettings::IsUserDataRoamingOn()
231{
232    return userDataRoaming_;
233}
234
235void DataSwitchSettings::UpdateUserDataRoamingOn(bool dataRoaming)
236{
237    userDataRoaming_ = dataRoaming;
238}
239} // namespace Telephony
240} // namespace OHOS