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 "dataobs_mgr_service.h"
17
18 #include <functional>
19 #include <memory>
20 #include <string>
21 #include <unistd.h>
22 #include "string_ex.h"
23
24 #include "dataobs_mgr_errors.h"
25 #include "hilog_wrapper.h"
26 #include "if_system_ability_manager.h"
27 #include "ipc_skeleton.h"
28 #include "system_ability_definition.h"
29
30 namespace OHOS {
31 namespace AAFwk {
32 const bool REGISTER_RESULT =
33 SystemAbility::MakeAndRegisterAbility(DelayedSingleton<DataObsMgrService>::GetInstance().get());
34
DataObsMgrService()35 DataObsMgrService::DataObsMgrService()
36 : SystemAbility(DATAOBS_MGR_SERVICE_SA_ID, true),
37 eventLoop_(nullptr),
38 handler_(nullptr),
39 state_(DataObsServiceRunningState::STATE_NOT_START)
40 {
41 dataObsMgrInner_ = std::make_shared<DataObsMgrInner>();
42 }
43
~DataObsMgrService()44 DataObsMgrService::~DataObsMgrService()
45 {}
46
OnStart()47 void DataObsMgrService::OnStart()
48 {
49 if (state_ == DataObsServiceRunningState::STATE_RUNNING) {
50 HILOG_INFO("Dataobs Manager Service has already started.");
51 return;
52 }
53 HILOG_INFO("Dataobs Manager Service started.");
54 if (!Init()) {
55 HILOG_ERROR("failed to init service.");
56 return;
57 }
58 state_ = DataObsServiceRunningState::STATE_RUNNING;
59 eventLoop_->Run();
60 /* Publish service maybe failed, so we need call this function at the last,
61 * so it can't affect the TDD test program */
62 bool ret = Publish(DelayedSingleton<DataObsMgrService>::GetInstance().get());
63 if (!ret) {
64 HILOG_ERROR("DataObsMgrService::Init Publish failed!");
65 return;
66 }
67
68 HILOG_INFO("Ability Manager Service start success.");
69 }
70
Init()71 bool DataObsMgrService::Init()
72 {
73 eventLoop_ = AppExecFwk::EventRunner::Create("DataObsMgrService");
74 if (eventLoop_ == nullptr) {
75 return false;
76 }
77
78 handler_ = std::make_shared<AppExecFwk::EventHandler>(eventLoop_);
79 dataObsMgrInner_->SetHandler(handler_);
80
81 HILOG_INFO("init success");
82 return true;
83 }
84
OnStop()85 void DataObsMgrService::OnStop()
86 {
87 HILOG_INFO("stop service");
88 eventLoop_.reset();
89 handler_.reset();
90 state_ = DataObsServiceRunningState::STATE_NOT_START;
91 }
92
QueryServiceState() const93 DataObsServiceRunningState DataObsMgrService::QueryServiceState() const
94 {
95 return state_;
96 }
97
RegisterObserver(const Uri & uri,const sptr<IDataAbilityObserver> & dataObserver)98 int DataObsMgrService::RegisterObserver(const Uri &uri, const sptr<IDataAbilityObserver> &dataObserver)
99 {
100 HILOG_INFO("DataObsMgrService::RegisterObserver called start");
101 if (dataObserver == nullptr) {
102 HILOG_ERROR("DataObsMgrService::RegisterObserver failed!. dataObserver is nullptr");
103 return DATA_OBSERVER_IS_NULL;
104 }
105
106 if (handler_ == nullptr) {
107 HILOG_ERROR("DataObsMgrService::RegisterObserver failed!. handler is nullptr");
108 return DATAOBS_SERVICE_HANDLER_IS_NULL;
109 }
110
111 if (dataObsMgrInner_ == nullptr) {
112 HILOG_ERROR("DataObsMgrService::RegisterObserver failed!. dataObsMgrInner_ is nullptr");
113 return DATAOBS_SERVICE_INNER_IS_NULL;
114 }
115
116 if (dataObsMgrInner_->CheckNeedLimmit()) {
117 return DATAOBS_SERVICE_TASK_LIMMIT;
118 }
119
120 if (dataObsMgrInner_->CheckRegisteFull(uri)) {
121 HILOG_ERROR("The number of subscribers for this uri has reached the upper limit.");
122 return DATAOBS_SERVICE_OBS_LIMMIT;
123 }
124
125 std::function<void()> registerObserverFunc =
126 std::bind(&DataObsMgrInner::HandleRegisterObserver, dataObsMgrInner_, uri, dataObserver);
127
128 dataObsMgrInner_->AtomicAddTaskCount();
129 bool ret = handler_->PostTask(registerObserverFunc);
130 if (!ret) {
131 dataObsMgrInner_->AtomicSubTaskCount();
132 HILOG_ERROR("DataObsMgrService::RegisterObserver PostTask error");
133 return DATAOBS_SERVICE_POST_TASK_FAILED;
134 }
135 HILOG_INFO("DataObsMgrService::RegisterObserver called end");
136 return NO_ERROR;
137 }
138
UnregisterObserver(const Uri & uri,const sptr<IDataAbilityObserver> & dataObserver)139 int DataObsMgrService::UnregisterObserver(const Uri &uri, const sptr<IDataAbilityObserver> &dataObserver)
140 {
141 HILOG_INFO("DataObsMgrService::UnregisterObserver called start");
142 if (dataObserver == nullptr) {
143 HILOG_ERROR("DataObsMgrService::UnregisterObserver failed!. dataObserver is nullptr");
144 return DATA_OBSERVER_IS_NULL;
145 }
146
147 if (handler_ == nullptr) {
148 HILOG_ERROR("DataObsMgrService::UnregisterObserver failed!. handler is nullptr");
149 return DATAOBS_SERVICE_HANDLER_IS_NULL;
150 }
151
152 if (dataObsMgrInner_ == nullptr) {
153 HILOG_ERROR("DataObsMgrService::UnregisterObserver failed!. dataObsMgrInner_ is nullptr");
154 return DATAOBS_SERVICE_INNER_IS_NULL;
155 }
156
157 if (dataObsMgrInner_->CheckNeedLimmit()) {
158 return DATAOBS_SERVICE_TASK_LIMMIT;
159 }
160
161 std::function<void()> unregisterObserverFunc =
162 std::bind(&DataObsMgrInner::HandleUnregisterObserver, dataObsMgrInner_, uri, dataObserver);
163
164 dataObsMgrInner_->AtomicAddTaskCount();
165 bool ret = handler_->PostSyncTask(unregisterObserverFunc);
166 if (!ret) {
167 dataObsMgrInner_->AtomicSubTaskCount();
168 HILOG_ERROR("DataObsMgrService::UnregisterObserver PostTask error");
169 return DATAOBS_SERVICE_POST_TASK_FAILED;
170 }
171 HILOG_INFO("DataObsMgrService::UnregisterObserver called end");
172 return NO_ERROR;
173 }
174
NotifyChange(const Uri & uri)175 int DataObsMgrService::NotifyChange(const Uri &uri)
176 {
177 HILOG_INFO("DataObsMgrService::NotifyChange called start");
178 if (handler_ == nullptr) {
179 HILOG_ERROR("DataObsMgrService::NotifyChange failed!. handler is nullptr");
180 return DATAOBS_SERVICE_HANDLER_IS_NULL;
181 }
182
183 if (dataObsMgrInner_ == nullptr) {
184 HILOG_ERROR("DataObsMgrService::NotifyChange failed!. dataObsMgrInner_ is nullptr");
185 return DATAOBS_SERVICE_INNER_IS_NULL;
186 }
187
188 if (dataObsMgrInner_->CheckNeedLimmit()) {
189 return DATAOBS_SERVICE_TASK_LIMMIT;
190 }
191
192 std::function<void()> notifyChangeFunc = std::bind(&DataObsMgrInner::HandleNotifyChange, dataObsMgrInner_, uri);
193
194 dataObsMgrInner_->AtomicAddTaskCount();
195 bool ret = handler_->PostTask(notifyChangeFunc);
196 if (!ret) {
197 dataObsMgrInner_->AtomicSubTaskCount();
198 HILOG_ERROR("DataObsMgrService::NotifyChange PostTask error");
199 return DATAOBS_SERVICE_POST_TASK_FAILED;
200 }
201 HILOG_INFO("DataObsMgrService::NotifyChange called end");
202 return NO_ERROR;
203 }
204
Dump(int fd,const std::vector<std::u16string> & args)205 int DataObsMgrService::Dump(int fd, const std::vector<std::u16string>& args)
206 {
207 std::string result;
208 Dump(args, result);
209 int ret = dprintf(fd, "%s\n", result.c_str());
210 if (ret < 0) {
211 HILOG_ERROR("%{public}s, dprintf error.", __func__);
212 return DATAOBS_HIDUMP_ERROR;
213 }
214 return ERR_OK;
215 }
216
Dump(const std::vector<std::u16string> & args,std::string & result) const217 void DataObsMgrService::Dump(const std::vector<std::u16string>& args, std::string& result) const
218 {
219 auto size = args.size();
220 if (size == 0) {
221 ShowHelp(result);
222 return;
223 }
224
225 std::string optionKey = Str16ToStr8(args[0]);
226 if (optionKey != "-h") {
227 result.append("error: unkown option.\n");
228 }
229 ShowHelp(result);
230 }
231
ShowHelp(std::string & result) const232 void DataObsMgrService::ShowHelp(std::string& result) const
233 {
234 result.append("Usage:\n")
235 .append("-h ")
236 .append("help text for the tool\n");
237 }
238
GetEventHandler()239 std::shared_ptr<EventHandler> DataObsMgrService::GetEventHandler()
240 {
241 return handler_;
242 }
243 } // namespace AAFwk
244 } // namespace OHOS
245