1 /*
2  * Copyright (c) 2023 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 "general_controller_service_impl.h"
17 #include <thread>
18 
19 #include "dataobs_mgr_client.h"
20 #include "dataobs_mgr_errors.h"
21 #include "datashare_log.h"
22 #include "datashare_string_utils.h"
23 
24 namespace OHOS {
25 namespace DataShare {
GeneralControllerServiceImpl(const std::string & ext)26 GeneralControllerServiceImpl::GeneralControllerServiceImpl(const std::string &ext)
27 {
28     extUri_ = ext;
29 }
30 
~GeneralControllerServiceImpl()31 GeneralControllerServiceImpl::~GeneralControllerServiceImpl()
32 {
33     auto manager = DataShareManagerImpl::GetInstance();
34     manager->RemoveRegisterCallback(this);
35 }
36 
Insert(const Uri & uri,const DataShareValuesBucket & value)37 int GeneralControllerServiceImpl::Insert(const Uri &uri, const DataShareValuesBucket &value)
38 {
39     auto manager = DataShareManagerImpl::GetInstance();
40     if (manager == nullptr) {
41         LOG_ERROR("Manager is nullptr");
42         return DATA_SHARE_ERROR;
43     }
44     manager->SetCallCount(__FUNCTION__, uri.ToString());
45     auto proxy = DataShareManagerImpl::GetServiceProxy();
46     if (proxy == nullptr) {
47         LOG_ERROR("proxy is nullptr");
48         return DATA_SHARE_ERROR;
49     }
50     return proxy->Insert(uri, Uri(extUri_), value);
51 }
52 
Update(const Uri & uri,const DataSharePredicates & predicates,const DataShareValuesBucket & value)53 int GeneralControllerServiceImpl::Update(const Uri &uri, const DataSharePredicates &predicates,
54     const DataShareValuesBucket &value)
55 {
56     auto manager = DataShareManagerImpl::GetInstance();
57     if (manager == nullptr) {
58         LOG_ERROR("Manager is nullptr");
59         return DATA_SHARE_ERROR;
60     }
61     manager->SetCallCount(__FUNCTION__, uri.ToString());
62     auto proxy = DataShareManagerImpl::GetServiceProxy();
63     if (proxy == nullptr) {
64         LOG_ERROR("proxy is nullptr");
65         return DATA_SHARE_ERROR;
66     }
67     return proxy->Update(uri, Uri(extUri_), predicates, value);
68 }
69 
Delete(const Uri & uri,const DataSharePredicates & predicates)70 int GeneralControllerServiceImpl::Delete(const Uri &uri, const DataSharePredicates &predicates)
71 {
72     auto manager = DataShareManagerImpl::GetInstance();
73     if (manager == nullptr) {
74         LOG_ERROR("Manager is nullptr");
75         return DATA_SHARE_ERROR;
76     }
77     manager->SetCallCount(__FUNCTION__, uri.ToString());
78     auto proxy = DataShareManagerImpl::GetServiceProxy();
79     if (proxy == nullptr) {
80         LOG_ERROR("proxy is nullptr");
81         return DATA_SHARE_ERROR;
82     }
83     return proxy->Delete(uri, Uri(extUri_), predicates);
84 }
85 
InsertEx(const Uri & uri,const DataShareValuesBucket & value)86 std::pair<int32_t, int32_t> GeneralControllerServiceImpl::InsertEx(const Uri &uri, const DataShareValuesBucket &value)
87 {
88     auto manager = DataShareManagerImpl::GetInstance();
89     if (manager == nullptr) {
90         LOG_ERROR("Manager is nullptr");
91         return std::make_pair(DATA_SHARE_ERROR, 0);
92     }
93     manager->SetCallCount(__FUNCTION__, uri.ToString());
94     auto proxy = DataShareManagerImpl::GetServiceProxy();
95     if (proxy == nullptr) {
96         LOG_ERROR("proxy is nullptr");
97         return std::make_pair(DATA_SHARE_ERROR, 0);
98     }
99     return proxy->InsertEx(uri, Uri(extUri_), value);
100 }
101 
UpdateEx(const Uri & uri,const DataSharePredicates & predicates,const DataShareValuesBucket & value)102 std::pair<int32_t, int32_t> GeneralControllerServiceImpl::UpdateEx(
103     const Uri &uri, const DataSharePredicates &predicates, const DataShareValuesBucket &value)
104 {
105     auto manager = DataShareManagerImpl::GetInstance();
106     if (manager == nullptr) {
107         LOG_ERROR("Manager is nullptr");
108         return std::make_pair(DATA_SHARE_ERROR, 0);
109     }
110     manager->SetCallCount(__FUNCTION__, uri.ToString());
111     auto proxy = DataShareManagerImpl::GetServiceProxy();
112     if (proxy == nullptr) {
113         LOG_ERROR("proxy is nullptr");
114         return std::make_pair(DATA_SHARE_ERROR, 0);
115     }
116     return proxy->UpdateEx(uri, Uri(extUri_), predicates, value);
117 }
118 
DeleteEx(const Uri & uri,const DataSharePredicates & predicates)119 std::pair<int32_t, int32_t> GeneralControllerServiceImpl::DeleteEx(const Uri &uri,
120     const DataSharePredicates &predicates)
121 {
122     auto manager = DataShareManagerImpl::GetInstance();
123     if (manager == nullptr) {
124         LOG_ERROR("Manager is nullptr");
125         return std::make_pair(DATA_SHARE_ERROR, 0);
126     }
127     manager->SetCallCount(__FUNCTION__, uri.ToString());
128     auto proxy = DataShareManagerImpl::GetServiceProxy();
129     if (proxy == nullptr) {
130         LOG_ERROR("proxy is nullptr");
131         return std::make_pair(DATA_SHARE_ERROR, 0);
132     }
133     return proxy->DeleteEx(uri, Uri(extUri_), predicates);
134 }
135 
Query(const Uri & uri,const DataSharePredicates & predicates,std::vector<std::string> & columns,DatashareBusinessError & businessError)136 std::shared_ptr<DataShareResultSet> GeneralControllerServiceImpl::Query(const Uri &uri,
137     const DataSharePredicates &predicates, std::vector<std::string> &columns, DatashareBusinessError &businessError)
138 {
139     auto manager = DataShareManagerImpl::GetInstance();
140     if (manager == nullptr) {
141         LOG_ERROR("Manager is nullptr");
142         return nullptr;
143     }
144     manager->SetCallCount(__FUNCTION__, uri.ToString());
145     auto proxy = DataShareManagerImpl::GetServiceProxy();
146     if (proxy == nullptr) {
147         LOG_ERROR("proxy is nullptr");
148         return nullptr;
149     }
150     auto resultSet = proxy->Query(uri, Uri(extUri_), predicates, columns, businessError);
151     int retryCount = 0;
152     while (resultSet == nullptr && businessError.GetCode() == E_RESULTSET_BUSY && retryCount++ < MAX_RETRY_COUNT) {
153         LOG_ERROR("resultSet busy retry, uri: %{public}s", DataShareStringUtils::Anonymous(uri.ToString()).c_str());
154         std::this_thread::sleep_for(std::chrono::milliseconds(
155             DataShareStringUtils::GetRandomNumber(RANDOM_MIN, RANDOM_MAX)));
156         resultSet = proxy->Query(uri, Uri(extUri_), predicates, columns, businessError);
157     }
158     return resultSet;
159 }
160 
RegisterObserver(const Uri & uri,const sptr<AAFwk::IDataAbilityObserver> & dataObserver)161 int GeneralControllerServiceImpl::RegisterObserver(const Uri &uri,
162     const sptr<AAFwk::IDataAbilityObserver> &dataObserver)
163 {
164     auto manager = DataShareManagerImpl::GetInstance();
165     if (manager == nullptr) {
166         LOG_ERROR("Manager is nullptr");
167         return E_DATA_SHARE_NOT_READY;
168     }
169     manager->SetCallCount(__FUNCTION__, uri.ToString());
170     auto obsMgrClient = OHOS::AAFwk::DataObsMgrClient::GetInstance();
171     if (obsMgrClient == nullptr) {
172         LOG_ERROR("get DataObsMgrClient failed");
173         return E_DATA_OBS_NOT_READY;
174     }
175     ErrCode ret = obsMgrClient->RegisterObserver(uri, dataObserver);
176     LOG_INFO("Register silent observer ret: %{public}d, uri: %{public}s", ret,
177         DataShareStringUtils::Anonymous(uri.ToString()).c_str());
178     return ret;
179 }
180 
UnregisterObserver(const Uri & uri,const sptr<AAFwk::IDataAbilityObserver> & dataObserver)181 int GeneralControllerServiceImpl::UnregisterObserver(const Uri &uri,
182     const sptr<AAFwk::IDataAbilityObserver> &dataObserver)
183 {
184     auto obsMgrClient = OHOS::AAFwk::DataObsMgrClient::GetInstance();
185     if (obsMgrClient == nullptr) {
186         LOG_ERROR("get DataObsMgrClient failed");
187         return E_DATA_OBS_NOT_READY;
188     }
189     ErrCode ret = obsMgrClient->UnregisterObserver(uri, dataObserver);
190     LOG_INFO("Unregister silent observer ret: %{public}d, uri: %{public}s", ret,
191         DataShareStringUtils::Anonymous(uri.ToString()).c_str());
192     return ret;
193 }
194 
NotifyChange(const Uri & uri)195 void GeneralControllerServiceImpl::NotifyChange(const Uri &uri)
196 {
197     auto proxy = DataShareManagerImpl::GetServiceProxy();
198     if (proxy == nullptr) {
199         LOG_ERROR("proxy is nullptr");
200         return;
201     }
202     proxy->Notify(uri.ToString());
203 }
204 
SetRegisterCallback()205 void GeneralControllerServiceImpl::SetRegisterCallback()
206 {
207     auto manager = DataShareManagerImpl::GetInstance();
208     if (manager == nullptr) {
209         LOG_ERROR("Manager is nullptr");
210         return;
211     }
212     auto registerCallback = [this]() {
213         ReRegisterObserver();
214     };
215     manager->SetRegisterCallback(this, registerCallback);
216 }
217 
ReRegisterObserver()218 void GeneralControllerServiceImpl::ReRegisterObserver()
219 {
220     LOG_INFO("Distributeddata service on start, reRegister observer.");
221     decltype(observers_) observers(std::move(observers_));
222     observers_.Clear();
223     observers.ForEach([this](const auto &key, const auto &value) {
224         for (const auto &uri : value) {
225             RegisterObserver(uri, key);
226         }
227         return false;
228     });
229 }
230 } // namespace DataShare
231 } // namespace OHOS