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_ability_connection_manager.h"
17
18 #include <algorithm>
19 #include <memory>
20 #include <string>
21 #include <vector>
22
23 #include "ability_connection_manager.h"
24 #include "dtbcollabmgr_log.h"
25 #include "ipc_skeleton.h"
26 #include "js_runtime_utils.h"
27 #include "napi_common_util.h"
28 #include "napi_base_context.h"
29 #include "native_avcapability.h"
30 #include "native_avcodec_base.h"
31 #include "native_avformat.h"
32 #include "native_avcodec_videoencoder.h"
33 #include "native_avcodec_videodecoder.h"
34 #include "string_wrapper.h"
35 #include "tokenid_kit.h"
36 namespace OHOS {
37 namespace DistributedCollab {
38 using namespace OHOS::AbilityRuntime;
39 using namespace OHOS::AppExecFwk;
40 using namespace OHOS::MediaAVCodec;
41 namespace {
42 #define GET_PARAMS(env, info, num) \
43 size_t argc = num; \
44 napi_value argv[num] = {nullptr}; \
45 napi_value thisVar = nullptr; \
46 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr))
47
48 const std::string TAG = "JsAbilityConnectionManager";
49 constexpr int32_t ARG_INDEX_ZERO = 0;
50 constexpr int32_t ARG_INDEX_ONE = 1;
51 constexpr int32_t ARG_INDEX_TWO = 2;
52 constexpr int32_t ARG_INDEX_THREE = 3;
53 constexpr int32_t ARG_COUNT_ONE = 1;
54 constexpr int32_t ARG_COUNT_TWO = 2;
55 constexpr int32_t ARG_COUNT_THREE = 3;
56 constexpr int32_t ARG_COUNT_FOUR = 4;
57 constexpr int32_t NAPI_BUF_LENGTH = 1024;
58 constexpr int32_t SOURCE = 0;
59 constexpr int32_t SINK = 1;
60 constexpr int32_t UNKNOWN = -1;
61 constexpr int32_t NV12 = 0;
62 constexpr int32_t NV21 = 1;
63 constexpr int32_t IMAGE_COMPRESSION_QUALITY = 30;
64
65 const std::string EVENT_CONNECT = "connect";
66 const std::string EVENT_DISCONNECT = "disconnect";
67 const std::string EVENT_RECEIVE_MESSAGE = "receiveMessage";
68 const std::string EVENT_RECEIVE_DATA = "receiveData";
69 const std::string EVENT_RECEIVE_IMAGE = "receiveImage";
70 const std::string EVENT_COLLABORATE = "collaborateEvent";
71 const std::vector<std::string> REGISTER_EVENT_TYPES = {
72 EVENT_CONNECT, EVENT_DISCONNECT, EVENT_RECEIVE_MESSAGE, EVENT_RECEIVE_DATA,
73 EVENT_RECEIVE_IMAGE, EVENT_COLLABORATE
74 };
75 const std::vector<std::string> SYSTEM_APP_EVENT_TYPES = {
76 EVENT_RECEIVE_IMAGE, EVENT_COLLABORATE
77 };
78
79 const std::string ERR_MESSAGE_NO_PERMISSION =
80 "Permission verification failed. The application does not have the permission required to call the API.";
81 const std::string ERR_MESSAGE_INVALID_PARAMS = "Parameter error.";
82 const std::string ERR_MESSAGE_FAILED = "Failed to execute the function.";
83 const std::string ERR_MESSAGE_ONE_STREAM = "Only one stream can be created for the current session.";
84 const std::string ERR_MESSAGE_RECEIVE_NOT_START = "The stream at the receive end is not started.";
85 const std::string KEY_START_OPTION = "ohos.collabrate.key.start.option";
86 const std::string VALUE_START_OPTION_FOREGROUND = "ohos.collabrate.value.forefround";
87 const std::string VALUE_START_OPTION_BACKGROUND = "ohos.collabrate.value.background";
88 const std::string COLLABORATE_KEYS_PEER_INFO = "ohos.collaboration.key.peerInfo";
89 const std::string COLLABORATE_KEYS_CONNECT_OPTIONS = "ohos.collaboration.key.connectOptions";
90 const std::string COLLABORATE_KEYS_COLLABORATE_TYPE = "ohos.collaboration.key.abilityCollaborateType";
91 const std::string ABILITY_COLLABORATION_TYPE_DEFAULT = "ohos.collaboration.value.abilityCollab";
92 const std::string ABILITY_COLLABORATION_TYPE_CONNECT_PROXY = "ohos.collaboration.value.connectProxy";
93 }
94
JsToInt32(const napi_env & env,const napi_value & value,const std::string & valueName,int32_t & strValue)95 bool JsAbilityConnectionManager::JsToInt32(const napi_env &env, const napi_value &value,
96 const std::string &valueName, int32_t &strValue)
97 {
98 HILOGD("called.");
99 napi_valuetype valueType = napi_undefined;
100 if (napi_typeof(env, value, &valueType) != napi_ok) {
101 HILOGE("Failed to get argument type");
102 return false;
103 }
104
105 if (valueType != napi_number) {
106 HILOGE("Argument must be a number");
107 return false;
108 }
109
110 if (napi_get_value_int32(env, value, &strValue) != napi_ok) {
111 HILOGE("Failed to get number value");
112 return false;
113 }
114 return true;
115 }
116
JsToString(const napi_env & env,const napi_value & value,const std::string & valueName,std::string & strValue)117 bool JsAbilityConnectionManager::JsToString(const napi_env &env, const napi_value &value, const std::string &valueName,
118 std::string &strValue)
119 {
120 napi_valuetype valueType = napi_undefined;
121 if (napi_typeof(env, value, &valueType) != napi_ok) {
122 HILOGE("Failed to get argument type");
123 return false;
124 }
125
126 if (valueType != napi_string) {
127 HILOGE("Argument must be a string");
128 return false;
129 }
130
131 size_t valueLen = 0;
132 if (napi_get_value_string_utf8(env, value, nullptr, 0, &valueLen) != napi_ok) {
133 HILOGE("Failed to get string length");
134 return false;
135 }
136
137 if (valueLen >= NAPI_BUF_LENGTH) {
138 HILOGE("string length mast < %{public}d", NAPI_BUF_LENGTH);
139 return false;
140 }
141
142 std::vector<char> buf(NAPI_BUF_LENGTH, 0);
143 if (napi_get_value_string_utf8(env, value, buf.data(), valueLen + 1, &valueLen) != napi_ok) {
144 HILOGE("Failed to read string value");
145 return false;
146 }
147 strValue.assign(buf.begin(), buf.begin() + valueLen);
148 return true;
149 }
150
JsObjectToString(const napi_env & env,const napi_value & object,const std::string & fieldStr,std::string & fieldRef)151 bool JsAbilityConnectionManager::JsObjectToString(const napi_env &env, const napi_value &object,
152 const std::string &fieldStr, std::string& fieldRef)
153 {
154 bool hasProperty = false;
155 if (napi_has_named_property(env, object, fieldStr.c_str(), &hasProperty) != napi_ok) {
156 HILOGE("check object has named property failed.");
157 return false;
158 }
159
160 if (!hasProperty) {
161 HILOGE("napi js to str no property: %{public}s", fieldStr.c_str());
162 return false;
163 }
164
165 napi_value field = nullptr;
166 if (napi_get_named_property(env, object, fieldStr.c_str(), &field) != napi_ok) {
167 HILOGE("get property failed, property is %{public}s.", fieldStr.c_str());
168 return false;
169 }
170 return JsToString(env, field, fieldStr, fieldRef);
171 }
172
JsObjectToBool(const napi_env & env,const napi_value & object,const std::string & fieldStr,bool & fieldRef)173 bool JsAbilityConnectionManager::JsObjectToBool(const napi_env &env, const napi_value &object,
174 const std::string &fieldStr, bool &fieldRef)
175 {
176 bool hasProperty = false;
177 if (napi_has_named_property(env, object, fieldStr.c_str(), &hasProperty) != napi_ok) {
178 HILOGE("check object has named property failed.");
179 return false;
180 }
181
182 if (!hasProperty) {
183 HILOGE("napi js to str no property: %{public}s", fieldStr.c_str());
184 return false;
185 }
186
187 napi_value field = nullptr;
188 if (napi_get_named_property(env, object, fieldStr.c_str(), &field) != napi_ok) {
189 HILOGE("get property failed, property is %{public}s.", fieldStr.c_str());
190 return false;
191 }
192
193 napi_valuetype valueType = napi_undefined;
194 if (napi_typeof(env, field, &valueType) != napi_ok) {
195 HILOGE("Failed to get argument type");
196 return false;
197 }
198
199 if (valueType != napi_boolean) {
200 return false;
201 }
202
203 if (napi_get_value_bool(env, field, &fieldRef) != napi_ok) {
204 HILOGE("Failed to read bool value");
205 return false;
206 }
207 return true;
208 }
209
JsObjectToInt(const napi_env & env,const napi_value & object,const std::string & fieldStr,int32_t & fieldRef)210 bool JsAbilityConnectionManager::JsObjectToInt(const napi_env &env, const napi_value &object,
211 const std::string &fieldStr, int32_t &fieldRef)
212 {
213 bool hasProperty = false;
214 if (napi_has_named_property(env, object, fieldStr.c_str(), &hasProperty) != napi_ok) {
215 HILOGE("check object has named property failed.");
216 return false;
217 }
218
219 if (!hasProperty) {
220 HILOGE("napi js to str no property: %{public}s", fieldStr.c_str());
221 return false;
222 }
223
224 napi_value field = nullptr;
225 if (napi_get_named_property(env, object, fieldStr.c_str(), &field) != napi_ok) {
226 HILOGE("get property failed, property is %{public}s.", fieldStr.c_str());
227 return false;
228 }
229 return JsToInt32(env, field, fieldStr, fieldRef);
230 }
231
IsSystemApp()232 bool JsAbilityConnectionManager::IsSystemApp()
233 {
234 static bool isSystemApp = []() {
235 uint64_t tokenId = OHOS::IPCSkeleton::GetSelfTokenID();
236 return OHOS::Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(tokenId);
237 }();
238 return isSystemApp;
239 }
240
GenerateBusinessError(napi_env env,int32_t err,const std::string & msg)241 napi_value GenerateBusinessError(napi_env env,
242 int32_t err, const std::string &msg)
243 {
244 napi_value businessError = nullptr;
245 NAPI_CALL(env, napi_create_object(env, &businessError));
246 napi_value errorCode = nullptr;
247 NAPI_CALL(env, napi_create_int32(env, err, &errorCode));
248 napi_value errorMsg = nullptr;
249 NAPI_CALL(env, napi_create_string_utf8(env, msg.c_str(), NAPI_AUTO_LENGTH, &errorMsg));
250 NAPI_CALL(env, napi_set_named_property(env, businessError, "code", errorCode));
251 NAPI_CALL(env, napi_set_named_property(env, businessError, "message", errorMsg));
252
253 return businessError;
254 }
255
CreateErrorForCall(napi_env env,int32_t code,const std::string & errMsg,bool isAsync=true)256 napi_value CreateErrorForCall(napi_env env, int32_t code, const std::string &errMsg, bool isAsync = true)
257 {
258 HILOGI("CreateErrorForCall code:%{public}d, message:%{public}s", code, errMsg.c_str());
259 napi_value error = nullptr;
260 if (isAsync) {
261 napi_throw_error(env, std::to_string(code).c_str(), errMsg.c_str());
262 } else {
263 error = GenerateBusinessError(env, code, errMsg);
264 }
265 return error;
266 }
267
CreateBusinessError(napi_env env,int32_t errCode,bool isAsync=true)268 napi_value CreateBusinessError(napi_env env, int32_t errCode, bool isAsync = true)
269 {
270 napi_value error = nullptr;
271 switch (errCode) {
272 case ERR_IS_NOT_SYSTEM_APP:
273 error = CreateErrorForCall(env, static_cast<int32_t>(BussinessErrorCode::ERR_NOT_SYSTEM_APP),
274 ERR_MESSAGE_NO_PERMISSION, isAsync);
275 break;
276 case ERR_INVALID_PARAMETERS:
277 error = CreateErrorForCall(env, static_cast<int32_t>(BussinessErrorCode::ERR_INVALID_PARAMS),
278 ERR_MESSAGE_INVALID_PARAMS, isAsync);
279 break;
280 case ONLY_SUPPORT_ONE_STREAM:
281 error = CreateErrorForCall(env, static_cast<int32_t>(BussinessErrorCode::ERR_ONLY_SUPPORT_ONE_STREAM),
282 ERR_MESSAGE_ONE_STREAM, isAsync);
283 break;
284 case RECEIVE_STREAM_NOT_START:
285 error = CreateErrorForCall(env, static_cast<int32_t>(BussinessErrorCode::ERR_RECEIVE_STREAM_NOT_START),
286 ERR_MESSAGE_RECEIVE_NOT_START, isAsync);
287 break;
288 case ERR_EXECUTE_FUNCTION:
289 error = CreateErrorForCall(env, static_cast<int32_t>(BussinessErrorCode::ERR_INVALID_PARAMS),
290 ERR_MESSAGE_FAILED, isAsync);
291 break;
292 case COLLAB_PERMISSION_DENIED:
293 error = CreateErrorForCall(env, static_cast<int32_t>(BussinessErrorCode::ERR_INVALID_PERMISSION),
294 ERR_MESSAGE_NO_PERMISSION, isAsync);
295 break;
296 case INVALID_PARAMETERS_ERR:
297 error = CreateErrorForCall(env, static_cast<int32_t>(BussinessErrorCode::ERR_INVALID_PARAMS),
298 ERR_MESSAGE_INVALID_PARAMS, isAsync);
299 break;
300 default:
301 error = CreateErrorForCall(env, static_cast<int32_t>(BussinessErrorCode::ERR_INVALID_PARAMS),
302 ERR_MESSAGE_FAILED, isAsync);
303 break;
304 }
305 return error;
306 }
307
CreateAbilityConnectionSession(napi_env env,napi_callback_info info)308 napi_value JsAbilityConnectionManager::CreateAbilityConnectionSession(napi_env env, napi_callback_info info)
309 {
310 HILOGI("called.");
311 GET_PARAMS(env, info, ARG_COUNT_FOUR);
312 napi_value result = nullptr;
313 if (argc != ARG_COUNT_FOUR) {
314 HILOGE("CheckArgsCount failed.");
315 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
316 return result;
317 }
318
319 std::string serviceName = "";
320 if (!JsToServiceName(env, argv[ARG_INDEX_ZERO], serviceName)) {
321 HILOGE("Failed to unwrap service name/id");
322 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
323 return result;
324 }
325
326 std::shared_ptr<AbilityInfo> abilityInfo = nullptr;
327 if (!JsToAbilityInfo(env, argv[ARG_INDEX_ONE], abilityInfo)) {
328 HILOGE("Failed to unwrap abilityInfo.");
329 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
330 return result;
331 }
332
333 PeerInfo peerInfo;
334 if (!JsToPeerInfo(env, argv[ARG_INDEX_TWO], peerInfo)) {
335 HILOGE("Failed to unwrap PeerInfo.");
336 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
337 return result;
338 }
339 if (peerInfo.serverId.empty()) {
340 peerInfo.serverId = serviceName;
341 peerInfo.serviceName = serviceName;
342 }
343
344 ConnectOption connectOption;
345 int32_t ret = JSToConnectOption(env, argv[ARG_INDEX_THREE], connectOption);
346 if (ret != ERR_OK) {
347 HILOGE("Failed to unwrap ConnectOption.");
348 CreateBusinessError(env, ret);
349 return result;
350 }
351
352 return ExecuteCreateSession(serviceName, abilityInfo, peerInfo, connectOption, env);
353 }
354
ExecuteCreateSession(const std::string & serviceName,std::shared_ptr<AbilityInfo> & abilityInfo,PeerInfo & peerInfo,ConnectOption & connectOption,const napi_env & env)355 napi_value JsAbilityConnectionManager::ExecuteCreateSession(
356 const std::string& serviceName, std::shared_ptr<AbilityInfo>& abilityInfo,
357 PeerInfo& peerInfo, ConnectOption& connectOption, const napi_env& env)
358 {
359 napi_value result = nullptr;
360 int32_t sessionId = -1;
361 int32_t ret = AbilityConnectionManager::GetInstance().CreateSession(
362 serviceName, abilityInfo, peerInfo, connectOption, sessionId);
363 if (ret == COLLAB_PERMISSION_DENIED || ret == INVALID_PARAMETERS_ERR) {
364 HILOGE("create session failed due to param or permission valid");
365 CreateBusinessError(env, ret);
366 return result;
367 } else if (ret != ERR_OK) {
368 HILOGE("create session failed due to function err");
369 CreateBusinessError(env, ERR_EXECUTE_FUNCTION);
370 return result;
371 }
372 NAPI_CALL(env, napi_create_int32(env, sessionId, &result));
373 return result;
374 }
375
JsToServiceName(const napi_env & env,const napi_value & jsValue,std::string & serviceName)376 bool JsAbilityConnectionManager::JsToServiceName(const napi_env &env, const napi_value &jsValue,
377 std::string& serviceName)
378 {
379 HILOGI("parse serviceName");
380 // no serviceName
381 if (!JsToString(env, jsValue, "serviceName", serviceName)) {
382 HILOGW("Failed to unwrap serviceName.");
383 } else {
384 return true;
385 }
386 // neither exist
387 if (!JsToString(env, jsValue, "serverId", serviceName)) {
388 HILOGE("Failed to unwrap serverId and serviceName.");
389 return false;
390 }
391 return true;
392 }
393
JsToAbilityInfo(const napi_env & env,const napi_value & jsValue,std::shared_ptr<AbilityInfo> & abilityInfo)394 bool JsAbilityConnectionManager::JsToAbilityInfo(const napi_env &env, const napi_value &jsValue,
395 std::shared_ptr<AbilityInfo>& abilityInfo)
396 {
397 HILOGI("parse abilityInfo");
398 bool stageMode = false;
399 napi_status status = OHOS::AbilityRuntime::IsStageContext(env, jsValue, stageMode);
400 if (status != napi_ok || !stageMode) {
401 auto ability = OHOS::AbilityRuntime::GetCurrentAbility(env);
402 if (!ability) {
403 HILOGE("get current ability failed!");
404 return false;
405 }
406 auto abilityContext = ability->GetAbilityContext();
407 if (!abilityContext) {
408 HILOGE("get ability context failed!");
409 return false;
410 }
411 abilityInfo = abilityContext->GetAbilityInfo();
412 } else {
413 auto context = AbilityRuntime::GetStageModeContext(env, jsValue);
414 if (!context) {
415 HILOGE("get stage mode context failed!");
416 return false;
417 }
418 auto abilityContext = AbilityRuntime::Context::ConvertTo<AbilityRuntime::AbilityContext>(context);
419 if (!abilityContext) {
420 HILOGE("convertTo AbilityContext failed!");
421 return false;
422 }
423 abilityInfo = abilityContext->GetAbilityInfo();
424 }
425 return true;
426 }
427
JsToPeerInfo(const napi_env & env,const napi_value & jsValue,PeerInfo & peerInfo)428 bool JsAbilityConnectionManager::JsToPeerInfo(const napi_env &env, const napi_value &jsValue, PeerInfo &peerInfo)
429 {
430 HILOGI("parse PeerInfo");
431 napi_valuetype argvType = napi_undefined;
432 NAPI_CALL_BASE(env, napi_typeof(env, jsValue, &argvType), false);
433 if (argvType != napi_object) {
434 HILOGE("Parameter verification failed.");
435 return false;
436 }
437
438 if (!JsObjectToString(env, jsValue, "deviceId", peerInfo.deviceId)) {
439 HILOGE("Failed to unwrap deviceId.");
440 return false;
441 }
442
443 if (!JsObjectToString(env, jsValue, "bundleName", peerInfo.bundleName)) {
444 HILOGE("Failed to unwrap bundleName.");
445 return false;
446 }
447
448 if (!JsObjectToString(env, jsValue, "moduleName", peerInfo.moduleName)) {
449 HILOGE("Failed to unwrap moduleName.");
450 return false;
451 }
452
453 if (!JsObjectToString(env, jsValue, "abilityName", peerInfo.abilityName)) {
454 HILOGE("Failed to unwrap abilityName.");
455 return false;
456 }
457
458 if (!JsObjectToString(env, jsValue, "serviceName", peerInfo.serverId)) {
459 HILOGW("Failed to unwrap serviceName.");
460 }
461 if (!JsObjectToString(env, jsValue, "serverId", peerInfo.serverId)) {
462 HILOGW("Failed to unwrap serverId.");
463 }
464 peerInfo.serviceName = peerInfo.serverId;
465 return true;
466 }
467
JSToConnectOption(const napi_env & env,const napi_value & jsValue,ConnectOption & option)468 int32_t JsAbilityConnectionManager::JSToConnectOption(const napi_env &env, const napi_value &jsValue,
469 ConnectOption &option)
470 {
471 HILOGI("parse ConnectOption");
472 napi_valuetype argvType = napi_undefined;
473 NAPI_CALL_BASE(env, napi_typeof(env, jsValue, &argvType), false);
474 if (argvType != napi_object) {
475 HILOGE("Parameter verification failed.");
476 return ERR_INVALID_PARAMETERS;
477 }
478 if (!JsObjectToBool(env, jsValue, "needSendData", option.needSendData)) {
479 HILOGW("Failed to unwrap needSendData.");
480 }
481 if (!JsObjectToBool(env, jsValue, "needSendStream", option.needSendStream)) {
482 HILOGW("Failed to unwrap needSendStream.");
483 }
484
485 if (!JsObjectToBool(env, jsValue, "needReceiveStream", option.needReceiveStream)) {
486 HILOGW("Failed to unwrap needSendStream.");
487 }
488 // check start option/options
489 napi_value startOptionsVal;
490 if (napi_get_named_property(env, jsValue, "startOptions", &startOptionsVal) == napi_ok) {
491 UnwrapStartOptions(env, startOptionsVal, option);
492 }
493 napi_value optionsVal;
494 if (napi_get_named_property(env, jsValue, "options", &optionsVal) == napi_ok) {
495 UnwrapOptions(env, optionsVal, option);
496 }
497 // set default
498 if (option.options.IsEmpty()) {
499 option.options.SetParam(KEY_START_OPTION, AAFwk::String::Box(VALUE_START_OPTION_FOREGROUND));
500 }
501
502 napi_value parametersVal;
503 if (napi_get_named_property(env, jsValue, "parameters", ¶metersVal) == napi_ok) {
504 UnwrapParameters(env, parametersVal, option);
505 }
506
507 return CheckConnectOption(option);
508 }
509
UnwrapStartOptions(napi_env env,napi_value startOptionsVal,ConnectOption & connectOption)510 bool JsAbilityConnectionManager::UnwrapStartOptions(napi_env env, napi_value startOptionsVal,
511 ConnectOption &connectOption)
512 {
513 HILOGI("unwrap StartOptions");
514 if (startOptionsVal == nullptr) {
515 HILOGE("start options is nullptr");
516 return false;
517 }
518 napi_valuetype argvType = napi_undefined;
519 if (napi_typeof(env, startOptionsVal, &argvType) != napi_ok) {
520 return false;
521 }
522 if (argvType != napi_number) {
523 HILOGW("start options verification failed.");
524 return false;
525 }
526 int32_t startOption = 0;
527 napi_get_value_int32(env, startOptionsVal, &startOption);
528 if (startOption < static_cast<int32_t>(StartOptionParams::START_IN_FOREGROUND) ||
529 startOption > static_cast<int32_t>(StartOptionParams::START_IN_BACKGROUND)) {
530 HILOGE("invalid start option");
531 return false;
532 }
533 if (startOption == static_cast<int32_t>(StartOptionParams::START_IN_FOREGROUND)) {
534 connectOption.options.SetParam(KEY_START_OPTION, AAFwk::String::Box(VALUE_START_OPTION_FOREGROUND));
535 } else if (startOption == static_cast<int32_t>(StartOptionParams::START_IN_BACKGROUND)) {
536 connectOption.options.SetParam(KEY_START_OPTION, AAFwk::String::Box(VALUE_START_OPTION_BACKGROUND));
537 } else {
538 HILOGE("Invalid startOptions value.");
539 return false;
540 }
541 return true;
542 }
543
UnwrapOptions(napi_env env,napi_value options,ConnectOption & connectOption)544 bool JsAbilityConnectionManager::UnwrapOptions(napi_env env, napi_value options, ConnectOption &connectOption)
545 {
546 HILOGI("unwrap Options");
547 if (options == nullptr) {
548 HILOGI("options is nullptr");
549 return false;
550 }
551
552 napi_valuetype argvType = napi_undefined;
553 if (napi_typeof(env, options, &argvType) != napi_ok) {
554 return false;
555 }
556
557 if (argvType != napi_object) {
558 HILOGW("options verification failed.");
559 return false;
560 }
561
562 napi_value jsProNameList = nullptr;
563 NAPI_CALL_BASE(env, napi_get_property_names(env, options, &jsProNameList), false);
564
565 uint32_t jsProCount = 0;
566 NAPI_CALL_BASE(env, napi_get_array_length(env, jsProNameList, &jsProCount), false);
567
568 napi_value jsProName = nullptr;
569 napi_value jsProValue = nullptr;
570 for (uint32_t index = 0; index < jsProCount; index++) {
571 NAPI_CALL_BASE(env, napi_get_element(env, jsProNameList, index, &jsProName), false);
572
573 std::string strProName;
574 if (!JsToString(env, jsProName, "options key", strProName)) {
575 HILOGE("options get key failed");
576 return false;
577 }
578
579 NAPI_CALL_BASE(env, napi_get_named_property(env, options, strProName.c_str(), &jsProValue), false);
580 std::string natValue;
581 if (!JsToString(env, jsProValue, "options value", natValue)) {
582 HILOGE("options get value failed");
583 return false;
584 }
585 connectOption.options.SetParam(strProName, AAFwk::String::Box(natValue));
586 }
587 return true;
588 }
589
CheckConnectOption(const ConnectOption & connectOption)590 int32_t JsAbilityConnectionManager::CheckConnectOption(const ConnectOption &connectOption)
591 {
592 // check background
593 if (connectOption.options.GetStringParam(KEY_START_OPTION) == VALUE_START_OPTION_BACKGROUND &&
594 !IsSystemApp()) {
595 HILOGE("normal app background denied");
596 return ERR_IS_NOT_SYSTEM_APP;
597 }
598 if (connectOption.needSendStream && !IsSystemApp()) {
599 HILOGE("normal app stream denied");
600 return ERR_IS_NOT_SYSTEM_APP;
601 }
602 if (connectOption.needReceiveStream && !IsSystemApp()) {
603 HILOGE("normal app stream denied");
604 return ERR_IS_NOT_SYSTEM_APP;
605 }
606 return ERR_OK;
607 }
608
UnwrapParameters(napi_env env,napi_value parameters,ConnectOption & option)609 bool JsAbilityConnectionManager::UnwrapParameters(napi_env env, napi_value parameters, ConnectOption &option)
610 {
611 HILOGI("Unwrap Parameters");
612 if (parameters == nullptr) {
613 HILOGI("parameters is nullptr");
614 return false;
615 }
616
617 napi_valuetype argvType = napi_undefined;
618 if (napi_typeof(env, parameters, &argvType) != napi_ok) {
619 return false;
620 }
621
622 if (argvType != napi_object) {
623 HILOGE("parameters verification failed.");
624 return false;
625 }
626
627 napi_value jsProNameList = nullptr;
628 NAPI_CALL_BASE(env, napi_get_property_names(env, parameters, &jsProNameList), false);
629
630 uint32_t jsProCount = 0;
631 NAPI_CALL_BASE(env, napi_get_array_length(env, jsProNameList, &jsProCount), false);
632
633 napi_value jsProName = nullptr;
634 napi_value jsProValue = nullptr;
635 for (uint32_t index = 0; index < jsProCount; index++) {
636 NAPI_CALL_BASE(env, napi_get_element(env, jsProNameList, index, &jsProName), false);
637
638 std::string strProName;
639 if (!JsToString(env, jsProName, "parameters key", strProName)) {
640 HILOGE("parameters get key failed");
641 return false;
642 }
643
644 NAPI_CALL_BASE(env, napi_get_named_property(env, parameters, strProName.c_str(), &jsProValue), false);
645 std::string natValue;
646 if (!JsToString(env, jsProValue, "parameters value", natValue)) {
647 HILOGE("parameters get value failed");
648 return false;
649 }
650 option.parameters.SetParam(strProName, AAFwk::String::Box(natValue));
651 }
652 return true;
653 }
654
DestroyAbilityConnectionSession(napi_env env,napi_callback_info info)655 napi_value JsAbilityConnectionManager::DestroyAbilityConnectionSession(napi_env env, napi_callback_info info)
656 {
657 HILOGI("called.");
658 GET_PARAMS(env, info, ARG_COUNT_ONE);
659 if (argc != ARG_COUNT_ONE) {
660 HILOGE("CheckArgsCount failed.");
661 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
662 return nullptr;
663 }
664
665 int32_t sessionId = -1;
666 if (!JsToInt32(env, argv[ARG_INDEX_ZERO], "sessionId", sessionId)) {
667 HILOGE("Failed to unwrap sessionId.");
668 return nullptr;
669 }
670
671 int32_t ret = AbilityConnectionManager::GetInstance().DestroySession(sessionId);
672 if (ret != ERR_OK) {
673 HILOGE("destroy session failed!");
674 CreateBusinessError(env, ERR_EXECUTE_FUNCTION);
675 }
676 return nullptr;
677 }
678
GetPeerInfoById(napi_env env,napi_callback_info info)679 napi_value JsAbilityConnectionManager::GetPeerInfoById(napi_env env, napi_callback_info info)
680 {
681 HILOGD("called.");
682 GET_PARAMS(env, info, ARG_COUNT_ONE);
683 napi_value result = nullptr;
684 if (argc != ARG_COUNT_ONE) {
685 HILOGE("CheckArgsCount failed.");
686 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
687 return result;
688 }
689 int32_t sessionId = -1;
690 if (!JsToInt32(env, argv[ARG_INDEX_ZERO], "sessionId", sessionId)) {
691 HILOGE("Failed to unwrap sessionId.");
692 return result;
693 }
694
695 PeerInfo peerInfo;
696 int32_t ret = AbilityConnectionManager::GetInstance().getPeerInfoBySessionId(sessionId, peerInfo);
697 if (ret != ERR_OK) {
698 HILOGE("get peerInfo failed!");
699 napi_value undefinedValue;
700 napi_get_undefined(env, &undefinedValue);
701 return undefinedValue;
702 }
703
704 return WrapPeerInfo(env, peerInfo);
705 }
706
WrapPeerInfo(napi_env & env,const PeerInfo & peerInfo)707 napi_value JsAbilityConnectionManager::WrapPeerInfo(napi_env& env,
708 const PeerInfo& peerInfo)
709 {
710 napi_value peerInfoObj;
711 napi_create_object(env, &peerInfoObj);
712
713 // empty peerInfo return undefined
714 if (peerInfo.deviceId.empty()) {
715 napi_value undefinedValue;
716 napi_get_undefined(env, &undefinedValue);
717 return undefinedValue;
718 }
719
720 napi_value deviceId;
721 napi_create_string_utf8(env, peerInfo.deviceId.c_str(), NAPI_AUTO_LENGTH, &deviceId);
722 napi_set_named_property(env, peerInfoObj, "deviceId", deviceId);
723
724 napi_value bundleName;
725 napi_create_string_utf8(env, peerInfo.bundleName.c_str(), NAPI_AUTO_LENGTH, &bundleName);
726 napi_set_named_property(env, peerInfoObj, "bundleName", bundleName);
727
728 napi_value moduleName;
729 napi_create_string_utf8(env, peerInfo.moduleName.c_str(), NAPI_AUTO_LENGTH, &moduleName);
730 napi_set_named_property(env, peerInfoObj, "moduleName", moduleName);
731
732 napi_value abilityName;
733 napi_create_string_utf8(env, peerInfo.abilityName.c_str(), NAPI_AUTO_LENGTH, &abilityName);
734 napi_set_named_property(env, peerInfoObj, "abilityName", abilityName);
735
736 napi_value serviceName;
737 napi_create_string_utf8(env, peerInfo.serverId.c_str(), NAPI_AUTO_LENGTH, &serviceName);
738 napi_set_named_property(env, peerInfoObj, "serviceName", serviceName);
739
740 return peerInfoObj;
741 }
742
CheckEventType(const std::string & eventType)743 int32_t JsAbilityConnectionManager::CheckEventType(const std::string& eventType)
744 {
745 bool isExist = (std::find(REGISTER_EVENT_TYPES.begin(),
746 REGISTER_EVENT_TYPES.end(), eventType) != REGISTER_EVENT_TYPES.end());
747 if (!isExist) {
748 HILOGE("invalid event type not exist: %{public}s", eventType.c_str());
749 return ERR_INVALID_PARAMETERS;
750 }
751
752 bool isCallSystemApi = (std::find(SYSTEM_APP_EVENT_TYPES.begin(),
753 SYSTEM_APP_EVENT_TYPES.end(), eventType) != SYSTEM_APP_EVENT_TYPES.end());
754 if (isCallSystemApi && !IsSystemApp()) {
755 HILOGE("event type %{public}s only allow system app", eventType.c_str());
756 return ERR_IS_NOT_SYSTEM_APP;
757 }
758 return ERR_OK;
759 }
760
RegisterAbilityConnectionSessionCallback(napi_env env,napi_callback_info info)761 napi_value JsAbilityConnectionManager::RegisterAbilityConnectionSessionCallback(napi_env env, napi_callback_info info)
762 {
763 HILOGD("called.");
764 GET_PARAMS(env, info, ARG_COUNT_THREE);
765 if (argc != ARG_COUNT_THREE) {
766 HILOGE("CheckArgsCount failed.");
767 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
768 return nullptr;
769 }
770
771 std::string eventType;
772 if (!JsToString(env, argv[ARG_INDEX_ZERO], "eventType", eventType)) {
773 HILOGE("Failed to unwrap type.");
774 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
775 return nullptr;
776 }
777
778 int32_t ret = CheckEventType(eventType);
779 if (ret != ERR_OK) {
780 HILOGE("The type error. eventType is %{public}s", eventType.c_str());
781 CreateBusinessError(env, ret);
782 return nullptr;
783 }
784
785 int32_t sessionId = -1;
786 if (!JsToInt32(env, argv[ARG_INDEX_ONE], "sessionId", sessionId)) {
787 HILOGE("Failed to unwrap sessionId.");
788 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
789 return nullptr;
790 }
791
792 napi_value listenerObj = argv[ARG_INDEX_TWO];
793 if (listenerObj == nullptr) {
794 HILOGE("listenerObj is nullptr");
795 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
796 return nullptr;
797 }
798
799 bool isCallable = false;
800 napi_status status = napi_is_callable(env, listenerObj, &isCallable);
801 if (status != napi_ok || !isCallable) {
802 HILOGE("Failed to check listenerObj is callable");
803 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
804 return nullptr;
805 }
806
807 std::shared_ptr<JsAbilityConnectionSessionListener> listener =
808 std::make_shared<JsAbilityConnectionSessionListener>(env);
809
810 listener->SetCallback(listenerObj);
811 ret = AbilityConnectionManager::GetInstance().RegisterEventCallback(
812 sessionId, eventType, listener);
813 if (ret != ERR_OK) {
814 HILOGE("Register event callback failed!");
815 CreateBusinessError(env, ERR_EXECUTE_FUNCTION);
816 }
817 return nullptr;
818 }
819
UnregisterAbilityConnectionSessionCallback(napi_env env,napi_callback_info info)820 napi_value JsAbilityConnectionManager::UnregisterAbilityConnectionSessionCallback(napi_env env,
821 napi_callback_info info)
822 {
823 HILOGD("called.");
824 GET_PARAMS(env, info, ARG_COUNT_TWO);
825 if (argc != ARG_COUNT_TWO) {
826 HILOGE("CheckArgsCount failed.");
827 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
828 return nullptr;
829 }
830
831 std::string eventType;
832 if (!JsToString(env, argv[ARG_INDEX_ZERO], "eventType", eventType)) {
833 HILOGE("Failed to unwrap type.");
834 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
835 return nullptr;
836 }
837
838 int32_t ret = CheckEventType(eventType);
839 if (ret != ERR_OK) {
840 HILOGE("The type error. eventType is %{public}s", eventType.c_str());
841 CreateBusinessError(env, ret);
842 return nullptr;
843 }
844
845 int32_t sessionId = -1;
846 if (!JsToInt32(env, argv[ARG_INDEX_ONE], "sessionId", sessionId)) {
847 HILOGE("Failed to unwrap sessionId.");
848 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
849 return nullptr;
850 }
851
852 ret = AbilityConnectionManager::GetInstance().UnregisterEventCallback(sessionId, eventType);
853 if (ret != ERR_OK) {
854 HILOGE("Unregister event callback failed!");
855 CreateBusinessError(env, ERR_EXECUTE_FUNCTION);
856 }
857 return nullptr;
858 }
859
Connect(napi_env env,napi_callback_info info)860 napi_value JsAbilityConnectionManager::Connect(napi_env env, napi_callback_info info)
861 {
862 HILOGI("called.");
863 int32_t sessionId = -1;
864 GET_PARAMS(env, info, ARG_COUNT_ONE);
865 if (argc != ARG_COUNT_ONE || !JsToInt32(env, argv[ARG_INDEX_ZERO], "sessionId", sessionId)) {
866 HILOGE("CheckArgsCount failed or Failed to unwrap sessionId.");
867 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
868 return nullptr;
869 }
870
871 napi_deferred deferred;
872 napi_value promise = nullptr;
873 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
874
875 AsyncConnectCallbackInfo* asyncCallbackInfo = new AsyncConnectCallbackInfo();
876 asyncCallbackInfo->deferred = deferred;
877 asyncCallbackInfo->sessionId = sessionId;
878
879 napi_threadsafe_function tsfn;
880 if (CreateConnectThreadsafeFunction(env, nullptr, &tsfn) != napi_ok || tsfn == nullptr) {
881 HILOGE("Failed to create connect function.");
882 delete asyncCallbackInfo;
883 napi_release_threadsafe_function(tsfn, napi_tsfn_release);
884 napi_reject_deferred(env, deferred, CreateBusinessError(env, ERR_EXECUTE_FUNCTION, false));
885 return promise;
886 }
887 asyncCallbackInfo->tsfn = tsfn;
888
889 napi_value asyncResourceName;
890 NAPI_CALL(env, napi_create_string_utf8(env, "connectAsync", NAPI_AUTO_LENGTH, &asyncResourceName));
891
892 napi_status status = napi_create_async_work(
893 env, nullptr, asyncResourceName, ExecuteConnect, CompleteAsyncConnectWork,
894 static_cast<void *>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork);
895 if (status != napi_ok) {
896 HILOGE("Failed to create async work.");
897 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
898 delete asyncCallbackInfo;
899 napi_release_threadsafe_function(tsfn, napi_tsfn_release);
900 napi_reject_deferred(env, deferred, CreateBusinessError(env, ERR_EXECUTE_FUNCTION, false));
901 return promise;
902 }
903
904 if (napi_queue_async_work(env, asyncCallbackInfo->asyncWork) != napi_ok) {
905 HILOGE("Failed to queue async work.");
906 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
907 delete asyncCallbackInfo;
908 napi_release_threadsafe_function(tsfn, napi_tsfn_release);
909 napi_reject_deferred(env, deferred, CreateBusinessError(env, ERR_EXECUTE_FUNCTION, false));
910 return promise;
911 }
912
913 return promise;
914 }
915
CreateConnectThreadsafeFunction(napi_env env,napi_value js_func,napi_threadsafe_function * tsfn)916 napi_status JsAbilityConnectionManager::CreateConnectThreadsafeFunction(napi_env env,
917 napi_value js_func, napi_threadsafe_function* tsfn)
918 {
919 napi_value async_resource = nullptr;
920 napi_value async_resource_name = nullptr;
921 napi_create_string_utf8(env, "connectAsync", NAPI_AUTO_LENGTH, &async_resource_name);
922
923 return napi_create_threadsafe_function(
924 env, js_func, async_resource, async_resource_name,
925 0, 1, nullptr, nullptr, nullptr,
926 ConnectThreadsafeFunctionCallback, tsfn);
927 }
928
ConnectThreadsafeFunctionCallback(napi_env env,napi_value js_callback,void * context,void * data)929 void JsAbilityConnectionManager::ConnectThreadsafeFunctionCallback(napi_env env, napi_value js_callback,
930 void* context, void* data)
931 {
932 HILOGI("called.");
933 if (data == nullptr) {
934 HILOGE("Async data is null");
935 return;
936 }
937
938 AsyncConnectCallbackInfo* asyncData = static_cast<AsyncConnectCallbackInfo*>(data);
939 napi_value connectResultObj;
940 napi_create_object(env, &connectResultObj);
941
942 napi_value isConnected;
943 napi_get_boolean(env, asyncData->result.isConnected, &isConnected);
944 napi_set_named_property(env, connectResultObj, "isConnected", isConnected);
945
946 napi_value reason;
947 napi_create_string_utf8(env, asyncData->result.reason.c_str(), NAPI_AUTO_LENGTH, &reason);
948 napi_set_named_property(env, connectResultObj, "reason", reason);
949
950 if (!asyncData->result.isConnected) {
951 napi_value errorCode;
952 napi_create_int32(env, static_cast<int32_t>(asyncData->result.errorCode), &errorCode);
953 napi_set_named_property(env, connectResultObj, "errorCode", errorCode);
954 }
955 napi_resolve_deferred(env, asyncData->deferred, connectResultObj);
956
957 napi_async_work asyncWork = asyncData->asyncWork;
958 napi_release_threadsafe_function(asyncData->tsfn, napi_tsfn_release);
959 napi_delete_async_work(env, asyncWork);
960 AbilityConnectionManager::GetInstance().FinishSessionConnect(asyncData->result.sessionId);
961 delete asyncData;
962 }
963
ExecuteConnect(napi_env env,void * data)964 void JsAbilityConnectionManager::ExecuteConnect(napi_env env, void *data)
965 {
966 HILOGI("called.");
967 AsyncConnectCallbackInfo* asyncData = static_cast<AsyncConnectCallbackInfo*>(data);
968 AbilityConnectionManager::ConnectCallback connectCallback = [asyncData](ConnectResult result) {
969 asyncData->result = result;
970 napi_threadsafe_function tsfn = asyncData->tsfn;
971 if (tsfn == nullptr) {
972 HILOGE("tsfn is nullptr");
973 }
974 napi_status status = napi_call_threadsafe_function(tsfn, asyncData, napi_tsfn_nonblocking);
975 if (status != napi_ok) {
976 HILOGE("Failed to create async work. status is %{public}d", static_cast<int32_t>(status));
977 }
978 };
979 asyncData->funResult = AbilityConnectionManager::GetInstance().ConnectSession(
980 asyncData->sessionId, connectCallback);
981 }
982
CompleteAsyncConnectWork(napi_env env,napi_status status,void * data)983 void JsAbilityConnectionManager::CompleteAsyncConnectWork(napi_env env, napi_status status, void* data)
984 {
985 HILOGI("called.");
986 if (data == nullptr) {
987 HILOGE("Async data is null");
988 return;
989 }
990
991 AsyncConnectCallbackInfo* asyncData = static_cast<AsyncConnectCallbackInfo*>(data);
992 HILOGI("start connect result is %{public}d", asyncData->funResult);
993 if (asyncData->funResult == INVALID_SESSION_ID) {
994 HILOGE("failed to start connect.");
995 napi_status ret = napi_reject_deferred(env, asyncData->deferred,
996 CreateBusinessError(env, ERR_INVALID_PARAMETERS, false));
997 if (ret != napi_ok) {
998 HILOGE("Failed to throw error. status is %{public}d", static_cast<int32_t>(ret));
999 }
1000 napi_delete_async_work(env, asyncData->asyncWork);
1001 delete asyncData;
1002 }
1003 }
1004
DisConnect(napi_env env,napi_callback_info info)1005 napi_value JsAbilityConnectionManager::DisConnect(napi_env env, napi_callback_info info)
1006 {
1007 HILOGI("called.");
1008 GET_PARAMS(env, info, ARG_COUNT_ONE);
1009 if (argc != ARG_COUNT_ONE) {
1010 HILOGE("CheckArgsCount failed.");
1011 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1012 return nullptr;
1013 }
1014
1015 int32_t sessionId = -1;
1016 if (!JsToInt32(env, argv[ARG_INDEX_ZERO], "sessionId", sessionId)) {
1017 HILOGE("Failed to unwrap sessionId.");
1018 return nullptr;
1019 }
1020
1021 int32_t ret = AbilityConnectionManager::GetInstance().DisconnectSession(sessionId);
1022 if (ret != ERR_OK) {
1023 HILOGE("disconnect session failed!");
1024 CreateBusinessError(env, ERR_EXECUTE_FUNCTION);
1025 }
1026 return nullptr;
1027 }
1028
CompleteAsyncWork(napi_env env,napi_status status,void * data)1029 void JsAbilityConnectionManager::CompleteAsyncWork(napi_env env, napi_status status, void* data)
1030 {
1031 HILOGI("called.");
1032 if (data == nullptr) {
1033 HILOGE("Async data is null");
1034 return;
1035 }
1036
1037 AsyncCallbackInfo* asyncData = static_cast<AsyncCallbackInfo*>(data);
1038 if (asyncData->result == ERR_OK) {
1039 napi_value result;
1040 napi_get_undefined(env, &result);
1041 napi_resolve_deferred(env, asyncData->deferred, result);
1042 } else {
1043 napi_reject_deferred(env, asyncData->deferred,
1044 CreateBusinessError(env, asyncData->result, false));
1045 }
1046 napi_delete_async_work(env, asyncData->asyncWork);
1047 delete asyncData;
1048 }
1049
AcceptConnect(napi_env env,napi_callback_info info)1050 napi_value JsAbilityConnectionManager::AcceptConnect(napi_env env, napi_callback_info info)
1051 {
1052 HILOGI("called.");
1053 GET_PARAMS(env, info, ARG_COUNT_TWO);
1054 if (argc != ARG_COUNT_TWO) {
1055 HILOGE("CheckArgsCount failed.");
1056 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1057 return nullptr;
1058 }
1059
1060 int32_t sessionId = -1;
1061 if (!JsToInt32(env, argv[ARG_INDEX_ZERO], "sessionId", sessionId)) {
1062 HILOGE("Failed to unwrap sessionId.");
1063 return nullptr;
1064 }
1065
1066 std::string token;
1067 if (!JsToString(env, argv[ARG_INDEX_ONE], "token", token)) {
1068 HILOGE("Failed to unwrap token.");
1069 return nullptr;
1070 }
1071
1072 napi_deferred deferred;
1073 napi_value promise = nullptr;
1074 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1075
1076 AsyncCallbackInfo* asyncCallbackInfo = new AsyncCallbackInfo();
1077 asyncCallbackInfo->deferred = deferred;
1078 asyncCallbackInfo->sessionId = sessionId;
1079 asyncCallbackInfo->token = token;
1080
1081 napi_value asyncResourceName;
1082 NAPI_CALL(env, napi_create_string_utf8(env, "acceptConnectAsync", NAPI_AUTO_LENGTH, &asyncResourceName));
1083
1084 napi_status status = napi_create_async_work(
1085 env, nullptr, asyncResourceName, ExecuteAcceptConnect, CompleteAsyncWork,
1086 static_cast<void *>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork);
1087 if (status != napi_ok) {
1088 HILOGE("Failed to create async work.");
1089 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1090 delete asyncCallbackInfo;
1091 napi_reject_deferred(env, deferred, CreateBusinessError(env, ERR_EXECUTE_FUNCTION, false));
1092 return promise;
1093 }
1094
1095 if (napi_queue_async_work(env, asyncCallbackInfo->asyncWork) != napi_ok) {
1096 HILOGE("Failed to queue async work.");
1097 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1098 delete asyncCallbackInfo;
1099 napi_reject_deferred(env, deferred, CreateBusinessError(env, ERR_EXECUTE_FUNCTION, false));
1100 return promise;
1101 }
1102 return promise;
1103 }
1104
ExecuteAcceptConnect(napi_env env,void * data)1105 void JsAbilityConnectionManager::ExecuteAcceptConnect(napi_env env, void *data)
1106 {
1107 HILOGI("called.");
1108 AsyncCallbackInfo* asyncData = static_cast<AsyncCallbackInfo*>(data);
1109 asyncData->result = AbilityConnectionManager::GetInstance().AcceptConnect(asyncData->sessionId, asyncData->token);
1110 }
1111
Reject(napi_env env,napi_callback_info info)1112 napi_value JsAbilityConnectionManager::Reject(napi_env env, napi_callback_info info)
1113 {
1114 HILOGI("called.");
1115 GET_PARAMS(env, info, ARG_COUNT_TWO);
1116 if (argc != ARG_COUNT_TWO) {
1117 HILOGE("CheckArgsCount failed.");
1118 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1119 return nullptr;
1120 }
1121
1122 std::string token;
1123 if (!JsToString(env, argv[ARG_INDEX_ZERO], "token", token)) {
1124 HILOGE("Failed to unwrap token.");
1125 return nullptr;
1126 }
1127
1128 std::string reason;
1129 if (!JsToString(env, argv[ARG_INDEX_ONE], "reason", reason)) {
1130 HILOGE("Failed to unwrap reason.");
1131 return nullptr;
1132 }
1133
1134 int32_t ret = AbilityConnectionManager::GetInstance().Reject(token, reason);
1135 if (ret != ERR_OK) {
1136 HILOGE("Reject session failed!");
1137 CreateBusinessError(env, ERR_EXECUTE_FUNCTION);
1138 }
1139 return nullptr;
1140 }
1141
SendMessage(napi_env env,napi_callback_info info)1142 napi_value JsAbilityConnectionManager::SendMessage(napi_env env, napi_callback_info info)
1143 {
1144 HILOGI("called.");
1145 napi_deferred deferred;
1146 napi_value promise = nullptr;
1147 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1148
1149 GET_PARAMS(env, info, ARG_COUNT_TWO);
1150 if (argc != ARG_COUNT_TWO) {
1151 HILOGE("CheckArgsCount failed.");
1152 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1153 return promise;
1154 }
1155
1156 int32_t sessionId = -1;
1157 if (!JsToInt32(env, argv[ARG_INDEX_ZERO], "sessionId", sessionId)) {
1158 HILOGE("Failed to unwrap sessionId.");
1159 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1160 return promise;
1161 }
1162
1163 std::string msg;
1164 if (!JsToString(env, argv[ARG_INDEX_ONE], "msg", msg)) {
1165 HILOGE("Failed to unwrap msg.");
1166 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1167 return promise;
1168 }
1169
1170 HILOGI("start send message.");
1171 int32_t ret = AbilityConnectionManager::GetInstance().SendMessage(sessionId, msg);
1172 HILOGI("notify sendMessage event.");
1173 if (ret == ERR_OK) {
1174 napi_value result;
1175 napi_get_undefined(env, &result);
1176 napi_resolve_deferred(env, deferred, result);
1177 } else {
1178 napi_reject_deferred(env, deferred,
1179 CreateBusinessError(env, ret, false));
1180 }
1181
1182 HILOGI("end.");
1183 return promise;
1184 }
1185
ExecuteSendMessage(napi_env env,void * data)1186 void JsAbilityConnectionManager::ExecuteSendMessage(napi_env env, void *data)
1187 {
1188 AsyncCallbackInfo* asyncData = static_cast<AsyncCallbackInfo*>(data);
1189 asyncData->result = AbilityConnectionManager::GetInstance().SendMessage(asyncData->sessionId, asyncData->msg);
1190 }
1191
SendData(napi_env env,napi_callback_info info)1192 napi_value JsAbilityConnectionManager::SendData(napi_env env, napi_callback_info info)
1193 {
1194 HILOGI("called.");
1195 napi_deferred deferred;
1196 napi_value promise = nullptr;
1197 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1198
1199 GET_PARAMS(env, info, ARG_COUNT_TWO);
1200 if (argc != ARG_COUNT_TWO) {
1201 HILOGE("CheckArgsCount failed.");
1202 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1203 return promise;
1204 }
1205
1206 int32_t sessionId = -1;
1207 if (!JsToInt32(env, argv[ARG_INDEX_ZERO], "sessionId", sessionId)) {
1208 HILOGE("Failed to unwrap sessionId.");
1209 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1210 return promise;
1211 }
1212
1213 void *data;
1214 size_t length;
1215 if (napi_get_arraybuffer_info(env, argv[ARG_INDEX_ONE], &data, &length) != napi_ok) {
1216 HILOGE("get arraybuffer info failed.");
1217 napi_throw_error(env, nullptr, ERR_MESSAGE_FAILED.c_str());
1218 return nullptr;
1219 }
1220
1221 std::shared_ptr<AVTransDataBuffer> buffer = std::make_shared<AVTransDataBuffer>(length);
1222 if (memcpy_s(buffer->Data(), buffer->Size(), data, length) != ERR_OK) {
1223 HILOGE("pack recv data failed");
1224 napi_throw_error(env, nullptr, ERR_MESSAGE_FAILED.c_str());
1225 return nullptr;
1226 }
1227
1228 AsyncCallbackInfo* asyncCallbackInfo = new AsyncCallbackInfo();
1229 asyncCallbackInfo->deferred = deferred;
1230 asyncCallbackInfo->sessionId = sessionId;
1231 asyncCallbackInfo->buffer = buffer;
1232 CreateSendDataAsyncWork(env, asyncCallbackInfo);
1233 return promise;
1234 }
1235
CreateSendDataAsyncWork(napi_env env,AsyncCallbackInfo * asyncCallbackInfo)1236 void JsAbilityConnectionManager::CreateSendDataAsyncWork(napi_env env, AsyncCallbackInfo* asyncCallbackInfo)
1237 {
1238 if (asyncCallbackInfo == nullptr) {
1239 return;
1240 }
1241 napi_value asyncResourceName;
1242 napi_create_string_utf8(env, "sendDataAsync", NAPI_AUTO_LENGTH, &asyncResourceName);
1243
1244 napi_status status = napi_create_async_work(
1245 env, nullptr, asyncResourceName, ExecuteSendData, CompleteAsyncWork,
1246 static_cast<void *>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork);
1247 if (status != napi_ok) {
1248 HILOGE("Failed to create async work.");
1249 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1250 napi_reject_deferred(env, asyncCallbackInfo->deferred, CreateBusinessError(env, ERR_EXECUTE_FUNCTION, false));
1251 delete asyncCallbackInfo;
1252 return;
1253 }
1254
1255 if (napi_queue_async_work(env, asyncCallbackInfo->asyncWork) != napi_ok) {
1256 HILOGE("Failed to queue async work.");
1257 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1258 napi_reject_deferred(env, asyncCallbackInfo->deferred, CreateBusinessError(env, ERR_EXECUTE_FUNCTION, false));
1259 delete asyncCallbackInfo;
1260 return;
1261 }
1262 }
1263
ExecuteSendData(napi_env env,void * data)1264 void JsAbilityConnectionManager::ExecuteSendData(napi_env env, void *data)
1265 {
1266 AsyncCallbackInfo* asyncData = static_cast<AsyncCallbackInfo*>(data);
1267 asyncData->result = AbilityConnectionManager::GetInstance().SendData(asyncData->sessionId, asyncData->buffer);
1268 }
1269
SendImage(napi_env env,napi_callback_info info)1270 napi_value JsAbilityConnectionManager::SendImage(napi_env env, napi_callback_info info)
1271 {
1272 HILOGI("called.");
1273 if (!IsSystemApp()) {
1274 HILOGE("Permission verification failed.");
1275 CreateBusinessError(env, ERR_IS_NOT_SYSTEM_APP);
1276 }
1277
1278 napi_deferred deferred;
1279 napi_value promise = nullptr;
1280 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1281
1282 GET_PARAMS(env, info, ARG_COUNT_THREE);
1283 if (argc < ARG_COUNT_TWO || argc > ARG_COUNT_THREE) {
1284 HILOGE("CheckArgsCount failed.");
1285 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1286 return promise;
1287 }
1288
1289 int32_t sessionId = -1;
1290 if (!JsToInt32(env, argv[ARG_INDEX_ZERO], "sessionId", sessionId)) {
1291 HILOGE("Failed to unwrap sessionId.");
1292 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1293 return promise;
1294 }
1295
1296 int32_t quality = IMAGE_COMPRESSION_QUALITY;
1297 if (argc == ARG_COUNT_THREE) {
1298 if (!JsToInt32(env, argv[ARG_INDEX_TWO], "quality", quality)) {
1299 HILOGE("Failed to unwrap quality.");
1300 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1301 return promise;
1302 }
1303 }
1304
1305 AsyncCallbackInfo* asyncCallbackInfo = new AsyncCallbackInfo();
1306 asyncCallbackInfo->deferred = deferred;
1307 asyncCallbackInfo->sessionId = sessionId;
1308 asyncCallbackInfo->image = Media::PixelMapNapi::GetPixelMap(env, argv[ARG_INDEX_ONE]);
1309 if (!asyncCallbackInfo->image) {
1310 HILOGE("Failed to unwrap image.");
1311 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1312 delete asyncCallbackInfo;
1313 return promise;
1314 }
1315 asyncCallbackInfo->imageQuality = quality;
1316 return CreateSendImageAsyncWork(env, asyncCallbackInfo);
1317 }
1318
CreateSendImageAsyncWork(napi_env env,AsyncCallbackInfo * asyncCallbackInfo)1319 napi_value JsAbilityConnectionManager::CreateSendImageAsyncWork(napi_env env, AsyncCallbackInfo* asyncCallbackInfo)
1320 {
1321 napi_value promise = nullptr;
1322 if (asyncCallbackInfo == nullptr) {
1323 return promise;
1324 }
1325 napi_value asyncResourceName;
1326 NAPI_CALL(env, napi_create_string_utf8(env, "sendImageAsync", NAPI_AUTO_LENGTH, &asyncResourceName));
1327
1328 napi_status status = napi_create_async_work(
1329 env, nullptr, asyncResourceName, ExecuteSendImage, CompleteAsyncWork,
1330 static_cast<void *>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork);
1331 if (status != napi_ok) {
1332 HILOGE("Failed to create async work.");
1333 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1334 napi_reject_deferred(env, asyncCallbackInfo->deferred, CreateBusinessError(env, ERR_EXECUTE_FUNCTION, false));
1335 delete asyncCallbackInfo;
1336 return promise;
1337 }
1338
1339 if (napi_queue_async_work(env, asyncCallbackInfo->asyncWork) != napi_ok) {
1340 HILOGE("Failed to queue async work.");
1341 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1342 napi_reject_deferred(env, asyncCallbackInfo->deferred, CreateBusinessError(env, ERR_EXECUTE_FUNCTION, false));
1343 delete asyncCallbackInfo;
1344 return promise;
1345 }
1346
1347 return promise;
1348 }
1349
ExecuteSendImage(napi_env env,void * data)1350 void JsAbilityConnectionManager::ExecuteSendImage(napi_env env, void *data)
1351 {
1352 AsyncCallbackInfo* asyncData = static_cast<AsyncCallbackInfo*>(data);
1353 asyncData->result = AbilityConnectionManager::GetInstance().SendImage(asyncData->sessionId,
1354 asyncData->image, asyncData->imageQuality);
1355 }
1356
CreateStream(napi_env env,napi_callback_info info)1357 napi_value JsAbilityConnectionManager::CreateStream(napi_env env, napi_callback_info info)
1358 {
1359 HILOGD("called.");
1360 if (!IsSystemApp()) {
1361 HILOGE("Permission verification failed.");
1362 CreateBusinessError(env, ERR_IS_NOT_SYSTEM_APP);
1363 }
1364
1365 napi_deferred deferred;
1366 napi_value promise = nullptr;
1367 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1368
1369 GET_PARAMS(env, info, ARG_COUNT_TWO);
1370 if (argc != ARG_COUNT_TWO) {
1371 HILOGE("CheckArgsCount failed.");
1372 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1373 return promise;
1374 }
1375
1376 int32_t sessionId = -1;
1377 if (!JsToInt32(env, argv[ARG_INDEX_ZERO], "sessionId", sessionId)) {
1378 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1379 return promise;
1380 }
1381
1382 HILOGI("StreamParam.");
1383 StreamParams streamParam;
1384 if (!JsToStreamParam(env, argv[ARG_INDEX_ONE], streamParam)) {
1385 HILOGE("Failed to unwrap streamParam.");
1386 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1387 return promise;
1388 }
1389
1390 AsyncCallbackInfo* asyncCallbackInfo = new AsyncCallbackInfo();
1391 asyncCallbackInfo->deferred = deferred;
1392 asyncCallbackInfo->sessionId = sessionId;
1393 asyncCallbackInfo->streamParam = streamParam;
1394 CreateStreamAsyncWork(env, asyncCallbackInfo);
1395
1396 return promise;
1397 }
1398
CreateStreamAsyncWork(napi_env env,AsyncCallbackInfo * asyncCallbackInfo)1399 void JsAbilityConnectionManager::CreateStreamAsyncWork(napi_env env, AsyncCallbackInfo* asyncCallbackInfo)
1400 {
1401 napi_value asyncResourceName;
1402 napi_create_string_utf8(env, "createStreamAsync", NAPI_AUTO_LENGTH, &asyncResourceName);
1403
1404 napi_status status = napi_create_async_work(
1405 env, nullptr, asyncResourceName, ExecuteCreateStream, CompleteAsyncCreateStreamWork,
1406 static_cast<void *>(asyncCallbackInfo), &asyncCallbackInfo->asyncWork);
1407 if (status != napi_ok) {
1408 HILOGE("Failed to create async work.");
1409 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1410 napi_reject_deferred(env, asyncCallbackInfo->deferred, CreateBusinessError(env, ERR_EXECUTE_FUNCTION, false));
1411 delete asyncCallbackInfo;
1412 return;
1413 }
1414
1415 if (napi_queue_async_work(env, asyncCallbackInfo->asyncWork) != napi_ok) {
1416 HILOGE("Failed to queue async work.");
1417 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
1418 napi_reject_deferred(env, asyncCallbackInfo->deferred, CreateBusinessError(env, ERR_EXECUTE_FUNCTION, false));
1419 delete asyncCallbackInfo;
1420 return;
1421 }
1422 }
1423
JsToStreamParam(const napi_env & env,const napi_value & jsValue,StreamParams & streamParam)1424 bool JsAbilityConnectionManager::JsToStreamParam(const napi_env &env, const napi_value &jsValue,
1425 StreamParams &streamParam)
1426 {
1427 napi_valuetype argvType = napi_undefined;
1428 NAPI_CALL_BASE(env, napi_typeof(env, jsValue, &argvType), false);
1429 if (argvType != napi_object) {
1430 HILOGE("Parameter verification failed.");
1431 return false;
1432 }
1433
1434 if (!JsObjectToString(env, jsValue, "name", streamParam.name)) {
1435 HILOGE("name parameter parsing failed.");
1436 return false;
1437 }
1438
1439 int32_t role = -1;
1440 if (!JsObjectToInt(env, jsValue, "role", role)) {
1441 HILOGE("role verification failed.");
1442 return false;
1443 }
1444
1445 if (role < static_cast<int32_t>(StreamRole::SOURCE) ||
1446 role > static_cast<int32_t>(StreamRole::SINK)) {
1447 HILOGE("Invalid role value: %{public}d", role);
1448 return false;
1449 }
1450 streamParam.role = static_cast<StreamRole>(role);
1451 if (!GetStreamParamBitrate(env, jsValue, streamParam)) {
1452 HILOGW("bitrate verification failed.");
1453 return false;
1454 }
1455 return true;
1456 }
1457
GetStreamParamBitrate(const napi_env & env,const napi_value & jsValue,StreamParams & streamParam)1458 bool JsAbilityConnectionManager::GetStreamParamBitrate(const napi_env &env, const napi_value &jsValue,
1459 StreamParams &streamParam)
1460 {
1461 int32_t bitrate = -1;
1462 if (JsObjectToInt(env, jsValue, "bitrate", bitrate)) {
1463 OH_BitrateMode bitrateMode = BITRATE_MODE_CBR;
1464 OH_AVCapability *capability = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true);
1465 if (capability == nullptr) {
1466 HILOGE("GetCapability failed, it's nullptr");
1467 return false;
1468 }
1469 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(capability, bitrateMode);
1470 if (!isSupported) {
1471 HILOGE("BITRATE_MODE_CBR is not support.");
1472 return false;
1473 }
1474 OH_AVRange bitrateRange = {-1, -1};
1475 int32_t ret = OH_AVCapability_GetEncoderBitrateRange(capability, &bitrateRange);
1476 if (ret != AV_ERR_OK || bitrateRange.maxVal <= 0) {
1477 HILOGE("bitrate range query failed. ret: %{public}d; maxVal: %{public}d;", ret, bitrateRange.maxVal);
1478 return false;
1479 }
1480 if (bitrate < bitrateRange.minVal || bitrate > bitrateRange.maxVal) {
1481 HILOGE("Bitrate is not supported, it should be between %{public}d and %{public}d", bitrateRange.minVal,
1482 bitrateRange.maxVal);
1483 return false;
1484 }
1485 HILOGI("bitrate is %{public}d.", bitrate);
1486 streamParam.bitrate = bitrate;
1487 }
1488 return true;
1489 }
1490
ExecuteCreateStream(napi_env env,void * data)1491 void JsAbilityConnectionManager::ExecuteCreateStream(napi_env env, void *data)
1492 {
1493 AsyncCallbackInfo* asyncData = static_cast<AsyncCallbackInfo*>(data);
1494
1495 asyncData->result = AbilityConnectionManager::GetInstance().CreateStream(asyncData->sessionId,
1496 asyncData->streamParam, asyncData->streamId);
1497 }
1498
CompleteAsyncCreateStreamWork(napi_env env,napi_status status,void * data)1499 void JsAbilityConnectionManager::CompleteAsyncCreateStreamWork(napi_env env, napi_status status, void* data)
1500 {
1501 HILOGI("called.");
1502 if (data == nullptr) {
1503 HILOGE("Async data is null");
1504 return;
1505 }
1506
1507 AsyncCallbackInfo* asyncData = static_cast<AsyncCallbackInfo*>(data);
1508 if (asyncData->result == ERR_OK) {
1509 napi_value result;
1510 napi_create_int32(env, asyncData->streamId, &result);
1511 napi_resolve_deferred(env, asyncData->deferred, result);
1512 } else {
1513 napi_reject_deferred(env, asyncData->deferred,
1514 CreateBusinessError(env, asyncData->result, false));
1515 }
1516 napi_delete_async_work(env, asyncData->asyncWork);
1517 delete asyncData;
1518 }
1519
SetSurfaceId(napi_env env,napi_callback_info info)1520 napi_value JsAbilityConnectionManager::SetSurfaceId(napi_env env, napi_callback_info info)
1521 {
1522 HILOGI("called.");
1523 if (!IsSystemApp()) {
1524 HILOGE("Permission verification failed.");
1525 CreateBusinessError(env, ERR_IS_NOT_SYSTEM_APP);
1526 }
1527
1528 GET_PARAMS(env, info, ARG_COUNT_THREE);
1529 if (argc != ARG_COUNT_THREE) {
1530 HILOGE("CheckArgsCount failed.");
1531 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1532 return nullptr;
1533 }
1534
1535 int32_t streamId = -1;
1536 if (!JsToInt32(env, argv[ARG_INDEX_ZERO], "streamId", streamId)) {
1537 HILOGE("Parameter parsing failed.");
1538 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1539 return nullptr;
1540 }
1541
1542 std::string surfaceId;
1543 if (!JsToString(env, argv[ARG_INDEX_ONE], "surfaceId", surfaceId)) {
1544 HILOGE("surfaceId parsing failed.");
1545 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1546 return nullptr;
1547 }
1548
1549 SurfaceParams surfaceParam;
1550 if (!JsToSurfaceParam(env, argv[ARG_INDEX_TWO], surfaceParam)) {
1551 HILOGE("Failed to unwrap surfaceParam.");
1552 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1553 return nullptr;
1554 }
1555
1556 int32_t ret = AbilityConnectionManager::GetInstance().SetSurfaceId(streamId,
1557 surfaceId, surfaceParam);
1558 if (ret != ERR_OK) {
1559 HILOGE("SetSurfaceId failed.");
1560 CreateBusinessError(env, ERR_EXECUTE_FUNCTION);
1561 }
1562 return nullptr;
1563 }
1564
JsToSurfaceParam(const napi_env & env,const napi_value & jsValue,SurfaceParams & surfaceParam)1565 bool JsAbilityConnectionManager::JsToSurfaceParam(const napi_env &env, const napi_value &jsValue,
1566 SurfaceParams &surfaceParam)
1567 {
1568 napi_valuetype argvType = napi_undefined;
1569 NAPI_CALL_BASE(env, napi_typeof(env, jsValue, &argvType), false);
1570 if (argvType != napi_object) {
1571 HILOGE("Parameter verification failed.");
1572 return false;
1573 }
1574
1575 if (!JsObjectToInt(env, jsValue, "width", surfaceParam.width)) {
1576 HILOGE("Unable to get width parameter.");
1577 return false;
1578 }
1579
1580 if (!JsObjectToInt(env, jsValue, "height", surfaceParam.height)) {
1581 HILOGE("Unable to get height parameter.");
1582 return false;
1583 }
1584
1585 int32_t format = -1;
1586 if (JsObjectToInt(env, jsValue, "format", format)) {
1587 if (format < static_cast<int32_t>(VideoPixelFormat::UNKNOWN) ||
1588 format > static_cast<int32_t>(VideoPixelFormat::NV21)) {
1589 HILOGE("Invalid format value: %{public}d", format);
1590 return false;
1591 }
1592 surfaceParam.format = static_cast<VideoPixelFormat>(format);
1593 }
1594
1595 int32_t flip = -1;
1596 if (JsObjectToInt(env, jsValue, "flip", flip)) {
1597 if (flip < static_cast<int32_t>(FlipOptions::HORIZONTAL) ||
1598 flip > static_cast<int32_t>(FlipOptions::VERTICAL)) {
1599 HILOGE("Invalid flip value: %{public}d", flip);
1600 return false;
1601 }
1602 surfaceParam.flip = static_cast<FlipOptions>(flip);
1603 }
1604
1605 if (!JsObjectToInt(env, jsValue, "rotation", surfaceParam.rotation)) {
1606 HILOGW("Unable to get rotation parameter.");
1607 }
1608
1609 return true;
1610 }
1611
GetSurfaceId(napi_env env,napi_callback_info info)1612 napi_value JsAbilityConnectionManager::GetSurfaceId(napi_env env, napi_callback_info info)
1613 {
1614 HILOGI("called.");
1615 if (!IsSystemApp()) {
1616 HILOGE("Permission verification failed.");
1617 CreateBusinessError(env, ERR_IS_NOT_SYSTEM_APP);
1618 }
1619
1620 GET_PARAMS(env, info, ARG_COUNT_TWO);
1621 if (argc != ARG_COUNT_TWO) {
1622 HILOGE("CheckArgsCount failed.");
1623 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1624 return nullptr;
1625 }
1626
1627 int32_t streamId = -1;
1628 if (!JsToInt32(env, argv[ARG_INDEX_ZERO], "streamId", streamId)) {
1629 HILOGE("Parameter parsing failed.");
1630 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1631 return nullptr;
1632 }
1633
1634 SurfaceParams surfaceParam;
1635 if (!JsToSurfaceParam(env, argv[ARG_INDEX_ONE], surfaceParam)) {
1636 HILOGE("Failed to unwrap surfaceParam.");
1637 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1638 return nullptr;
1639 }
1640
1641 std::string surfaceId;
1642 int32_t ret = AbilityConnectionManager::GetInstance().GetSurfaceId(streamId, surfaceParam, surfaceId);
1643 if (ret != ERR_OK) {
1644 HILOGE("SetSurfaceId failed.");
1645 CreateBusinessError(env, ERR_EXECUTE_FUNCTION);
1646 return nullptr;
1647 }
1648
1649 napi_value result;
1650 napi_create_string_utf8(env, surfaceId.c_str(), surfaceId.size(), &result);
1651 return result;
1652 }
1653
UpdateSurfaceParam(napi_env env,napi_callback_info info)1654 napi_value JsAbilityConnectionManager::UpdateSurfaceParam(napi_env env, napi_callback_info info)
1655 {
1656 HILOGI("called.");
1657 if (!IsSystemApp()) {
1658 HILOGE("Permission verification failed.");
1659 CreateBusinessError(env, ERR_IS_NOT_SYSTEM_APP);
1660 }
1661
1662 GET_PARAMS(env, info, ARG_COUNT_TWO);
1663 if (argc != ARG_COUNT_TWO) {
1664 HILOGE("CheckArgsCount failed.");
1665 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1666 return nullptr;
1667 }
1668
1669 int32_t streamId = -1;
1670 if (!JsToInt32(env, argv[ARG_INDEX_ZERO], "streamId", streamId)) {
1671 HILOGE("streamId parsing failed.");
1672 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1673 return nullptr;
1674 }
1675
1676 SurfaceParams surfaceParam;
1677 if (!JsToSurfaceParam(env, argv[ARG_INDEX_ONE], surfaceParam)) {
1678 HILOGE("Failed to unwrap surfaceParam.");
1679 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1680 return nullptr;
1681 }
1682
1683 int32_t ret = AbilityConnectionManager::GetInstance().UpdateSurfaceParam(streamId, surfaceParam);
1684 if (ret != ERR_OK) {
1685 HILOGE("SetSurfaceId failed.");
1686 CreateBusinessError(env, ERR_EXECUTE_FUNCTION);
1687 }
1688 return nullptr;
1689 }
1690
DestroyStream(napi_env env,napi_callback_info info)1691 napi_value JsAbilityConnectionManager::DestroyStream(napi_env env, napi_callback_info info)
1692 {
1693 HILOGI("called.");
1694 if (!IsSystemApp()) {
1695 HILOGE("Permission verification failed.");
1696 CreateBusinessError(env, ERR_IS_NOT_SYSTEM_APP);
1697 }
1698
1699 GET_PARAMS(env, info, ARG_COUNT_ONE);
1700 if (argc != ARG_COUNT_ONE) {
1701 HILOGE("CheckArgsCount failed.");
1702 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1703 return nullptr;
1704 }
1705
1706 int32_t streamId = -1;
1707 if (!JsToInt32(env, argv[ARG_INDEX_ZERO], "streamId", streamId)) {
1708 HILOGE("Parameter parsing failed.");
1709 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1710 return nullptr;
1711 }
1712
1713 int32_t ret = AbilityConnectionManager::GetInstance().DestroyStream(streamId);
1714 if (ret != ERR_OK) {
1715 HILOGE("DestroyStream failed.");
1716 CreateBusinessError(env, ERR_EXECUTE_FUNCTION);
1717 }
1718 return nullptr;
1719 }
1720
StartStream(napi_env env,napi_callback_info info)1721 napi_value JsAbilityConnectionManager::StartStream(napi_env env, napi_callback_info info)
1722 {
1723 HILOGI("called.");
1724 if (!IsSystemApp()) {
1725 HILOGE("Permission verification failed.");
1726 CreateBusinessError(env, ERR_IS_NOT_SYSTEM_APP);
1727 }
1728
1729 GET_PARAMS(env, info, ARG_COUNT_ONE);
1730 if (argc != ARG_COUNT_ONE) {
1731 HILOGE("CheckArgsCount failed.");
1732 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1733 return nullptr;
1734 }
1735
1736 int32_t streamId = -1;
1737 if (!JsToInt32(env, argv[ARG_INDEX_ZERO], "streamId", streamId)) {
1738 HILOGE("Parameter parsing failed.");
1739 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1740 return nullptr;
1741 }
1742
1743 int32_t ret = AbilityConnectionManager::GetInstance().StartStream(streamId);
1744 if (ret != ERR_OK) {
1745 HILOGE("StartStream failed.");
1746 CreateBusinessError(env, ret);
1747 }
1748 return nullptr;
1749 }
1750
StopStream(napi_env env,napi_callback_info info)1751 napi_value JsAbilityConnectionManager::StopStream(napi_env env, napi_callback_info info)
1752 {
1753 HILOGI("called.");
1754 if (!IsSystemApp()) {
1755 HILOGE("Permission verification failed.");
1756 CreateBusinessError(env, ERR_IS_NOT_SYSTEM_APP);
1757 }
1758
1759 GET_PARAMS(env, info, ARG_COUNT_ONE);
1760 if (argc != ARG_COUNT_ONE) {
1761 HILOGE("CheckArgsCount failed.");
1762 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1763 return nullptr;
1764 }
1765
1766 int32_t streamId = -1;
1767 if (!JsToInt32(env, argv[ARG_INDEX_ZERO], "streamId", streamId)) {
1768 HILOGE("Parameter parsing failed.");
1769 CreateBusinessError(env, ERR_INVALID_PARAMETERS);
1770 return nullptr;
1771 }
1772
1773 int32_t ret = AbilityConnectionManager::GetInstance().StopStream(streamId);
1774 if (ret != ERR_OK) {
1775 HILOGE("StopStream failed.");
1776 CreateBusinessError(env, ERR_EXECUTE_FUNCTION);
1777 }
1778 return nullptr;
1779 }
1780
InitConnectOptionParams(napi_env & env,napi_value & exports)1781 void InitConnectOptionParams(napi_env& env, napi_value& exports)
1782 {
1783 char propertyName[] = "ConnectOptionParams";
1784 napi_value startOptionKey = nullptr;
1785 napi_value startToForeground = nullptr;
1786 napi_value startTobackground = nullptr;
1787 napi_create_string_utf8(env, KEY_START_OPTION.c_str(), KEY_START_OPTION.size(), &startOptionKey);
1788 napi_create_string_utf8(env, VALUE_START_OPTION_FOREGROUND.c_str(),
1789 VALUE_START_OPTION_FOREGROUND.size(), &startToForeground);
1790 napi_create_string_utf8(env, VALUE_START_OPTION_BACKGROUND.c_str(),
1791 VALUE_START_OPTION_BACKGROUND.size(), &startTobackground);
1792
1793 napi_property_descriptor desc[] = {
1794 DECLARE_NAPI_STATIC_PROPERTY("KEY_START_OPTION", startOptionKey),
1795 DECLARE_NAPI_STATIC_PROPERTY("VALUE_START_OPTION_FOREGROUND", startToForeground),
1796 DECLARE_NAPI_STATIC_PROPERTY("VALUE_START_OPTION_BACKGROUND", startTobackground),
1797 };
1798 napi_value obj = nullptr;
1799 napi_create_object(env, &obj);
1800 napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
1801 napi_set_named_property(env, exports, propertyName, obj);
1802 }
1803
InitDisconnectReason(napi_env & env,napi_value & exports)1804 void InitDisconnectReason(napi_env& env, napi_value& exports)
1805 {
1806 char propertyName[] = "DisconnectReason";
1807 napi_value peerAppExit = nullptr;
1808 napi_value peerAppCloseCollab = nullptr;
1809 napi_value networkDisconnected = nullptr;
1810 napi_create_int32(env,
1811 static_cast<int32_t>(DisconnectReason::PEER_APP_CLOSE_COLLABORATION), &peerAppCloseCollab);
1812 napi_create_int32(env,
1813 static_cast<int32_t>(DisconnectReason::PEER_APP_EXIT), &peerAppExit);
1814 napi_create_int32(env,
1815 static_cast<int32_t>(DisconnectReason::NETWORK_DISCONNECTED), &networkDisconnected);
1816
1817 napi_property_descriptor desc[] = {
1818 DECLARE_NAPI_STATIC_PROPERTY("PEER_APP_CLOSE_COLLABORATION", peerAppCloseCollab),
1819 DECLARE_NAPI_STATIC_PROPERTY("PEER_APP_EXIT", peerAppExit),
1820 DECLARE_NAPI_STATIC_PROPERTY("NETWORK_DISCONNECTED", networkDisconnected),
1821 };
1822 napi_value obj = nullptr;
1823 napi_create_object(env, &obj);
1824 napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
1825 napi_set_named_property(env, exports, propertyName, obj);
1826 }
1827
InitFlipOptions(napi_env & env,napi_value & exports)1828 void InitFlipOptions(napi_env& env, napi_value& exports)
1829 {
1830 char propertyName[] = "FlipOptions";
1831 char propertyNameOld[] = "FlipOption";
1832 napi_value horizontal = nullptr;
1833 napi_value vertical = nullptr;
1834 napi_create_int32(env, static_cast<int32_t>(FlipOptions::HORIZONTAL), &horizontal);
1835 napi_create_int32(env, static_cast<int32_t>(FlipOptions::VERTICAL), &vertical);
1836
1837 napi_property_descriptor desc[] = {
1838 DECLARE_NAPI_STATIC_PROPERTY("HORIZONTAL", horizontal),
1839 DECLARE_NAPI_STATIC_PROPERTY("VERTICAL", vertical),
1840 };
1841 napi_value obj = nullptr;
1842 napi_create_object(env, &obj);
1843 napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
1844 napi_set_named_property(env, exports, propertyName, obj);
1845 napi_set_named_property(env, exports, propertyNameOld, obj);
1846 }
1847
InitStreamRole(napi_env & env,napi_value & exports)1848 void InitStreamRole(napi_env& env, napi_value& exports)
1849 {
1850 char propertyName[] = "StreamRole";
1851 napi_value source = nullptr;
1852 napi_value sink = nullptr;
1853 napi_create_int32(env, SOURCE, &source);
1854 napi_create_int32(env, SINK, &sink);
1855
1856 napi_property_descriptor desc[] = {
1857 DECLARE_NAPI_STATIC_PROPERTY("SOURCE", source),
1858 DECLARE_NAPI_STATIC_PROPERTY("SINK", sink),
1859 };
1860 napi_value obj = nullptr;
1861 napi_create_object(env, &obj);
1862 napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
1863 napi_set_named_property(env, exports, propertyName, obj);
1864 }
1865
InitVideoPixelFormat(napi_env & env,napi_value & exports)1866 void InitVideoPixelFormat(napi_env& env, napi_value& exports)
1867 {
1868 char propertyName[] = "VideoPixelFormat";
1869 napi_value unknown = nullptr;
1870 napi_value nv12 = nullptr;
1871 napi_value nv21 = nullptr;
1872 napi_create_int32(env, UNKNOWN, &unknown);
1873 napi_create_int32(env, NV12, &nv12);
1874 napi_create_int32(env, NV21, &nv21);
1875
1876 napi_property_descriptor desc[] = {
1877 DECLARE_NAPI_STATIC_PROPERTY("UNKNOWN", unknown),
1878 DECLARE_NAPI_STATIC_PROPERTY("NV12", nv12),
1879 DECLARE_NAPI_STATIC_PROPERTY("NV21", nv21),
1880 };
1881 napi_value obj = nullptr;
1882 napi_create_object(env, &obj);
1883 napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
1884 napi_set_named_property(env, exports, propertyName, obj);
1885 }
1886
InitStartOptionParams(napi_env & env,napi_value & exports)1887 void InitStartOptionParams(napi_env& env, napi_value& exports)
1888 {
1889 char propertyName[] = "StartOptionParams";
1890 napi_value startInForeground = nullptr;
1891 napi_value startInBackground = nullptr;
1892 napi_create_int32(env, static_cast<int32_t>(StartOptionParams::START_IN_FOREGROUND),
1893 &startInForeground);
1894 napi_create_int32(env, static_cast<int32_t>(StartOptionParams::START_IN_BACKGROUND),
1895 &startInBackground);
1896
1897 napi_property_descriptor desc[] = {
1898 DECLARE_NAPI_STATIC_PROPERTY("START_IN_FOREGROUND", startInForeground),
1899 DECLARE_NAPI_STATIC_PROPERTY("START_IN_BACKGROUND", startInBackground),
1900 };
1901 napi_value obj = nullptr;
1902 napi_create_object(env, &obj);
1903 napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
1904 napi_set_named_property(env, exports, propertyName, obj);
1905 }
1906
InitCollaborateEventType(napi_env & env,napi_value & exports)1907 void InitCollaborateEventType(napi_env& env, napi_value& exports)
1908 {
1909 char propertyName[] = "CollaborateEventType";
1910 napi_value sendFailure = nullptr;
1911 napi_value colorSpaceConversionFailure = nullptr;
1912 napi_create_int32(env, static_cast<int32_t>(CollaborateEventType::SEND_FAILURE),
1913 &sendFailure);
1914 napi_create_int32(env, static_cast<int32_t>(CollaborateEventType::COLOR_SPACE_CONVERSION_FAILURE),
1915 &colorSpaceConversionFailure);
1916
1917 napi_property_descriptor desc[] = {
1918 DECLARE_NAPI_STATIC_PROPERTY("SEND_FAILURE", sendFailure),
1919 DECLARE_NAPI_STATIC_PROPERTY("COLOR_SPACE_CONVERSION_FAILURE", colorSpaceConversionFailure),
1920 };
1921 napi_value obj = nullptr;
1922 napi_create_object(env, &obj);
1923 napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
1924 napi_set_named_property(env, exports, propertyName, obj);
1925 }
1926
InitConnectErrorCode(napi_env env,napi_value exports)1927 void InitConnectErrorCode(napi_env env, napi_value exports)
1928 {
1929 char propertyName[] = "ConnectErrorCode";
1930 napi_value connectedSessionExists = nullptr;
1931 napi_value peerAppRejected = nullptr;
1932 napi_value localWifiNotOpen = nullptr;
1933 napi_value peerWifiNotOpen = nullptr;
1934 napi_value peerAbilityNoOncollaborate = nullptr;
1935 napi_value systemInternalError = nullptr;
1936
1937 napi_create_int32(env,
1938 static_cast<int32_t>(ConnectErrorCode::CONNECTED_SESSION_EXISTS), &connectedSessionExists);
1939 napi_create_int32(env,
1940 static_cast<int32_t>(ConnectErrorCode::PEER_APP_REJECTED), &peerAppRejected);
1941 napi_create_int32(env,
1942 static_cast<int32_t>(ConnectErrorCode::LOCAL_WIFI_NOT_OPEN), &localWifiNotOpen);
1943 napi_create_int32(env,
1944 static_cast<int32_t>(ConnectErrorCode::PEER_WIFI_NOT_OPEN), &peerWifiNotOpen);
1945 napi_create_int32(env,
1946 static_cast<int32_t>(ConnectErrorCode::PEER_ABILITY_NO_ONCOLLABORATE), &peerAbilityNoOncollaborate);
1947 napi_create_int32(env,
1948 static_cast<int32_t>(ConnectErrorCode::SYSTEM_INTERNAL_ERROR), &systemInternalError);
1949
1950 napi_property_descriptor desc[] = {
1951 DECLARE_NAPI_STATIC_PROPERTY("CONNECTED_SESSION_EXISTS", connectedSessionExists),
1952 DECLARE_NAPI_STATIC_PROPERTY("PEER_APP_REJECTED", peerAppRejected),
1953 DECLARE_NAPI_STATIC_PROPERTY("LOCAL_WIFI_NOT_OPEN", localWifiNotOpen),
1954 DECLARE_NAPI_STATIC_PROPERTY("PEER_WIFI_NOT_OPEN", peerWifiNotOpen),
1955 DECLARE_NAPI_STATIC_PROPERTY("PEER_ABILITY_NO_ONCOLLABORATE", peerAbilityNoOncollaborate),
1956 DECLARE_NAPI_STATIC_PROPERTY("SYSTEM_INTERNAL_ERROR", systemInternalError),
1957 };
1958
1959 napi_value obj = nullptr;
1960 napi_create_object(env, &obj);
1961 napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
1962 napi_set_named_property(env, exports, propertyName, obj);
1963 }
1964
InitCollaborationKeys(napi_env & env,napi_value & exports)1965 void InitCollaborationKeys(napi_env& env, napi_value& exports)
1966 {
1967 char propertyName[] = "CollaborationKeys";
1968 napi_value peerInfo = nullptr;
1969 napi_value connectOptions = nullptr;
1970 napi_value collaborateType = nullptr;
1971
1972 napi_create_string_utf8(env, COLLABORATE_KEYS_PEER_INFO.c_str(),
1973 COLLABORATE_KEYS_PEER_INFO.size(), &peerInfo);
1974 napi_create_string_utf8(env, COLLABORATE_KEYS_CONNECT_OPTIONS.c_str(),
1975 COLLABORATE_KEYS_CONNECT_OPTIONS.size(), &connectOptions);
1976 napi_create_string_utf8(env, COLLABORATE_KEYS_COLLABORATE_TYPE.c_str(),
1977 COLLABORATE_KEYS_COLLABORATE_TYPE.size(), &collaborateType);
1978
1979 napi_property_descriptor desc[] = {
1980 DECLARE_NAPI_STATIC_PROPERTY("PEER_INFO", peerInfo),
1981 DECLARE_NAPI_STATIC_PROPERTY("CONNECT_OPTIONS", connectOptions),
1982 DECLARE_NAPI_STATIC_PROPERTY("COLLABORATE_TYPE", collaborateType),
1983 };
1984 napi_value obj = nullptr;
1985 napi_create_object(env, &obj);
1986 napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
1987 napi_set_named_property(env, exports, propertyName, obj);
1988 }
1989
InitCollaborationValues(napi_env & env,napi_value & exports)1990 void InitCollaborationValues(napi_env& env, napi_value& exports)
1991 {
1992 char propertyName[] = "CollaborationValues";
1993 napi_value abilityCollab = nullptr;
1994 napi_value connectProxy = nullptr;
1995
1996 napi_create_string_utf8(env, ABILITY_COLLABORATION_TYPE_DEFAULT.c_str(),
1997 ABILITY_COLLABORATION_TYPE_DEFAULT.size(), &abilityCollab);
1998 napi_create_string_utf8(env, ABILITY_COLLABORATION_TYPE_CONNECT_PROXY.c_str(),
1999 ABILITY_COLLABORATION_TYPE_CONNECT_PROXY.size(), &connectProxy);
2000
2001 napi_property_descriptor desc[] = {
2002 DECLARE_NAPI_STATIC_PROPERTY("ABILITY_COLLABORATION_TYPE_DEFAULT", abilityCollab),
2003 DECLARE_NAPI_STATIC_PROPERTY("ABILITY_COLLABORATION_TYPE_CONNECT_PROXY", connectProxy),
2004 };
2005 napi_value obj = nullptr;
2006 napi_create_object(env, &obj);
2007 napi_define_properties(env, obj, sizeof(desc) / sizeof(desc[0]), desc);
2008 napi_set_named_property(env, exports, propertyName, obj);
2009 }
2010
InitFunction(napi_env env,napi_value exports)2011 void InitFunction(napi_env env, napi_value exports)
2012 {
2013 static napi_property_descriptor desc[] = {
2014 DECLARE_NAPI_FUNCTION("createAbilityConnectionSession",
2015 JsAbilityConnectionManager::CreateAbilityConnectionSession),
2016 DECLARE_NAPI_FUNCTION("destroyAbilityConnectionSession",
2017 JsAbilityConnectionManager::DestroyAbilityConnectionSession),
2018 DECLARE_NAPI_FUNCTION("getPeerInfoById", JsAbilityConnectionManager::GetPeerInfoById),
2019 DECLARE_NAPI_FUNCTION("on", JsAbilityConnectionManager::RegisterAbilityConnectionSessionCallback),
2020 DECLARE_NAPI_FUNCTION("off", JsAbilityConnectionManager::UnregisterAbilityConnectionSessionCallback),
2021 DECLARE_NAPI_FUNCTION("connect", JsAbilityConnectionManager::Connect),
2022 DECLARE_NAPI_FUNCTION("disconnect", JsAbilityConnectionManager::DisConnect),
2023 DECLARE_NAPI_FUNCTION("acceptConnect", JsAbilityConnectionManager::AcceptConnect),
2024 DECLARE_NAPI_FUNCTION("reject", JsAbilityConnectionManager::Reject),
2025 DECLARE_NAPI_FUNCTION("sendMessage", JsAbilityConnectionManager::SendMessage),
2026 DECLARE_NAPI_FUNCTION("sendData", JsAbilityConnectionManager::SendData),
2027 DECLARE_NAPI_FUNCTION("sendImage", JsAbilityConnectionManager::SendImage),
2028 DECLARE_NAPI_FUNCTION("createStream", JsAbilityConnectionManager::CreateStream),
2029 DECLARE_NAPI_FUNCTION("setSurfaceId", JsAbilityConnectionManager::SetSurfaceId),
2030 DECLARE_NAPI_FUNCTION("getSurfaceId", JsAbilityConnectionManager::GetSurfaceId),
2031 DECLARE_NAPI_FUNCTION("updateSurfaceParam", JsAbilityConnectionManager::UpdateSurfaceParam),
2032 DECLARE_NAPI_FUNCTION("destroyStream", JsAbilityConnectionManager::DestroyStream),
2033 DECLARE_NAPI_FUNCTION("startStream", JsAbilityConnectionManager::StartStream),
2034 DECLARE_NAPI_FUNCTION("stopStream", JsAbilityConnectionManager::StopStream),
2035 };
2036 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
2037 }
2038
JsAbilityConnectionManagerInit(napi_env env,napi_value exports)2039 napi_value JsAbilityConnectionManagerInit(napi_env env, napi_value exports)
2040 {
2041 HILOGD("called.");
2042 if (env == nullptr || exports == nullptr) {
2043 HILOGE("Invalid input parameters");
2044 return nullptr;
2045 }
2046 InitConnectOptionParams(env, exports);
2047 InitDisconnectReason(env, exports);
2048 InitFlipOptions(env, exports);
2049 InitStreamRole(env, exports);
2050 InitVideoPixelFormat(env, exports);
2051 InitStartOptionParams(env, exports);
2052 InitCollaborateEventType(env, exports);
2053 InitConnectErrorCode(env, exports);
2054 InitCollaborationKeys(env, exports);
2055 InitCollaborationValues(env, exports);
2056 InitFunction(env, exports);
2057
2058 HILOGI("napi_define_properties end");
2059 return exports;
2060 }
2061 } // namespace DistributedCollab
2062 } // namespace OHOS