1 /*
2 * Copyright (c) 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 "js_query_erms_observer.h"
17
18 #include "ability_manager_errors.h"
19 #include "hilog_tag_wrapper.h"
20 #include "hitrace_meter.h"
21 #include "js_error_utils.h"
22 #include "js_runtime.h"
23 #include "js_runtime_utils.h"
24 #include "napi/native_api.h"
25
26 namespace OHOS {
27 namespace AbilityRuntime {
JsQueryERMSObserver(napi_env env)28 JsQueryERMSObserver::JsQueryERMSObserver(napi_env env) : env_(env) {}
29
30 JsQueryERMSObserver::~JsQueryERMSObserver() = default;
31
OnQueryFinished(const std::string & appId,const std::string & startTime,const AtomicServiceStartupRule & rule,int32_t resultCode)32 void JsQueryERMSObserver::OnQueryFinished(const std::string &appId, const std::string &startTime,
33 const AtomicServiceStartupRule &rule, int32_t resultCode)
34 {
35 TAG_LOGD(AAFwkTag::QUERY_ERMS, "call");
36 wptr<JsQueryERMSObserver> jsObserver = this;
37 std::unique_ptr<NapiAsyncTask::CompleteCallback> complete = std::make_unique<NapiAsyncTask::CompleteCallback>
38 ([jsObserver, appId, startTime, rule, resultCode](napi_env env, NapiAsyncTask &task, int32_t status) {
39 sptr<JsQueryERMSObserver> jsObserverSptr = jsObserver.promote();
40 if (jsObserverSptr == nullptr) {
41 TAG_LOGE(AAFwkTag::QUERY_ERMS, "null jsObserverSptr");
42 return;
43 }
44 if (resultCode == AAFwk::ERR_CAPABILITY_NOT_SUPPORT || resultCode == ERR_OK) {
45 jsObserverSptr->HandleOnQueryFinished(appId, startTime, rule, resultCode);
46 return;
47 }
48 jsObserverSptr->HandleOnQueryFinished(appId, startTime, rule, AAFwk::INNER_ERR);
49 });
50 napi_ref callback = nullptr;
51 std::unique_ptr<NapiAsyncTask::ExecuteCallback> execute = nullptr;
52 NapiAsyncTask::Schedule("JsQueryERMSObserver::OnQueryFinished", env_, std::make_unique<NapiAsyncTask>(callback,
53 std::move(execute), std::move(complete)));
54 }
55
HandleOnQueryFinished(const std::string & appId,const std::string & startTime,const AtomicServiceStartupRule & rule,int32_t resultCode)56 void JsQueryERMSObserver::HandleOnQueryFinished(const std::string &appId, const std::string &startTime,
57 const AtomicServiceStartupRule &rule, int32_t resultCode)
58 {
59 TAG_LOGD(AAFwkTag::QUERY_ERMS, "call");
60 std::vector<napi_deferred> promises;
61 {
62 std::unique_lock<std::mutex> lock(jsObserverObjectListLock_);
63 for (auto it = jsObserverObjectList_.begin(); it != jsObserverObjectList_.end();) {
64 if (it->appId != appId || it->startTime != startTime || it->deferred == nullptr) {
65 it++;
66 continue;
67 }
68 promises.emplace_back(it->deferred);
69 it = jsObserverObjectList_.erase(it);
70 }
71 }
72
73 for (const napi_deferred& promise : promises) {
74 CallPromise(promise, rule, resultCode);
75 FinishAsyncTrace(HITRACE_TAG_ABILITY_MANAGER, "StartQueryERMS", atoi(startTime.c_str()));
76 }
77 }
78
CallPromise(napi_deferred deferred,const AtomicServiceStartupRule & rule,int32_t resultCode)79 void JsQueryERMSObserver::CallPromise(napi_deferred deferred, const AtomicServiceStartupRule &rule,
80 int32_t resultCode)
81 {
82 if (deferred == nullptr) {
83 TAG_LOGE(AAFwkTag::QUERY_ERMS, "deferred is nullptr");
84 return;
85 }
86 if (resultCode == ERR_OK) {
87 napi_value result = CreateJsAtomicServiceStartupRule(env_, rule);
88 napi_resolve_deferred(env_, deferred, result);
89 return;
90 }
91 napi_value error = CreateJsError(env_, GetJsErrorCodeByNativeError(resultCode));
92 napi_reject_deferred(env_, deferred, error);
93 }
94
AddJsObserverObject(const std::string & appId,const std::string & startTime,napi_value * result)95 void JsQueryERMSObserver::AddJsObserverObject(const std::string &appId, const std::string &startTime,
96 napi_value* result)
97 {
98 TAG_LOGD(AAFwkTag::QUERY_ERMS, "call");
99 {
100 std::unique_lock<std::mutex> lock(jsObserverObjectListLock_);
101 for (auto it = jsObserverObjectList_.begin(); it != jsObserverObjectList_.end(); ++it) {
102 if (it->appId == appId && it->startTime == startTime) {
103 TAG_LOGW(AAFwkTag::QUERY_ERMS, "The jsObject has been added");
104 return;
105 }
106 }
107 }
108
109 StartAsyncTrace(HITRACE_TAG_ABILITY_MANAGER, "StartQueryERMS", atoi(startTime.c_str()));
110 JsQueryERMSObserverObject object;
111 object.appId = appId;
112 object.startTime = startTime;
113 napi_deferred deferred;
114 napi_create_promise(env_, &deferred, result);
115 object.deferred = deferred;
116
117 std::unique_lock<std::mutex> lock(jsObserverObjectListLock_);
118 jsObserverObjectList_.emplace_back(object);
119 }
120
CreateJsAtomicServiceStartupRule(napi_env env,const AbilityRuntime::AtomicServiceStartupRule & rule)121 napi_value JsQueryERMSObserver::CreateJsAtomicServiceStartupRule(napi_env env,
122 const AbilityRuntime::AtomicServiceStartupRule &rule)
123 {
124 napi_value object = nullptr;
125 napi_create_object(env, &object);
126
127 napi_set_named_property(env, object, "isOpenAllowed", CreateJsValue(env, rule.isOpenAllowed));
128 napi_set_named_property(env, object, "isEmbeddedAllowed", CreateJsValue(env, rule.isEmbeddedAllowed));
129 return object;
130 }
131 } // namespace AbilityRuntime
132 } // namespace OHOS