xref: /foundation/ability/dmsfwk/interfaces/kits/napi/continuation_manager/js_device_selection_listener.cpp

/*
 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "js_device_selection_listener.h"

#include "base/continuationmgr_log.h"
#include "js_runtime_utils.h"
#include "napi_common_util.h"

namespace OHOS {
namespace DistributedSchedule {
using namespace OHOS::AbilityRuntime;
namespace {
const std::string TAG = "JsDeviceSelectionListener";
}

void JsDeviceSelectionListener::OnDeviceConnect(const std::vector<ContinuationResult>& continuationResults)
{
    HILOGD("called.");
    CallJsMethod(EVENT_CONNECT, continuationResults);
}

void JsDeviceSelectionListener::OnDeviceDisconnect(const std::vector<ContinuationResult>& continuationResults)
{
    HILOGD("called.");
    CallJsMethod(EVENT_DISCONNECT, continuationResults);
}

void JsDeviceSelectionListener::AddCallback(const std::string& cbType, napi_value jsListenerObj)
{
    HILOGD("called.");
    napi_ref tempRef = nullptr;
    std::unique_ptr<NativeReference> callbackRef;
    if (engine_ == nullptr) {
        HILOGE("engine_ is nullptr");
        return;
    }
    napi_create_reference(engine_, jsListenerObj, 1, &tempRef);
    callbackRef.reset(reinterpret_cast<NativeReference *>(tempRef));
    std::lock_guard<std::mutex> jsCallBackMapLock(jsCallBackMapMutex_);
    jsCallBackMap_[cbType] = std::move(callbackRef);
    HILOGD("jsCallBackMap_ cbType: %{public}s, size: %{public}u!",
        cbType.c_str(), static_cast<uint32_t>(jsCallBackMap_.size()));
}

void JsDeviceSelectionListener::RemoveCallback(const std::string& cbType)
{
    HILOGD("called.");
    std::lock_guard<std::mutex> jsCallBackMapLock(jsCallBackMapMutex_);
    jsCallBackMap_.erase(cbType);
    HILOGD("jsCallBackMap_ cbType: %{public}s, size: %{public}u!",
        cbType.c_str(), static_cast<uint32_t>(jsCallBackMap_.size()));
}

void JsDeviceSelectionListener::CallJsMethod(const std::string& methodName,
    const std::vector<ContinuationResult>& continuationResults)
{
    HILOGD("methodName = %{public}s", methodName.c_str());
    if (engine_ == nullptr) {
        HILOGE("engine_ is nullptr");
        return;
    }
    // js callback should run in js thread
    auto task = [this, methodName, continuationResults] {
        napi_handle_scope scope = nullptr;
        napi_open_handle_scope(this->engine_, &scope);
        if (scope == nullptr) {
            return;
        }

        CallJsMethodInner(methodName, continuationResults);

        napi_close_handle_scope(this->engine_, scope);
    };
    if (napi_status::napi_ok != napi_send_event(engine_, task, napi_eprio_high)) {
        HILOGE("send event failed!");
    }
}

void JsDeviceSelectionListener::CallJsMethodInner(const std::string& methodName,
    const std::vector<ContinuationResult>& continuationResults)
{
    std::lock_guard<std::mutex> jsCallBackMapLock(jsCallBackMapMutex_);
    auto it = jsCallBackMap_.find(methodName);
    if (it == jsCallBackMap_.end()) {
        HILOGE("Callback method %s not found in jsCallBackMap_", methodName.c_str());
        return;
    }
    napi_value method = jsCallBackMap_[methodName]->GetNapiValue();
    if (method == nullptr) {
        HILOGE("Failed to get %{public}s from object", methodName.c_str());
        return;
    }
    napi_value argv[] = { WrapContinuationResultArray(engine_, continuationResults) };
    napi_call_function(engine_, CreateJsUndefined(engine_), method, ArraySize(argv), argv, nullptr);
}

void JsDeviceSelectionListener::CallJsMethod(const std::string& methodName, const std::vector<std::string>& deviceIds)
{
    HILOGD("methodName = %{public}s", methodName.c_str());
    if (engine_ == nullptr) {
        HILOGE("engine_ is nullptr");
        return;
    }
    // js callback should run in js thread
    auto task = [this, methodName, deviceIds]() {
        napi_handle_scope scope = nullptr;
        napi_open_handle_scope(this->engine_, &scope);
        if (scope == nullptr) {
            return;
        }
        CallJsMethodInner(methodName, deviceIds);

        napi_close_handle_scope(this->engine_, scope);
    };
    if (napi_status::napi_ok != napi_send_event(engine_, task, napi_eprio_high)) {
        HILOGE("send event failed!");
    }
}

void JsDeviceSelectionListener::CallJsMethodInner(const std::string& methodName,
    const std::vector<std::string>& deviceIds)
{
    std::lock_guard<std::mutex> jsCallBackMapLock(jsCallBackMapMutex_);
    auto it = jsCallBackMap_.find(methodName);
    if (it == jsCallBackMap_.end()) {
        HILOGE("Callback method %s not found in jsCallBackMap_", methodName.c_str());
        return;
    }
    napi_value method = jsCallBackMap_[methodName]->GetNapiValue();
    if (method == nullptr) {
        HILOGE("Failed to get %{public}s from object", methodName.c_str());
        return;
    }
    napi_value argv[] = { WrapDeviceIdArray(engine_, deviceIds) };
    napi_call_function(engine_, CreateJsUndefined(engine_), method, ArraySize(argv), argv, nullptr);
}

napi_value JsDeviceSelectionListener::WrapContinuationResult(napi_env env,
    const ContinuationResult& continuationResult)
{
    napi_value objValue;
    napi_create_object(env, &objValue);
    SetKeyValue(env, objValue, "id", continuationResult.GetDeviceId());
    SetKeyValue(env, objValue, "type", continuationResult.GetDeviceType());
    SetKeyValue(env, objValue, "name", continuationResult.GetDeviceName());
    return objValue;
}

napi_value JsDeviceSelectionListener::WrapContinuationResultArray(napi_env env,
    const std::vector<ContinuationResult>& continuationResults)
{
    napi_value arrayValue;
    napi_create_array_with_length(env, continuationResults.size(), &arrayValue);
    uint32_t index = 0;
    for (const auto& continuationResult : continuationResults) {
        napi_set_element(env,
            arrayValue, index++, WrapContinuationResult(env, continuationResult));
    }
    return arrayValue;
}

napi_value JsDeviceSelectionListener::WrapDeviceIdArray(napi_env env,
    const std::vector<std::string>& deviceIds)
{
    napi_value arrayValue;
    napi_create_array_with_length(env, deviceIds.size(), &arrayValue);
    uint32_t index = 0;
    for (const auto& deviceId : deviceIds) {
        napi_set_element(env, arrayValue, index++, CreateJsValue(env, deviceId));
    }
    return arrayValue;
}

void JsDeviceSelectionListener::SetKeyValue(napi_env env,
    const napi_value object, const std::string &strKey, const std::string &strValue) const
{
    napi_value attrValue = nullptr;
    napi_create_string_utf8(env, strValue.c_str(), NAPI_AUTO_LENGTH, &attrValue);
    napi_set_named_property(env, object, strKey.c_str(), attrValue);
}
}  // namespace DistributedSchedule
}  // namespace OHOS