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