1 /*
2  * Copyright (c) 2023-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_embeddable_ui_ability_context.h"
17 
18 #include <chrono>
19 #include <cstdint>
20 #include <string>
21 
22 #include "ability_manager_client.h"
23 #include "event_handler.h"
24 #include "hilog_tag_wrapper.h"
25 #include "js_context_utils.h"
26 #include "js_data_struct_converter.h"
27 #include "js_error_utils.h"
28 #include "js_runtime.h"
29 #include "js_runtime_utils.h"
30 #include "napi/native_api.h"
31 #include "napi_common_ability.h"
32 #include "napi_common_want.h"
33 #include "napi_common_util.h"
34 #include "napi_common_start_options.h"
35 #include "want.h"
36 
37 namespace OHOS {
38 namespace AbilityRuntime {
39 #define CHECK_POINTER_RETURN(env, object)            \
40     if (!(object)) {                                 \
41         TAG_LOGE(AAFwkTag::UI_EXT, "Context is nullptr");           \
42         return CreateJsUndefined(env);               \
43     }
44 
45 namespace {
46 const std::string ERR_MSG_NOT_SUPPORT = "Not support the interface in embedded screen mode of atomic service.";
47 }
48 
JsEmbeddableUIAbilityContext(const std::shared_ptr<AbilityContext> & uiAbiContext,const std::shared_ptr<UIExtensionContext> & uiExtContext,int32_t screenMode)49 JsEmbeddableUIAbilityContext::JsEmbeddableUIAbilityContext(const std::shared_ptr<AbilityContext>& uiAbiContext,
50     const std::shared_ptr<UIExtensionContext>& uiExtContext, int32_t screenMode)
51 {
52     jsAbilityContext_ = std::make_shared<JsAbilityContext>(uiAbiContext);
53     jsUIExtensionContext_ = std::make_shared<JsUIExtensionContext>(uiExtContext);
54     screenMode_ = screenMode;
55 }
56 
Finalizer(napi_env env,void * data,void * hint)57 void JsEmbeddableUIAbilityContext::Finalizer(napi_env env, void* data, void* hint)
58 {
59     TAG_LOGD(AAFwkTag::UI_EXT, "called");
60     std::unique_ptr<JsEmbeddableUIAbilityContext>(static_cast<JsEmbeddableUIAbilityContext*>(data));
61 }
62 
StartAbility(napi_env env,napi_callback_info info)63 napi_value JsEmbeddableUIAbilityContext::StartAbility(napi_env env, napi_callback_info info)
64 {
65     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnStartAbility);
66 }
67 
OpenLink(napi_env env,napi_callback_info info)68 napi_value JsEmbeddableUIAbilityContext::OpenLink(napi_env env, napi_callback_info info)
69 {
70     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnOpenLink);
71 }
72 
StartAbilityForResult(napi_env env,napi_callback_info info)73 napi_value JsEmbeddableUIAbilityContext::StartAbilityForResult(napi_env env, napi_callback_info info)
74 {
75     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnStartAbilityForResult);
76 }
77 
ConnectAbility(napi_env env,napi_callback_info info)78 napi_value JsEmbeddableUIAbilityContext::ConnectAbility(napi_env env, napi_callback_info info)
79 {
80     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnConnectAbility);
81 }
82 
DisconnectAbility(napi_env env,napi_callback_info info)83 napi_value JsEmbeddableUIAbilityContext::DisconnectAbility(napi_env env, napi_callback_info info)
84 {
85     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnDisconnectAbility);
86 }
87 
TerminateSelf(napi_env env,napi_callback_info info)88 napi_value JsEmbeddableUIAbilityContext::TerminateSelf(napi_env env, napi_callback_info info)
89 {
90     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnTerminateSelf);
91 }
92 
TerminateSelfWithResult(napi_env env,napi_callback_info info)93 napi_value JsEmbeddableUIAbilityContext::TerminateSelfWithResult(napi_env env, napi_callback_info info)
94 {
95     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnTerminateSelfWithResult);
96 }
97 
BackToCallerAbilityWithResult(napi_env env,napi_callback_info info)98 napi_value JsEmbeddableUIAbilityContext::BackToCallerAbilityWithResult(napi_env env, napi_callback_info info)
99 {
100     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnBackToCallerAbilityWithResult);
101 }
102 
StartAbilityAsCaller(napi_env env,napi_callback_info info)103 napi_value JsEmbeddableUIAbilityContext::StartAbilityAsCaller(napi_env env, napi_callback_info info)
104 {
105     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnStartAbilityAsCaller);
106 }
107 
StartAbilityWithAccount(napi_env env,napi_callback_info info)108 napi_value JsEmbeddableUIAbilityContext::StartAbilityWithAccount(napi_env env, napi_callback_info info)
109 {
110     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnStartAbilityWithAccount);
111 }
112 
StartAbilityByCall(napi_env env,napi_callback_info info)113 napi_value JsEmbeddableUIAbilityContext::StartAbilityByCall(napi_env env, napi_callback_info info)
114 {
115     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnStartAbilityByCall);
116 }
117 
StartAbilityForResultWithAccount(napi_env env,napi_callback_info info)118 napi_value JsEmbeddableUIAbilityContext::StartAbilityForResultWithAccount(napi_env env, napi_callback_info info)
119 {
120     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnStartAbilityForResultWithAccount);
121 }
122 
StartServiceExtensionAbility(napi_env env,napi_callback_info info)123 napi_value JsEmbeddableUIAbilityContext::StartServiceExtensionAbility(napi_env env, napi_callback_info info)
124 {
125     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnStartExtensionAbility);
126 }
127 
StartServiceExtensionAbilityWithAccount(napi_env env,napi_callback_info info)128 napi_value JsEmbeddableUIAbilityContext::StartServiceExtensionAbilityWithAccount(napi_env env, napi_callback_info info)
129 {
130     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnStartExtensionAbilityWithAccount);
131 }
132 
StopServiceExtensionAbility(napi_env env,napi_callback_info info)133 napi_value JsEmbeddableUIAbilityContext::StopServiceExtensionAbility(napi_env env, napi_callback_info info)
134 {
135     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnStopExtensionAbility);
136 }
137 
StopServiceExtensionAbilityWithAccount(napi_env env,napi_callback_info info)138 napi_value JsEmbeddableUIAbilityContext::StopServiceExtensionAbilityWithAccount(napi_env env, napi_callback_info info)
139 {
140     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnStopExtensionAbilityWithAccount);
141 }
142 
ConnectAbilityWithAccount(napi_env env,napi_callback_info info)143 napi_value JsEmbeddableUIAbilityContext::ConnectAbilityWithAccount(napi_env env, napi_callback_info info)
144 {
145     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnConnectAbilityWithAccount);
146 }
147 
RestoreWindowStage(napi_env env,napi_callback_info info)148 napi_value JsEmbeddableUIAbilityContext::RestoreWindowStage(napi_env env, napi_callback_info info)
149 {
150     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnRestoreWindowStage);
151 }
152 
IsTerminating(napi_env env,napi_callback_info info)153 napi_value JsEmbeddableUIAbilityContext::IsTerminating(napi_env env, napi_callback_info info)
154 {
155     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnIsTerminating);
156 }
157 
StartRecentAbility(napi_env env,napi_callback_info info)158 napi_value JsEmbeddableUIAbilityContext::StartRecentAbility(napi_env env, napi_callback_info info)
159 {
160     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnStartRecentAbility);
161 }
162 
RequestDialogService(napi_env env,napi_callback_info info)163 napi_value JsEmbeddableUIAbilityContext::RequestDialogService(napi_env env, napi_callback_info info)
164 {
165     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnRequestDialogService);
166 }
167 
ReportDrawnCompleted(napi_env env,napi_callback_info info)168 napi_value JsEmbeddableUIAbilityContext::ReportDrawnCompleted(napi_env env, napi_callback_info info)
169 {
170     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnReportDrawnCompleted);
171 }
172 
SetMissionContinueState(napi_env env,napi_callback_info info)173 napi_value JsEmbeddableUIAbilityContext::SetMissionContinueState(napi_env env, napi_callback_info info)
174 {
175     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnSetMissionContinueState);
176 }
177 
StartAbilityByType(napi_env env,napi_callback_info info)178 napi_value JsEmbeddableUIAbilityContext::StartAbilityByType(napi_env env, napi_callback_info info)
179 {
180     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnStartAbilityByType);
181 }
182 
MoveAbilityToBackground(napi_env env,napi_callback_info info)183 napi_value JsEmbeddableUIAbilityContext::MoveAbilityToBackground(napi_env env, napi_callback_info info)
184 {
185     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnMoveAbilityToBackground);
186 }
187 
RequestModalUIExtension(napi_env env,napi_callback_info info)188 napi_value JsEmbeddableUIAbilityContext::RequestModalUIExtension(napi_env env, napi_callback_info info)
189 {
190     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnRequestModalUIExtension);
191 }
192 
OpenAtomicService(napi_env env,napi_callback_info info)193 napi_value JsEmbeddableUIAbilityContext::OpenAtomicService(napi_env env, napi_callback_info info)
194 {
195     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnOpenAtomicService);
196 }
197 
ShowAbility(napi_env env,napi_callback_info info)198 napi_value JsEmbeddableUIAbilityContext::ShowAbility(napi_env env, napi_callback_info info)
199 {
200     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnShowAbility);
201 }
202 
HideAbility(napi_env env,napi_callback_info info)203 napi_value JsEmbeddableUIAbilityContext::HideAbility(napi_env env, napi_callback_info info)
204 {
205     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnHideAbility);
206 }
207 
OnStartAbility(napi_env env,NapiCallbackInfo & info)208 napi_value JsEmbeddableUIAbilityContext::OnStartAbility(napi_env env, NapiCallbackInfo& info)
209 {
210     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
211         TAG_LOGI(AAFwkTag::UI_EXT, "Start ability in embedded screen mode");
212         CHECK_POINTER_RETURN(env, jsUIExtensionContext_);
213         return jsUIExtensionContext_->OnStartAbility(env, info);
214     }
215     CHECK_POINTER_RETURN(env, jsAbilityContext_);
216     return jsAbilityContext_->OnStartAbility(env, info);
217 }
218 
OnOpenLink(napi_env env,NapiCallbackInfo & info)219 napi_value JsEmbeddableUIAbilityContext::OnOpenLink(napi_env env, NapiCallbackInfo& info)
220 {
221     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
222         TAG_LOGI(AAFwkTag::UI_EXT, "Start openlink in embedded screen mode.");
223         CHECK_POINTER_RETURN(env, jsUIExtensionContext_);
224         return jsUIExtensionContext_->OnOpenLink(env, info);
225     }
226     CHECK_POINTER_RETURN(env, jsAbilityContext_);
227     return jsAbilityContext_->OnOpenLink(env, info);
228 }
229 
OnStartAbilityForResult(napi_env env,NapiCallbackInfo & info)230 napi_value JsEmbeddableUIAbilityContext::OnStartAbilityForResult(napi_env env, NapiCallbackInfo& info)
231 {
232     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
233         TAG_LOGI(AAFwkTag::UI_EXT, "Start ability for result in embedded screen mode");
234         CHECK_POINTER_RETURN(env, jsUIExtensionContext_);
235         return jsUIExtensionContext_->OnStartAbilityForResult(env, info);
236     }
237     CHECK_POINTER_RETURN(env, jsAbilityContext_);
238     return jsAbilityContext_->OnStartAbilityForResult(env, info);
239 }
240 
OnConnectAbility(napi_env env,NapiCallbackInfo & info)241 napi_value JsEmbeddableUIAbilityContext::OnConnectAbility(napi_env env, NapiCallbackInfo& info)
242 {
243     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
244         TAG_LOGI(AAFwkTag::UI_EXT, "Connect ability in embedded screen mode");
245         CHECK_POINTER_RETURN(env, jsUIExtensionContext_);
246         return jsUIExtensionContext_->OnConnectAbility(env, info);
247     }
248     CHECK_POINTER_RETURN(env, jsAbilityContext_);
249     return jsAbilityContext_->OnConnectAbility(env, info);
250 }
251 
OnDisconnectAbility(napi_env env,NapiCallbackInfo & info)252 napi_value JsEmbeddableUIAbilityContext::OnDisconnectAbility(napi_env env, NapiCallbackInfo& info)
253 {
254     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
255         TAG_LOGI(AAFwkTag::UI_EXT, "Disconnect ability in embedded screen mode");
256         CHECK_POINTER_RETURN(env, jsUIExtensionContext_);
257         return jsUIExtensionContext_->OnDisconnectAbility(env, info);
258     }
259     CHECK_POINTER_RETURN(env, jsAbilityContext_);
260     return jsAbilityContext_->OnDisconnectAbility(env, info);
261 }
262 
OnTerminateSelf(napi_env env,NapiCallbackInfo & info)263 napi_value JsEmbeddableUIAbilityContext::OnTerminateSelf(napi_env env, NapiCallbackInfo& info)
264 {
265     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
266         TAG_LOGI(AAFwkTag::UI_EXT, "TerminateSelf in embedded screen mode");
267         CHECK_POINTER_RETURN(env, jsUIExtensionContext_);
268         return jsUIExtensionContext_->OnTerminateSelf(env, info);
269     }
270     CHECK_POINTER_RETURN(env, jsAbilityContext_);
271     return jsAbilityContext_->OnTerminateSelf(env, info);
272 }
273 
OnTerminateSelfWithResult(napi_env env,NapiCallbackInfo & info)274 napi_value JsEmbeddableUIAbilityContext::OnTerminateSelfWithResult(napi_env env, NapiCallbackInfo& info)
275 {
276     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
277         TAG_LOGI(AAFwkTag::UI_EXT, "TerminateSelfWithResult ability in embedded screen mode");
278         CHECK_POINTER_RETURN(env, jsUIExtensionContext_);
279         return jsUIExtensionContext_->OnTerminateSelfWithResult(env, info);
280     }
281     CHECK_POINTER_RETURN(env, jsAbilityContext_);
282     return jsAbilityContext_->OnTerminateSelfWithResult(env, info);
283 }
284 
OnBackToCallerAbilityWithResult(napi_env env,NapiCallbackInfo & info)285 napi_value JsEmbeddableUIAbilityContext::OnBackToCallerAbilityWithResult(napi_env env, NapiCallbackInfo& info)
286 {
287     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
288         TAG_LOGE(AAFwkTag::UI_EXT, "BackToCallerAbilityWithResult in embedded screen mode");
289         ThrowError(env, static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INNER), ERR_MSG_NOT_SUPPORT);
290         return CreateJsUndefined(env);
291     }
292     CHECK_POINTER_RETURN(env, jsAbilityContext_);
293     return jsAbilityContext_->OnBackToCallerAbilityWithResult(env, info);
294 }
295 
OnStartAbilityAsCaller(napi_env env,NapiCallbackInfo & info)296 napi_value JsEmbeddableUIAbilityContext::OnStartAbilityAsCaller(napi_env env, NapiCallbackInfo& info)
297 {
298     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
299         TAG_LOGE(AAFwkTag::UI_EXT, "Start ability as caller in embedded screen mode");
300         ThrowError(env, static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INNER), ERR_MSG_NOT_SUPPORT);
301         return CreateJsUndefined(env);
302     }
303     CHECK_POINTER_RETURN(env, jsAbilityContext_);
304     return jsAbilityContext_->OnStartAbilityAsCaller(env, info);
305 }
306 
OnStartAbilityWithAccount(napi_env env,NapiCallbackInfo & info)307 napi_value JsEmbeddableUIAbilityContext::OnStartAbilityWithAccount(napi_env env, NapiCallbackInfo& info)
308 {
309     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
310         TAG_LOGE(AAFwkTag::UI_EXT, "Start ability with account in embedded screen mode");
311         ThrowError(env, static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INNER), ERR_MSG_NOT_SUPPORT);
312         return CreateJsUndefined(env);
313     }
314     CHECK_POINTER_RETURN(env, jsAbilityContext_);
315     return jsAbilityContext_->OnStartAbilityWithAccount(env, info);
316 }
317 
OnStartAbilityByCall(napi_env env,NapiCallbackInfo & info)318 napi_value JsEmbeddableUIAbilityContext::OnStartAbilityByCall(napi_env env, NapiCallbackInfo& info)
319 {
320     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
321         TAG_LOGE(AAFwkTag::UI_EXT, "Start ability by caller in embedded screen mode");
322         ThrowError(env, static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INNER), ERR_MSG_NOT_SUPPORT);
323         return CreateJsUndefined(env);
324     }
325     CHECK_POINTER_RETURN(env, jsAbilityContext_);
326     return jsAbilityContext_->OnStartAbilityByCall(env, info);
327 }
328 
OnStartAbilityForResultWithAccount(napi_env env,NapiCallbackInfo & info)329 napi_value JsEmbeddableUIAbilityContext::OnStartAbilityForResultWithAccount(napi_env env, NapiCallbackInfo& info)
330 {
331     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
332         TAG_LOGE(AAFwkTag::UI_EXT, "Start ability for result in embedded screen mode");
333         ThrowError(env, static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INNER), ERR_MSG_NOT_SUPPORT);
334         return CreateJsUndefined(env);
335     }
336     CHECK_POINTER_RETURN(env, jsAbilityContext_);
337     return jsAbilityContext_->OnStartAbilityForResultWithAccount(env, info);
338 }
339 
OnStartExtensionAbility(napi_env env,NapiCallbackInfo & info)340 napi_value JsEmbeddableUIAbilityContext::OnStartExtensionAbility(napi_env env, NapiCallbackInfo& info)
341 {
342     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
343         TAG_LOGE(AAFwkTag::UI_EXT, "Start extension in embedded screen mode");
344         ThrowError(env, static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INNER), ERR_MSG_NOT_SUPPORT);
345         return CreateJsUndefined(env);
346     }
347     CHECK_POINTER_RETURN(env, jsAbilityContext_);
348     return jsAbilityContext_->OnStartExtensionAbility(env, info);
349 }
350 
OnStartExtensionAbilityWithAccount(napi_env env,NapiCallbackInfo & info)351 napi_value JsEmbeddableUIAbilityContext::OnStartExtensionAbilityWithAccount(napi_env env, NapiCallbackInfo& info)
352 {
353     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
354         TAG_LOGE(AAFwkTag::UI_EXT, "Start extensionin with account in embedded screen mode");
355         ThrowError(env, static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INNER), ERR_MSG_NOT_SUPPORT);
356         return CreateJsUndefined(env);
357     }
358     CHECK_POINTER_RETURN(env, jsAbilityContext_);
359     return jsAbilityContext_->OnStartExtensionAbilityWithAccount(env, info);
360 }
361 
OnStopExtensionAbility(napi_env env,NapiCallbackInfo & info)362 napi_value JsEmbeddableUIAbilityContext::OnStopExtensionAbility(napi_env env, NapiCallbackInfo& info)
363 {
364     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
365         TAG_LOGE(AAFwkTag::UI_EXT, "Stop extensionin in embedded screen mode");
366         ThrowError(env, static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INNER), ERR_MSG_NOT_SUPPORT);
367         return CreateJsUndefined(env);
368     }
369     CHECK_POINTER_RETURN(env, jsAbilityContext_);
370     return jsAbilityContext_->OnStopExtensionAbility(env, info);
371 }
372 
OnStopExtensionAbilityWithAccount(napi_env env,NapiCallbackInfo & info)373 napi_value JsEmbeddableUIAbilityContext::OnStopExtensionAbilityWithAccount(napi_env env, NapiCallbackInfo& info)
374 {
375     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
376         TAG_LOGE(AAFwkTag::UI_EXT, "Stop extensionin with account in embedded screen mode");
377         ThrowError(env, static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INNER), ERR_MSG_NOT_SUPPORT);
378         return CreateJsUndefined(env);
379     }
380     CHECK_POINTER_RETURN(env, jsAbilityContext_);
381     return jsAbilityContext_->OnStopExtensionAbilityWithAccount(env, info);
382 }
383 
OnConnectAbilityWithAccount(napi_env env,NapiCallbackInfo & info)384 napi_value JsEmbeddableUIAbilityContext::OnConnectAbilityWithAccount(napi_env env, NapiCallbackInfo& info)
385 {
386     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
387         TAG_LOGE(AAFwkTag::UI_EXT, "Connect ability with account in embedded screen mode");
388         ThrowError(env, static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INNER), ERR_MSG_NOT_SUPPORT);
389         return CreateJsUndefined(env);
390     }
391     CHECK_POINTER_RETURN(env, jsAbilityContext_);
392     return jsAbilityContext_->OnConnectAbilityWithAccount(env, info);
393 }
394 
OnRestoreWindowStage(napi_env env,NapiCallbackInfo & info)395 napi_value JsEmbeddableUIAbilityContext::OnRestoreWindowStage(napi_env env, NapiCallbackInfo& info)
396 {
397     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
398         TAG_LOGE(AAFwkTag::UI_EXT, "Restore window stage with account in embedded screen mode");
399         ThrowError(env, static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INNER), ERR_MSG_NOT_SUPPORT);
400         return CreateJsUndefined(env);
401     }
402     CHECK_POINTER_RETURN(env, jsAbilityContext_);
403     return jsAbilityContext_->OnRestoreWindowStage(env, info);
404 }
405 
OnIsTerminating(napi_env env,NapiCallbackInfo & info)406 napi_value JsEmbeddableUIAbilityContext::OnIsTerminating(napi_env env, NapiCallbackInfo& info)
407 {
408     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
409         TAG_LOGE(AAFwkTag::UI_EXT, "Get terminating state in embedded screen mode");
410         ThrowError(env, static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INNER), ERR_MSG_NOT_SUPPORT);
411         return CreateJsUndefined(env);
412     }
413     CHECK_POINTER_RETURN(env, jsAbilityContext_);
414     return jsAbilityContext_->OnIsTerminating(env, info);
415 }
416 
OnStartRecentAbility(napi_env env,NapiCallbackInfo & info)417 napi_value JsEmbeddableUIAbilityContext::OnStartRecentAbility(napi_env env, NapiCallbackInfo& info)
418 {
419     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
420         TAG_LOGE(AAFwkTag::UI_EXT, "Start recent ability in embedded screen mode");
421         ThrowError(env, static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INNER), ERR_MSG_NOT_SUPPORT);
422         return CreateJsUndefined(env);
423     }
424     CHECK_POINTER_RETURN(env, jsAbilityContext_);
425     return jsAbilityContext_->OnStartRecentAbility(env, info);
426 }
427 
OnRequestDialogService(napi_env env,NapiCallbackInfo & info)428 napi_value JsEmbeddableUIAbilityContext::OnRequestDialogService(napi_env env, NapiCallbackInfo& info)
429 {
430     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
431         TAG_LOGE(AAFwkTag::UI_EXT, "Request dialog service in embedded screen mode");
432         ThrowError(env, static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INNER), ERR_MSG_NOT_SUPPORT);
433         return CreateJsUndefined(env);
434     }
435     CHECK_POINTER_RETURN(env, jsAbilityContext_);
436     return jsAbilityContext_->OnRequestDialogService(env, info);
437 }
438 
OnReportDrawnCompleted(napi_env env,NapiCallbackInfo & info)439 napi_value JsEmbeddableUIAbilityContext::OnReportDrawnCompleted(napi_env env, NapiCallbackInfo& info)
440 {
441     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
442         TAG_LOGI(AAFwkTag::UI_EXT, "Report Drawn Completed in half screen mode");
443         CHECK_POINTER_RETURN(env, jsUIExtensionContext_);
444         return jsUIExtensionContext_->OnReportDrawnCompleted(env, info);
445     }
446     CHECK_POINTER_RETURN(env, jsAbilityContext_);
447     return jsAbilityContext_->OnReportDrawnCompleted(env, info);
448 }
449 
OnSetMissionContinueState(napi_env env,NapiCallbackInfo & info)450 napi_value JsEmbeddableUIAbilityContext::OnSetMissionContinueState(napi_env env, NapiCallbackInfo& info)
451 {
452     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
453         TAG_LOGE(AAFwkTag::UI_EXT, "Set mission continue state in embedded screen mode");
454         ThrowError(env, static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INNER), ERR_MSG_NOT_SUPPORT);
455         return CreateJsUndefined(env);
456     }
457     CHECK_POINTER_RETURN(env, jsAbilityContext_);
458     return jsAbilityContext_->OnSetMissionContinueState(env, info);
459 }
460 
OnStartAbilityByType(napi_env env,NapiCallbackInfo & info)461 napi_value JsEmbeddableUIAbilityContext::OnStartAbilityByType(napi_env env, NapiCallbackInfo& info)
462 {
463     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
464         TAG_LOGE(AAFwkTag::UI_EXT, "Start ability by type in embedded screen mode");
465         ThrowError(env, static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INNER), ERR_MSG_NOT_SUPPORT);
466         return CreateJsUndefined(env);
467     }
468     CHECK_POINTER_RETURN(env, jsAbilityContext_);
469     return jsAbilityContext_->OnStartAbilityByType(env, info);
470 }
471 
OnMoveAbilityToBackground(napi_env env,NapiCallbackInfo & info)472 napi_value JsEmbeddableUIAbilityContext::OnMoveAbilityToBackground(napi_env env, NapiCallbackInfo& info)
473 {
474     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
475         TAG_LOGE(AAFwkTag::UI_EXT, "OnMoveAbilityToBackground in half screen mode");
476         ThrowError(env, static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INNER), ERR_MSG_NOT_SUPPORT);
477         return CreateJsUndefined(env);
478     }
479     CHECK_POINTER_RETURN(env, jsAbilityContext_);
480     return jsAbilityContext_->OnMoveAbilityToBackground(env, info);
481 }
482 
OnRequestModalUIExtension(napi_env env,NapiCallbackInfo & info)483 napi_value JsEmbeddableUIAbilityContext::OnRequestModalUIExtension(napi_env env, NapiCallbackInfo& info)
484 {
485     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
486         TAG_LOGE(AAFwkTag::UI_EXT, "OnRequestModalUIExtension in half screen mode.");
487         ThrowError(env, static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INNER), ERR_MSG_NOT_SUPPORT);
488         return CreateJsUndefined(env);
489     }
490     CHECK_POINTER_RETURN(env, jsAbilityContext_);
491     return jsAbilityContext_->OnRequestModalUIExtension(env, info);
492 }
493 
OnOpenAtomicService(napi_env env,NapiCallbackInfo & info)494 napi_value JsEmbeddableUIAbilityContext::OnOpenAtomicService(napi_env env, NapiCallbackInfo& info)
495 {
496     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
497         TAG_LOGI(AAFwkTag::UI_EXT, "OpenAtomicService in embedded screen mode.");
498         CHECK_POINTER_RETURN(env, jsUIExtensionContext_);
499         return jsUIExtensionContext_->OnOpenAtomicService(env, info);
500     }
501     CHECK_POINTER_RETURN(env, jsAbilityContext_);
502     return jsAbilityContext_->OnOpenAtomicService(env, info);
503 }
504 
OnShowAbility(napi_env env,NapiCallbackInfo & info)505 napi_value JsEmbeddableUIAbilityContext::OnShowAbility(napi_env env, NapiCallbackInfo& info)
506 {
507     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
508         TAG_LOGE(AAFwkTag::UI_EXT, "OnShowAbility in half screen mode.");
509         ThrowError(env, static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INNER), ERR_MSG_NOT_SUPPORT);
510         return CreateJsUndefined(env);
511     }
512     CHECK_POINTER_RETURN(env, jsAbilityContext_);
513     return jsAbilityContext_->OnShowAbility(env, info);
514 }
515 
OnHideAbility(napi_env env,NapiCallbackInfo & info)516 napi_value JsEmbeddableUIAbilityContext::OnHideAbility(napi_env env, NapiCallbackInfo& info)
517 {
518     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
519         TAG_LOGE(AAFwkTag::UI_EXT, "OnHideAbility in half screen mode.");
520         ThrowError(env, static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INNER), ERR_MSG_NOT_SUPPORT);
521         return CreateJsUndefined(env);
522     }
523     CHECK_POINTER_RETURN(env, jsAbilityContext_);
524     return jsAbilityContext_->OnHideAbility(env, info);
525 }
526 
527 #ifdef SUPPORT_GRAPHICS
SetMissionLabel(napi_env env,napi_callback_info info)528 napi_value JsEmbeddableUIAbilityContext::SetMissionLabel(napi_env env, napi_callback_info info)
529 {
530     TAG_LOGI(AAFwkTag::UI_EXT, "called");
531     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnSetMissionLabel);
532 }
533 
SetMissionIcon(napi_env env,napi_callback_info info)534 napi_value JsEmbeddableUIAbilityContext::SetMissionIcon(napi_env env, napi_callback_info info)
535 {
536     TAG_LOGI(AAFwkTag::UI_EXT, "called");
537     GET_NAPI_INFO_AND_CALL(env, info, JsEmbeddableUIAbilityContext, OnSetMissionIcon);
538 }
539 
OnSetMissionLabel(napi_env env,NapiCallbackInfo & info)540 napi_value JsEmbeddableUIAbilityContext::OnSetMissionLabel(napi_env env, NapiCallbackInfo& info)
541 {
542     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
543         TAG_LOGE(AAFwkTag::UI_EXT, "Set mission label in embedded screen mode");
544         ThrowError(env, static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INNER), ERR_MSG_NOT_SUPPORT);
545         return CreateJsUndefined(env);
546     }
547     CHECK_POINTER_RETURN(env, jsAbilityContext_);
548     return jsAbilityContext_->OnSetMissionLabel(env, info);
549 }
550 
OnSetMissionIcon(napi_env env,NapiCallbackInfo & info)551 napi_value JsEmbeddableUIAbilityContext::OnSetMissionIcon(napi_env env, NapiCallbackInfo& info)
552 {
553     if (screenMode_ == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
554         TAG_LOGE(AAFwkTag::UI_EXT, "Set mission icon in embedded screen mode");
555         ThrowError(env, static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INNER), ERR_MSG_NOT_SUPPORT);
556         return CreateJsUndefined(env);
557     }
558     CHECK_POINTER_RETURN(env, jsAbilityContext_);
559     return jsAbilityContext_->OnSetMissionIcon(env, info);
560 }
561 #endif
562 
WrapJsUIAbilityContext(napi_env env,std::shared_ptr<AbilityContext> uiAbiContext,napi_value & objValue,int32_t screenMode)563 void JsEmbeddableUIAbilityContext::WrapJsUIAbilityContext(napi_env env,
564     std::shared_ptr<AbilityContext> uiAbiContext, napi_value &objValue, int32_t screenMode)
565 {
566     if (uiAbiContext == nullptr) {
567         TAG_LOGE(AAFwkTag::UI_EXT, "UI ability context is nullptr");
568         return;
569     }
570     objValue = CreateJsBaseContext(env, uiAbiContext);
571     std::unique_ptr<JsEmbeddableUIAbilityContext> jsContext = std::make_unique<JsEmbeddableUIAbilityContext>(
572         uiAbiContext, nullptr, screenMode);
573     napi_wrap(env, objValue, jsContext.release(), Finalizer, nullptr, nullptr);
574 
575     auto abilityInfo = uiAbiContext->GetAbilityInfo();
576     if (abilityInfo != nullptr) {
577         napi_set_named_property(env, objValue, "abilityInfo", CreateJsAbilityInfo(env, *abilityInfo));
578     }
579 
580     auto configuration = uiAbiContext->GetConfiguration();
581     if (configuration != nullptr) {
582         napi_set_named_property(env, objValue, "config", CreateJsConfiguration(env, *configuration));
583     }
584 }
585 
WrapJsUIExtensionContext(napi_env env,std::shared_ptr<UIExtensionContext> uiExtContext,napi_value & objValue,int32_t screenMode)586 void JsEmbeddableUIAbilityContext::WrapJsUIExtensionContext(napi_env env,
587     std::shared_ptr<UIExtensionContext> uiExtContext, napi_value &objValue, int32_t screenMode)
588 {
589     if (uiExtContext == nullptr) {
590         TAG_LOGE(AAFwkTag::UI_EXT, "UI extension context is nullptr");
591         return;
592     }
593     objValue = CreateJsBaseContext(env, uiExtContext);
594     std::unique_ptr<JsEmbeddableUIAbilityContext> jsContext = std::make_unique<JsEmbeddableUIAbilityContext>(
595         nullptr, uiExtContext, screenMode);
596     napi_wrap(env, objValue, jsContext.release(), Finalizer, nullptr, nullptr);
597 
598     auto abilityInfo = uiExtContext->GetAbilityInfo();
599     if (abilityInfo != nullptr) {
600         napi_set_named_property(env, objValue, "abilityInfo", CreateJsAbilityInfo(env, *abilityInfo));
601     }
602 
603     auto configuration = uiExtContext->GetConfiguration();
604     if (configuration != nullptr) {
605         napi_set_named_property(env, objValue, "config", CreateJsConfiguration(env, *configuration));
606     }
607 }
608 
CreateJsEmbeddableUIAbilityContext(napi_env env,std::shared_ptr<AbilityContext> uiAbiContext,std::shared_ptr<UIExtensionContext> uiExtContext,int32_t screenMode)609 napi_value JsEmbeddableUIAbilityContext::CreateJsEmbeddableUIAbilityContext(napi_env env,
610     std::shared_ptr<AbilityContext> uiAbiContext, std::shared_ptr<UIExtensionContext> uiExtContext, int32_t screenMode)
611 {
612     TAG_LOGD(AAFwkTag::UI_EXT, "begin");
613     napi_value objValue = nullptr;
614     if (screenMode == AAFwk::JUMP_SCREEN_MODE) {
615         WrapJsUIAbilityContext(env, uiAbiContext, objValue, screenMode);
616     } else if (screenMode == AAFwk::EMBEDDED_FULL_SCREEN_MODE) {
617         WrapJsUIExtensionContext(env, uiExtContext, objValue, screenMode);
618     }
619 
620     const char* moduleName = "JsEmbeddableUIAbilityContext";
621     BindNativeFunction(env, objValue, "startAbility", moduleName, StartAbility);
622     BindNativeFunction(env, objValue, "openLink", moduleName, OpenLink);
623     BindNativeFunction(env, objValue, "startAbilityForResult", moduleName, StartAbilityForResult);
624     BindNativeFunction(env, objValue, "connectServiceExtensionAbility", moduleName, ConnectAbility);
625     BindNativeFunction(env, objValue, "disconnectServiceExtensionAbility", moduleName, DisconnectAbility);
626     BindNativeFunction(env, objValue, "terminateSelf", moduleName, TerminateSelf);
627     BindNativeFunction(env, objValue, "terminateSelfWithResult", moduleName, TerminateSelfWithResult);
628     BindNativeFunction(env, objValue, "backToCallerAbilityWithResult", moduleName, BackToCallerAbilityWithResult);
629     BindNativeFunction(env, objValue, "startAbilityAsCaller", moduleName, StartAbilityAsCaller);
630     BindNativeFunction(env, objValue, "startAbilityWithAccount", moduleName, StartAbilityWithAccount);
631     BindNativeFunction(env, objValue, "startAbilityByCall", moduleName, StartAbilityByCall);
632     BindNativeFunction(env, objValue, "startAbilityForResultWithAccount", moduleName,
633         StartAbilityForResultWithAccount);
634     BindNativeFunction(env, objValue, "startServiceExtensionAbility", moduleName, StartServiceExtensionAbility);
635     BindNativeFunction(env, objValue, "startServiceExtensionAbilityWithAccount", moduleName,
636         StartServiceExtensionAbilityWithAccount);
637     BindNativeFunction(env, objValue, "stopServiceExtensionAbility", moduleName, StopServiceExtensionAbility);
638     BindNativeFunction(env, objValue, "stopServiceExtensionAbilityWithAccount", moduleName,
639         StopServiceExtensionAbilityWithAccount);
640     BindNativeFunction(env, objValue, "connectServiceExtensionAbilityWithAccount", moduleName,
641         ConnectAbilityWithAccount);
642     BindNativeFunction(env, objValue, "restoreWindowStage", moduleName, RestoreWindowStage);
643     BindNativeFunction(env, objValue, "isTerminating", moduleName, IsTerminating);
644     BindNativeFunction(env, objValue, "startRecentAbility", moduleName, StartRecentAbility);
645     BindNativeFunction(env, objValue, "requestDialogService", moduleName, RequestDialogService);
646     BindNativeFunction(env, objValue, "reportDrawnCompleted", moduleName, ReportDrawnCompleted);
647     BindNativeFunction(env, objValue, "setMissionContinueState", moduleName, SetMissionContinueState);
648     BindNativeFunction(env, objValue, "startAbilityByType", moduleName, StartAbilityByType);
649     BindNativeFunction(env, objValue, "moveAbilityToBackground", moduleName, MoveAbilityToBackground);
650     BindNativeFunction(env, objValue, "requestModalUIExtension", moduleName, RequestModalUIExtension);
651     BindNativeFunction(env, objValue, "openAtomicService", moduleName, OpenAtomicService);
652     BindNativeFunction(env, objValue, "showAbility", moduleName, ShowAbility);
653     BindNativeFunction(env, objValue, "hideAbility", moduleName, HideAbility);
654 
655 #ifdef SUPPORT_GRAPHICS
656     BindNativeFunction(env, objValue, "setMissionLabel", moduleName, SetMissionLabel);
657     BindNativeFunction(env, objValue, "setMissionIcon", moduleName, SetMissionIcon);
658 #endif
659     return objValue;
660 }
661 }  // namespace AbilityRuntime
662 }  // namespace OHOS
663