1 /*
2 * Copyright (C) 2025 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 "usb_settings_datashare.h"
17
18 #include "hilog_wrapper.h"
19 #include "datashare_helper.h"
20 #include "datashare_predicates.h"
21 #include "iservice_registry.h"
22 #include "uri.h"
23 #include "singleton.h"
24
25 namespace OHOS {
26 namespace USB {
27 namespace {
28 constexpr const char *SETTINGS_DATASHARE_URI =
29 "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true";
30 const std::string SETTINGS_DATASHARE_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
UsbSettingDataShare()35 UsbSettingDataShare::UsbSettingDataShare()
36 {
37 datashareHelper_ = CreateDataShareHelper(USB_SYSTEM_ABILITY_ID);
38 }
39
~UsbSettingDataShare()40 UsbSettingDataShare::~UsbSettingDataShare()
41 {
42 if (datashareHelper_ != nullptr) {
43 USB_HILOGI(MODULE_USB_SERVICE, "datashareHelper_ is here Release!");
44 datashareHelper_->Release();
45 }
46 }
47
CreateDataShareHelper(int systemAbilityId)48 std::shared_ptr<DataShare::DataShareHelper> UsbSettingDataShare::CreateDataShareHelper(int systemAbilityId)
49 {
50 USB_HILOGI(MODULE_USB_SERVICE, "CreateDataShareHelper start!");
51 sptr<ISystemAbilityManager> saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
52 if (saManager == nullptr) {
53 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: GetSystemAbilityManager failed!", __func__);
54 return nullptr;
55 }
56 sptr<IRemoteObject> remote = saManager->GetSystemAbility(systemAbilityId);
57 if (remote == nullptr) {
58 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: GetSystemAbility Service Failed!", __func__);
59 return nullptr;
60 }
61 USB_HILOGI(MODULE_USB_SERVICE, "%{public}s: systemAbilityId = %{public}d", __func__, systemAbilityId);
62 auto [ret, helper] = DataShare::DataShareHelper::Create(remote, SETTINGS_DATASHARE_URI, SETTINGS_DATASHARE_EXT_URI);
63 if (ret == DataShare::E_OK) {
64 return helper;
65 } else if (ret == DataShare::E_DATA_SHARE_NOT_READY) {
66 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: data is not ready!", __func__);
67 return nullptr;
68 } else {
69 USB_HILOGE(MODULE_USB_SERVICE, "%{public}s: create datashare failed, ret = %{public}d.", __func__, ret);
70 return nullptr;
71 }
72 }
73
Query(Uri & uri,const std::string & key,std::string & value)74 bool UsbSettingDataShare::Query(Uri &uri, const std::string &key, std::string &value)
75 {
76 USB_HILOGI(MODULE_USB_SERVICE, "start Query key = %{public}s", key.c_str());
77 if (datashareHelper_ == nullptr) {
78 USB_HILOGE(MODULE_USB_SERVICE, "query error, datashareHelper_ is nullptr");
79 return false;
80 }
81
82 std::vector<std::string> columns;
83 DataShare::DataSharePredicates predicates;
84 predicates.EqualTo(SETTINGS_DATA_COLUMN_KEYWORD, key);
85 auto result = datashareHelper_->Query(uri, predicates, columns);
86 if (result == nullptr) {
87 USB_HILOGE(MODULE_USB_SERVICE, "query error, result is nullptr");
88 return false;
89 }
90
91 if (result->GoToFirstRow() != DataShare::E_OK) {
92 USB_HILOGE(MODULE_USB_SERVICE, "query error, go to first row error");
93 result->Close();
94 return false;
95 }
96
97 int columnIndex = 0;
98 result->GetColumnIndex(SETTINGS_DATA_COLUMN_VALUE, columnIndex);
99 result->GetString(columnIndex, value);
100 result->Close();
101 USB_HILOGI(MODULE_USB_SERVICE, "SettingUtils: query success");
102 return true;
103 }
104
Insert(Uri uri,const std::string & key,std::string & value)105 bool UsbSettingDataShare::Insert(Uri uri, const std::string &key, std::string &value)
106 {
107 USB_HILOGI(MODULE_USB_SERVICE, "start Insert key = %{public}s", key.c_str());
108 if (datashareHelper_ == nullptr) {
109 USB_HILOGE(MODULE_USB_SERVICE, "query error, datashareHelper_ is nullptr");
110 return false;
111 }
112 DataShare::DataShareValuesBucket valuesBucket;
113 DataShare::DataShareValueObject keyObj(key);
114 DataShare::DataShareValueObject valueObj(value);
115 valuesBucket.Put(SETTINGS_DATA_COLUMN_KEYWORD, keyObj);
116 valuesBucket.Put(SETTINGS_DATA_COLUMN_VALUE, valueObj);
117 int32_t result = datashareHelper_->Insert(uri, valuesBucket);
118 if (result == RDB_INVALID_VALUE) {
119 datashareHelper_->Release();
120 return false;
121 }
122 USB_HILOGI(MODULE_USB_SERVICE, "UsbSettingDataShare: insert success");
123 datashareHelper_->NotifyChange(uri);
124 datashareHelper_->Release();
125 return true;
126 }
127
Update(Uri uri,const std::string & key,std::string & value)128 bool UsbSettingDataShare::Update(Uri uri, const std::string &key, std::string &value)
129 {
130 if (datashareHelper_ == nullptr) {
131 USB_HILOGE(MODULE_USB_SERVICE, "query error, datashareHelper_ is nullptr");
132 return false;
133 }
134 USB_HILOGI(MODULE_USB_SERVICE, "start Update key = %{public}s", key.c_str());
135 std::string queryValue = "";
136 if (!Query(uri, key, queryValue)) {
137 USB_HILOGI(MODULE_USB_SERVICE, "%{public}s is cannot Query!", key.c_str());
138 return Insert(uri, key, value);
139 }
140 DataShare::DataShareValuesBucket valuesBucket;
141 DataShare::DataShareValueObject valueObj(value);
142 valuesBucket.Put(SETTINGS_DATA_COLUMN_VALUE, valueObj);
143 DataShare::DataSharePredicates predicates;
144 predicates.EqualTo(SETTINGS_DATA_COLUMN_KEYWORD, key);
145 int32_t result = datashareHelper_->Update(uri, predicates, valuesBucket);
146 if (result == RDB_INVALID_VALUE) {
147 USB_HILOGE(MODULE_USB_SERVICE, "fail to update %{public}s !", key.c_str());
148 datashareHelper_->Release();
149 return false;
150 }
151 USB_HILOGI(MODULE_USB_SERVICE, "UsbSettingDataShare: update success");
152 datashareHelper_->NotifyChange(uri);
153 datashareHelper_->Release();
154 return true;
155 }
156 } // namespace USB
157 } // namespace OHOS
158