1 /*
2  * Copyright (C) 2023-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 "net_datashare_utils.h"
17 
18 #include <atomic>
19 #include <vector>
20 
21 #include "data_ability_observer_stub.h"
22 #include "net_manager_constants.h"
23 #include "net_mgr_log_wrapper.h"
24 
25 namespace OHOS {
26 namespace NetManagerStandard {
27 namespace {
28 constexpr const char *SETTINGS_DATASHARE_URI =
29     "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true";
30 constexpr const char *SETTINGS_DATA_EXT_URI = "datashare:///com.ohos.settingsdata.DataAbility";
31 constexpr const char *SETTINGS_DATA_COLUMN_KEYWORD = "KEYWORD";
32 constexpr const char *SETTINGS_DATA_COLUMN_VALUE = "VALUE";
33 
34 constexpr int INVALID_VALUE = -1;
35 } // namespace
36 
37 class NetDataAbilityObserver : public AAFwk::DataAbilityObserverStub {
38 public:
NetDataAbilityObserver(std::function<void ()> onChange)39     explicit NetDataAbilityObserver(std::function<void()> onChange) : onChange_(std::move(onChange)) {}
OnChange()40     void OnChange() override
41     {
42         if (onChange_) {
43             onChange_();
44         }
45     }
OnChangeExt(const AAFwk::ChangeInfo &)46     void OnChangeExt(const AAFwk::ChangeInfo &) override {}
OnChangePreferences(const std::string &)47     void OnChangePreferences(const std::string &) override {}
48 
49 private:
50     std::function<void()> onChange_;
51 };
52 
NetDataShareHelperUtils()53 NetDataShareHelperUtils::NetDataShareHelperUtils() {}
54 
CreateDataShareHelper()55 std::shared_ptr<DataShare::DataShareHelper> NetDataShareHelperUtils::CreateDataShareHelper()
56 {
57     sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
58     if (saManager == nullptr) {
59         NETMGR_LOG_E("GetSystemAbilityManager failed.");
60         return nullptr;
61     }
62     sptr<IRemoteObject> remoteObj = saManager->GetSystemAbility(COMM_NET_CONN_MANAGER_SYS_ABILITY_ID);
63     if (remoteObj == nullptr) {
64         NETMGR_LOG_E("GetSystemAbility Service Failed.");
65         return nullptr;
66     }
67     return DataShare::DataShareHelper::Creator(remoteObj, SETTINGS_DATASHARE_URI, SETTINGS_DATA_EXT_URI);
68 }
69 
Query(Uri & uri,const std::string & key,std::string & value)70 int32_t NetDataShareHelperUtils::Query(Uri &uri, const std::string &key, std::string &value)
71 {
72     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper();
73     if (dataShareHelper == nullptr) {
74         NETMGR_LOG_E("dataShareHelper is nullptr");
75         return NETMANAGER_ERROR;
76     }
77     DataShare::DataSharePredicates predicates;
78     std::vector<std::string> columns;
79     predicates.EqualTo(SETTINGS_DATA_COLUMN_KEYWORD, key);
80     auto result = dataShareHelper->Query(uri, predicates, columns);
81     if (result == nullptr) {
82         NETMGR_LOG_E("query error, result is null");
83         dataShareHelper->Release();
84         return NETMANAGER_ERROR;
85     }
86 
87     if (result->GoToFirstRow() != DataShare::E_OK) {
88         NETMGR_LOG_E("go to first row error");
89         result->Close();
90         dataShareHelper->Release();
91         return NETMANAGER_ERROR;
92     }
93 
94     int columnIndex;
95     result->GetColumnIndex(SETTINGS_DATA_COLUMN_VALUE, columnIndex);
96     result->GetString(columnIndex, value);
97     result->Close();
98     dataShareHelper->Release();
99     NETMGR_LOG_D("query success,value[%{public}s]", value.c_str());
100     return NETMANAGER_SUCCESS;
101 }
102 
Insert(Uri & uri,const std::string & key,const std::string & value)103 int32_t NetDataShareHelperUtils::Insert(Uri &uri, const std::string &key, const std::string &value)
104 {
105     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper();
106     if (dataShareHelper == nullptr) {
107         NETMGR_LOG_E("dataShareHelper is nullptr");
108         return NETMANAGER_ERROR;
109     }
110     DataShare::DataShareValuesBucket valuesBucket;
111     DataShare::DataShareValueObject keyObj(key);
112     DataShare::DataShareValueObject valueObj(value);
113     valuesBucket.Put(SETTINGS_DATA_COLUMN_KEYWORD, keyObj);
114     valuesBucket.Put(SETTINGS_DATA_COLUMN_VALUE, valueObj);
115     int32_t result = dataShareHelper->Insert(uri, valuesBucket);
116     if (result == INVALID_VALUE) {
117         NETMGR_LOG_E("insert failed");
118         dataShareHelper->Release();
119         return NETMANAGER_ERROR;
120     }
121     dataShareHelper->NotifyChange(uri);
122     dataShareHelper->Release();
123     NETMGR_LOG_I("insert success");
124     return NETMANAGER_SUCCESS;
125 }
126 
Update(Uri & uri,const std::string & key,const std::string & value)127 int32_t NetDataShareHelperUtils::Update(Uri &uri, const std::string &key, const std::string &value)
128 {
129     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper();
130     if (dataShareHelper == nullptr) {
131         NETMGR_LOG_E("dataShareHelper is nullptr");
132         return NETMANAGER_ERROR;
133     }
134     std::string queryValue;
135     int32_t ret = Query(uri, key, queryValue);
136     if (ret == NETMANAGER_ERROR) {
137         dataShareHelper->Release();
138         return Insert(uri, key, value);
139     }
140 
141     DataShare::DataShareValuesBucket valuesBucket;
142     DataShare::DataShareValueObject valueObj(value);
143     valuesBucket.Put(SETTINGS_DATA_COLUMN_VALUE, valueObj);
144     DataShare::DataSharePredicates predicates;
145     predicates.EqualTo(SETTINGS_DATA_COLUMN_KEYWORD, key);
146     int32_t result = dataShareHelper->Update(uri, predicates, valuesBucket);
147     if (result == INVALID_VALUE) {
148         dataShareHelper->Release();
149         return NETMANAGER_ERROR;
150     }
151     dataShareHelper->NotifyChange(uri);
152     dataShareHelper->Release();
153     NETMGR_LOG_I("update success");
154     return NETMANAGER_SUCCESS;
155 }
156 
Delete(Uri & uri,const std::string & key)157 int32_t NetDataShareHelperUtils::Delete(Uri &uri, const std::string &key)
158 {
159     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = CreateDataShareHelper();
160     if (dataShareHelper == nullptr) {
161         NETMGR_LOG_E("dataShareHelper is nullptr");
162         return NETMANAGER_ERROR;
163     }
164     std::string queryValue;
165     int32_t ret = Query(uri, key, queryValue);
166     if (ret == NETMANAGER_ERROR) {
167         dataShareHelper->Release();
168         NETMGR_LOG_D("don't have record");
169         return NETMANAGER_SUCCESS;
170     }
171 
172     DataShare::DataSharePredicates predicates;
173     predicates.EqualTo(SETTINGS_DATA_COLUMN_KEYWORD, key);
174     int32_t result = dataShareHelper->Delete(uri, predicates);
175     if (result == INVALID_VALUE) {
176         dataShareHelper->Release();
177         NETMGR_LOG_D("Delete failed");
178         return NETMANAGER_ERROR;
179     }
180     dataShareHelper->NotifyChange(uri);
181     dataShareHelper->Release();
182     NETMGR_LOG_I("Delete success");
183     return NETMANAGER_SUCCESS;
184 }
185 
RegisterObserver(const Uri & uri,const std::function<void ()> & onChange)186 int32_t NetDataShareHelperUtils::RegisterObserver(const Uri &uri, const std::function<void()> &onChange)
187 {
188     static std::atomic<int32_t> callbackId;
189     auto dataShareHelper = CreateDataShareHelper();
190     if (dataShareHelper == nullptr) {
191         NETMGR_LOG_E("dataShareHelper is nullptr");
192         return NETMANAGER_ERROR;
193     }
194     sptr<AAFwk::IDataAbilityObserver> observer = new (std::nothrow) NetDataAbilityObserver(onChange);
195     if (observer == nullptr) {
196         return NETMANAGER_ERROR;
197     }
198     dataShareHelper->RegisterObserver(uri, observer);
199     auto id = ++callbackId;
200     callbacks_.emplace(id, observer);
201     return id;
202 }
203 
UnregisterObserver(const Uri & uri,int32_t callbackId)204 int32_t NetDataShareHelperUtils::UnregisterObserver(const Uri &uri, int32_t callbackId)
205 {
206     auto dataShareHelper = CreateDataShareHelper();
207     if (dataShareHelper == nullptr) {
208         NETMGR_LOG_E("dataShareHelper is nullptr");
209         return NETMANAGER_ERROR;
210     }
211     auto it = callbacks_.find(callbackId);
212     if (it == callbacks_.end() || it->second == nullptr) {
213         return NETMANAGER_ERROR;
214     }
215     dataShareHelper->UnregisterObserver(uri, it->second);
216     return NETMANAGER_SUCCESS;
217 }
218 } // namespace NetManagerStandard
219 } // namespace OHOS
220