/*
 * Copyright (c) 2022-2025 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 <cstdio>

#include "napi_avsession.h"
#include "avsession_controller.h"
#include "napi_utils.h"
#include "napi_avcall_meta_data.h"
#include "napi_avcall_state.h"
#include "napi_meta_data.h"
#include "napi_playback_state.h"
#include "napi_media_description.h"
#include "napi_queue_item.h"
#include "want_params.h"
#include "want_agent.h"
#include "avsession_trace.h"
#include "napi_avsession_controller.h"
#include "napi_avsession_manager.h"
#include "curl/curl.h"
#include "image_source.h"
#include "pixel_map.h"
#include "avsession_pixel_map_adapter.h"

#ifdef CASTPLUS_CAST_ENGINE_ENABLE
#include "avcast_controller.h"
#include "napi_avcast_controller.h"
#endif
namespace OHOS::AVSession {

static __thread napi_ref AVSessionConstructorRef = nullptr;
std::map<std::string, NapiAVSession::OnEventHandlerType> NapiAVSession::onEventHandlers_ = {
    { "play", OnPlay },
    { "pause", OnPause },
    { "stop", OnStop },
    { "playNext", OnPlayNext },
    { "playPrevious", OnPlayPrevious },
    { "fastForward", OnFastForward },
    { "rewind", OnRewind },
    { "seek", OnSeek },
    { "setSpeed", OnSetSpeed },
    { "setLoopMode", OnSetLoopMode },
    { "setTargetLoopMode", OnSetTargetLoopMode },
    { "toggleFavorite", OnToggleFavorite },
    { "handleKeyEvent", OnMediaKeyEvent },
    { "outputDeviceChange", OnOutputDeviceChange },
    { "commonCommand", OnCommonCommand },
    { "skipToQueueItem", OnSkipToQueueItem },
    { "answer", OnAVCallAnswer },
    { "hangUp", OnAVCallHangUp },
    { "toggleCallMute", OnAVCallToggleCallMute },
    { "playFromAssetId", OnPlayFromAssetId },
    { "playWithAssetId", OnPlayWithAssetId },
    { "castDisplayChange", OnCastDisplayChange },
    { "castDisplaySizeChange", OnCastDisplaySizeChange },
    { "customDataChange", OnCustomData },
};
std::map<std::string, NapiAVSession::OffEventHandlerType> NapiAVSession::offEventHandlers_ = {
    { "play", OffPlay },
    { "pause", OffPause },
    { "stop", OffStop },
    { "playNext", OffPlayNext },
    { "playPrevious", OffPlayPrevious },
    { "fastForward", OffFastForward },
    { "rewind", OffRewind },
    { "seek", OffSeek },
    { "setSpeed", OffSetSpeed },
    { "setLoopMode", OffSetLoopMode },
    { "setTargetLoopMode", OffSetTargetLoopMode },
    { "toggleFavorite", OffToggleFavorite },
    { "handleKeyEvent", OffMediaKeyEvent },
    { "outputDeviceChange", OffOutputDeviceChange },
    { "commonCommand", OffCommonCommand },
    { "skipToQueueItem", OffSkipToQueueItem },
    { "answer", OffAVCallAnswer },
    { "hangUp", OffAVCallHangUp },
    { "toggleCallMute", OffAVCallToggleCallMute },
    { "playFromAssetId", OffPlayFromAssetId },
    { "playWithAssetId", OffPlayWithAssetId },
    { "castDisplayChange", OffCastDisplayChange },
    { "customDataChange", OffCustomData },
};
std::list<int32_t> registerEventList_;
std::map<std::string, int32_t> convertEventType_ = {
    { "play", AVControlCommand::SESSION_CMD_PLAY },
    { "pause", AVControlCommand::SESSION_CMD_PAUSE },
    { "stop", AVControlCommand::SESSION_CMD_STOP },
    { "playNext", AVControlCommand::SESSION_CMD_PLAY_NEXT },
    { "playPrevious", AVControlCommand::SESSION_CMD_PLAY_PREVIOUS },
    { "fastForward", AVControlCommand::SESSION_CMD_FAST_FORWARD },
    { "rewind", AVControlCommand::SESSION_CMD_REWIND },
    { "seek", AVControlCommand::SESSION_CMD_SEEK },
    { "setSpeed", AVControlCommand::SESSION_CMD_SET_SPEED },
    { "setLoopMode", AVControlCommand::SESSION_CMD_SET_LOOP_MODE },
    { "toggleFavorite", AVControlCommand::SESSION_CMD_TOGGLE_FAVORITE },
    { "handleKeyEvent", AVControlCommand::SESSION_CMD_MEDIA_KEY_SUPPORT },
    { "playFromAssetId", AVControlCommand::SESSION_CMD_PLAY_FROM_ASSETID },
    { "playWithAssetId", AVControlCommand::SESSION_CMD_PLAY_WITH_ASSETID }
};

std::mutex NapiAVSession::lock_;
std::mutex NapiAVSession::syncMutex_;
std::mutex NapiAVSession::syncAsyncMutex_;
std::condition_variable NapiAVSession::syncCond_;
std::condition_variable NapiAVSession::syncAsyncCond_;
std::recursive_mutex registerEventLock_;
int32_t NapiAVSession::playBackStateRet_ = AVSESSION_ERROR;
std::shared_ptr<NapiAVSession> NapiAVSession::napiAVSession_ = nullptr;
std::recursive_mutex NapiAVSession::destroyLock_;
bool NapiAVSession::isNapiSessionDestroy_ = false;

NapiAVSession::NapiAVSession()
{
    SLOGI("construct");
}

NapiAVSession::~NapiAVSession()
{
    SLOGI("destroy");
    AVSessionManager::GetInstance().UnregisterServiceStartCallback();
    std::lock_guard lockGuard(registerEventLock_);
    registerEventList_.clear();
}

napi_value NapiAVSession::Init(napi_env env, napi_value exports)
{
    napi_property_descriptor descriptors[] = {
        DECLARE_NAPI_FUNCTION("setAVMetadata", SetAVMetaData),
        DECLARE_NAPI_FUNCTION("setCallMetadata", SetAVCallMetaData),
        DECLARE_NAPI_FUNCTION("setAVPlaybackState", SetAVPlaybackState),
        DECLARE_NAPI_FUNCTION("setAVCallState", SetAVCallState),
        DECLARE_NAPI_FUNCTION("setLaunchAbility", SetLaunchAbility),
        DECLARE_NAPI_FUNCTION("setExtras", SetExtras),
        DECLARE_NAPI_FUNCTION("setAudioStreamId", SetAudioStreamId),
        DECLARE_NAPI_FUNCTION("getController", GetController),
        DECLARE_NAPI_FUNCTION("activate", Activate),
        DECLARE_NAPI_FUNCTION("deactivate", Deactivate),
        DECLARE_NAPI_FUNCTION("destroy", Destroy),
        DECLARE_NAPI_FUNCTION("on", OnEvent),
        DECLARE_NAPI_FUNCTION("off", OffEvent),
        DECLARE_NAPI_FUNCTION("getOutputDevice", GetOutputDevice),
        DECLARE_NAPI_FUNCTION("getOutputDeviceSync", GetOutputDeviceSync),
        DECLARE_NAPI_FUNCTION("dispatchSessionEvent", SetSessionEvent),
        DECLARE_NAPI_FUNCTION("setAVQueueItems", SetAVQueueItems),
        DECLARE_NAPI_FUNCTION("setAVQueueTitle", SetAVQueueTitle),
        DECLARE_NAPI_FUNCTION("sendCustomData", SendCustomData),
        DECLARE_NAPI_FUNCTION("getAVCastController", GetAVCastController),
        DECLARE_NAPI_FUNCTION("stopCasting", ReleaseCast),
        DECLARE_NAPI_FUNCTION("getAllCastDisplays", GetAllCastDisplays),
    };
    auto propertyCount = sizeof(descriptors) / sizeof(napi_property_descriptor);
    napi_value constructor {};
    auto status = napi_define_class(env, "AVSession", NAPI_AUTO_LENGTH, ConstructorCallback, nullptr,
                                    propertyCount, descriptors, &constructor);
    if (status != napi_ok) {
        SLOGE("define class failed");
        return NapiUtils::GetUndefinedValue(env);
    }
    napi_create_reference(env, constructor, 1, &AVSessionConstructorRef);
    return exports;
}

napi_value NapiAVSession::ConstructorCallback(napi_env env, napi_callback_info info)
{
    napi_value self;
    NAPI_CALL_BASE(env, napi_get_cb_info(env, info, nullptr, nullptr, &self, nullptr), nullptr);
    auto finalize = [](napi_env env, void* data, void* hint) {
        auto* napiSession = reinterpret_cast<NapiAVSession*>(data);
        napi_delete_reference(env, napiSession->wrapperRef_);
        delete napiSession;
        napiSession = nullptr;
    };
    auto* napiSession = new(std::nothrow) NapiAVSession();
    if (napiSession == nullptr) {
        SLOGE("no memory");
        return nullptr;
    }
    if (napi_wrap(env, self, static_cast<void*>(napiSession), finalize, nullptr, nullptr) != napi_ok) {
        SLOGE("wrap failed");
        delete napiSession;
        napiSession = nullptr;
        return nullptr;
    }
    return self;
}

napi_status NapiAVSession::ReCreateInstance()
{
    if (napiAVSession_ == nullptr) {
        SLOGE("napiAVSession is null");
        return napi_generic_failure;
    }
    {
        std::lock_guard lockGuard(destroyLock_);
        if (isNapiSessionDestroy_) {
            SLOGE("isNapiSessionDestroy_=%{public}d", isNapiSessionDestroy_);
            return napi_generic_failure;
        }
    }
    SLOGI("sessionId=%{public}s***", napiAVSession_->sessionId_.substr(0, UNMASK_CHAR_NUM).c_str());
    std::shared_ptr<AVSession> nativeSession;
    int32_t ret = AVSessionManager::GetInstance().CreateSession(napiAVSession_->sessionTag_,
        NapiUtils::ConvertSessionType(napiAVSession_->sessionType_), napiAVSession_->elementName_, nativeSession);
    CHECK_RETURN(ret == AVSESSION_SUCCESS, "create native session fail", napi_generic_failure);
    napiAVSession_->session_ = std::move(nativeSession);
    napiAVSession_->sessionId_ = napiAVSession_->session_->GetSessionId();
    napiAVSession_->sessionType_ = napiAVSession_->session_->GetSessionType();
    if (napiAVSession_->callback_ == nullptr) {
        napiAVSession_->callback_ = std::make_shared<NapiAVSessionCallback>();
    }
    int32_t res = napiAVSession_->session_->RegisterCallback(napiAVSession_->callback_);
    CHECK_RETURN(res == AVSESSION_SUCCESS, "register session callback fail", napi_generic_failure);
    {
        std::lock_guard lockGuard(registerEventLock_);
        for (int32_t event : registerEventList_) {
            int32_t result = napiAVSession_->session_->AddSupportCommand(event);
            if (result != AVSESSION_SUCCESS) {
                SLOGE("AddSupportCommand fail, ret=%{public}d", res);
                continue;
            }
        }
    }
    napiAVSession_->session_->Activate();
    return napi_ok;
}

napi_status NapiAVSession::NewInstance(napi_env env, std::shared_ptr<AVSession>& nativeSession, napi_value& out,
    std::string tag, AppExecFwk::ElementName elementName)
{
    napi_value constructor {};
    NAPI_CALL_BASE(env, napi_get_reference_value(env, AVSessionConstructorRef, &constructor), napi_generic_failure);
    napi_value instance{};
    NAPI_CALL_BASE(env, napi_new_instance(env, constructor, 0, nullptr, &instance), napi_generic_failure);
    napiAVSession_ = std::make_shared<NapiAVSession>();
    NAPI_CALL_BASE(env, napi_unwrap(env, instance, reinterpret_cast<void**>(&napiAVSession_)), napi_generic_failure);
    napiAVSession_->session_ = std::move(nativeSession);
    napiAVSession_->sessionId_ = napiAVSession_->session_->GetSessionId();
    napiAVSession_->sessionType_ = napiAVSession_->session_->GetSessionType();
    napiAVSession_->sessionTag_ = tag;
    napiAVSession_->elementName_ = elementName;
    SLOGI("sessionId=%{public}s***, sessionType:%{public}s",
        napiAVSession_->sessionId_.substr(0, UNMASK_CHAR_NUM).c_str(),
        napiAVSession_->sessionType_.c_str());

    napi_value property {};
    auto status = NapiUtils::SetValue(env, napiAVSession_->sessionId_, property);
    CHECK_RETURN(status == napi_ok, "create object failed", napi_generic_failure);
    NAPI_CALL_BASE(env, napi_set_named_property(env, instance, "sessionId", property), napi_generic_failure);

    status = NapiUtils::SetValue(env, napiAVSession_->sessionType_, property);
    CHECK_RETURN(status == napi_ok, "create object failed", napi_generic_failure);
    NAPI_CALL_BASE(env, napi_set_named_property(env, instance, "sessionType", property), napi_generic_failure);
    out = instance;
    return napi_ok;
}

void AddRegisterEvent(std::string eventName)
{
    std::lock_guard lockGuard(registerEventLock_);
    if (convertEventType_.find(eventName) == convertEventType_.end()) {
        SLOGE("eventName is invalid: eventName = %{public}s",  eventName.c_str());
        return;
    }
    registerEventList_.push_back(convertEventType_[eventName]);
}

void RemoveRegisterEvent(std::string eventName)
{
    std::lock_guard lockGuard(registerEventLock_);
    if (convertEventType_.find(eventName) == convertEventType_.end()) {
        SLOGE("eventName is invalid: eventName = %{public}s",  eventName.c_str());
        return;
    }
    registerEventList_.remove(convertEventType_[eventName]);
}

napi_value NapiAVSession::OnEvent(napi_env env, napi_callback_info info)
{
    auto context = std::make_shared<ContextBase>();
    if (context == nullptr) {
        SLOGE("OnEvent failed : no memory");
        return ThrowErrorAndReturn(env, "OnEvent failed : no memory", ERR_NO_MEMORY);
    }
    std::string eventName;
    napi_value callback {};
    auto input = [&eventName, &callback, env, &context](size_t argc, napi_value* argv) {
        CHECK_ARGS_RETURN_VOID(context, argc == ARGC_TWO, "invalid argument number",
            NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
        context->status = NapiUtils::GetValue(env, argv[ARGV_FIRST], eventName);
        CHECK_STATUS_RETURN_VOID(context, "get event name failed", NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
        napi_valuetype type = napi_undefined;
        context->status = napi_typeof(env, argv[ARGV_SECOND], &type);
        CHECK_ARGS_RETURN_VOID(context, (context->status == napi_ok) && (type == napi_function),
                               "callback type invalid", NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
        callback = argv[ARGV_SECOND];
    };
    context->GetCbInfo(env, info, input, true);
    if (context->status != napi_ok) {
        NapiUtils::ThrowError(env, context->errMessage.c_str(), context->errCode);
        return NapiUtils::GetUndefinedValue(env);
    }
    auto it = onEventHandlers_.find(eventName);
    if (it == onEventHandlers_.end()) {
        SLOGE("event name invalid");
        return ThrowErrorAndReturn(env, "event name invalid", ERR_INVALID_PARAM);
    }
    auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
    if (napiSession->session_ == nullptr) {
        SLOGE("OnEvent failed : session is nullptr");
        return ThrowErrorAndReturn(env, "OnEvent failed : session is nullptr", ERR_SESSION_NOT_EXIST);
    }
    if (napiSession->callback_ == nullptr) {
        napiSession->callback_ = std::make_shared<NapiAVSessionCallback>();
        if (napiSession->callback_ == nullptr) {
            return ThrowErrorAndReturn(env, "OnEvent failed : no memory", ERR_NO_MEMORY);
        }
        int32_t ret = napiSession->session_->RegisterCallback(napiSession->callback_);
        if (ret != AVSESSION_SUCCESS) {
            return ThrowErrorAndReturnByErrCode(env, "OnEvent", ret);
        }
    }
    if (it->second(env, napiSession, callback) != napi_ok) {
        NapiUtils::ThrowError(env, "add event callback failed", NapiAVSessionManager::errcode_[AVSESSION_ERROR]);
    }
    AddRegisterEvent(eventName);
    return NapiUtils::GetUndefinedValue(env);
}

napi_value NapiAVSession::ThrowErrorAndReturn(napi_env env, const std::string& message, int32_t errCode)
{
    std::string tempMessage = message;
    NapiUtils::ThrowError(env, tempMessage.c_str(), NapiAVSessionManager::errcode_[errCode]);
    return NapiUtils::GetUndefinedValue(env);
}

napi_value NapiAVSession::ThrowErrorAndReturnByErrCode(napi_env env, const std::string& message, int32_t errCode)
{
    std::string tempMessage = message;
    if (errCode == ERR_SESSION_NOT_EXIST) {
        tempMessage.append(" failed : native session not exist");
    } else if (errCode == ERR_INVALID_PARAM) {
        tempMessage.append(" failed : native invalid parameters");
    } else if (errCode == ERR_NO_PERMISSION) {
        tempMessage.append(" failed : native no permission");
    } else {
        tempMessage.append(" failed : native server exception");
    }
    SLOGI("throw error message: %{public}s", tempMessage.c_str());
    NapiUtils::ThrowError(env, tempMessage.c_str(), NapiAVSessionManager::errcode_[errCode]);
    return NapiUtils::GetUndefinedValue(env);
}

napi_value NapiAVSession::OffEvent(napi_env env, napi_callback_info info)
{
    auto context = std::make_shared<ContextBase>();
    if (context == nullptr) {
        SLOGE("OffEvent failed : no memory");
        NapiUtils::ThrowError(env, "OffEvent failed : no memory", NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
        return NapiUtils::GetUndefinedValue(env);
    }
    std::string eventName;
    napi_value callback = nullptr;
    auto input = [&eventName, env, &context, &callback](size_t argc, napi_value* argv) {
        CHECK_ARGS_RETURN_VOID(context, argc == ARGC_ONE || argc == ARGC_TWO,
                               "invalid argument number", NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
        context->status = NapiUtils::GetValue(env, argv[ARGV_FIRST], eventName);
        CHECK_STATUS_RETURN_VOID(context, "get event name failed", NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
        if (argc == ARGC_TWO) {
            callback = argv[ARGV_SECOND];
        }
    };
    context->GetCbInfo(env, info, input, true);
    if (context->status != napi_ok) {
        NapiUtils::ThrowError(env, context->errMessage.c_str(), context->errCode);
        return NapiUtils::GetUndefinedValue(env);
    }
    auto it = offEventHandlers_.find(eventName);
    if (it == offEventHandlers_.end()) {
        SLOGE("event name invalid");
        NapiUtils::ThrowError(env, "event name invalid", NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
        return NapiUtils::GetUndefinedValue(env);
    }
    auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
    if (napiSession == nullptr) {
        SLOGE("OffEvent failed : napiSession is nullptr");
        NapiUtils::ThrowError(env, "OffEvent failed : napiSession is nullptr",
            NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST]);
        return NapiUtils::GetUndefinedValue(env);
    }
    if (napiSession->session_ == nullptr) {
        SLOGE("OffEvent failed : session is nullptr");
        NapiUtils::ThrowError(env, "OffEvent failed : session is nullptr",
            NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST]);
        return NapiUtils::GetUndefinedValue(env);
    }
    if (napiSession != nullptr && it->second(env, napiSession, callback) != napi_ok) {
        NapiUtils::ThrowError(env, "remove event callback failed", NapiAVSessionManager::errcode_[AVSESSION_ERROR]);
    }
    RemoveRegisterEvent(eventName);
    return NapiUtils::GetUndefinedValue(env);
}

napi_value NapiAVSession::SetAVCallMetaData(napi_env env, napi_callback_info info)
{
    AVSESSION_TRACE_SYNC_START("NapiAVSession::SetAVCallMetadata");
    struct ConcreteContext : public ContextBase {
        AVCallMetaData avCallMetaData;
    };
    auto context = std::make_shared<ConcreteContext>();
    if (context == nullptr) {
        SLOGE("SetAVCallMetaData failed : no memory");
        NapiUtils::ThrowError(env, "SetAVCallMetaData failed : no memory",
            NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
        return NapiUtils::GetUndefinedValue(env);
    }

    auto inputParser = [env, context](size_t argc, napi_value* argv) {
        CHECK_ARGS_RETURN_VOID(context, argc == ARGC_ONE, "invalid arguments",
            NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
        context->status = NapiAVCallMetaData::GetValue(env, argv[ARGV_FIRST], context->avCallMetaData);
        CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get av call meta data failed",
            NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
    };
    context->GetCbInfo(env, info, inputParser);
    context->taskId = NAPI_SET_AVCALL_META_DATA_TASK_ID;

    auto executor = [context]() {
        auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
        if (napiSession->session_ == nullptr) {
            context->status = napi_generic_failure;
            context->errMessage = "SetAVCallMetaData failed : session is nullptr";
            context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
            return;
        }
        int32_t ret = napiSession->session_->SetAVCallMetaData(context->avCallMetaData);
        if (ret != AVSESSION_SUCCESS) {
            if (ret == ERR_SESSION_NOT_EXIST) {
                context->errMessage = "SetAVCallMetaData failed : native session not exist";
            } else if (ret == ERR_INVALID_PARAM) {
                context->errMessage = "SetAVCallMetaData failed : native invalid parameters";
            } else if (ret == ERR_NO_PERMISSION) {
                context->errMessage = "SetAVCallMetaData failed : native no permission";
            } else {
                context->errMessage = "SetAVCallMetaData failed : native server exception";
            }
            context->status = napi_generic_failure;
            context->errCode = NapiAVSessionManager::errcode_[ret];
        }
    };
    auto complete = [env](napi_value& output) {
        output = NapiUtils::GetUndefinedValue(env);
    };
    return NapiAsyncWork::Enqueue(env, context, "SetAVCallMetaData", executor, complete);
}

napi_value NapiAVSession::SetAVCallState(napi_env env, napi_callback_info info)
{
    AVSESSION_TRACE_SYNC_START("NapiAVSession::SetAVCallState");
    struct ConcreteContext : public ContextBase {
        AVCallState avCallState;
    };
    auto context = std::make_shared<ConcreteContext>();
    if (context == nullptr) {
        SLOGE("SetAVCallState failed : no memory");
        NapiUtils::ThrowError(env, "SetAVCallState failed : no memory",
                              NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
        return NapiUtils::GetUndefinedValue(env);
    }

    auto inputParser = [env, context](size_t argc, napi_value* argv) {
        CHECK_ARGS_RETURN_VOID(context, argc == ARGC_ONE, "invalid arguments",
            NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
        context->status = NapiAVCallState::GetValue(env, argv[ARGV_FIRST], context->avCallState);
        CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get avCallState failed",
            NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
    };
    context->GetCbInfo(env, info, inputParser);
    context->taskId = NAPI_SET_AV_CALL_STATE_TASK_ID;

    auto executor = [context]() {
        auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
        if (napiSession->session_ == nullptr) {
            context->status = napi_generic_failure;
            context->errMessage = "SetAVCallState failed : session is nullptr";
            context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
            return;
        }
        int32_t ret = napiSession->session_->SetAVCallState(context->avCallState);
        if (ret != AVSESSION_SUCCESS) {
            if (ret == ERR_SESSION_NOT_EXIST) {
                context->errMessage = "SetAVCallState failed : native session not exist";
            } else if (ret == ERR_INVALID_PARAM) {
                context->errMessage = "SetAVCallState failed : native invalid parameters";
            } else if (ret == ERR_NO_PERMISSION) {
                context->errMessage = "SetAVCallState failed : native no permission";
            } else {
                context->errMessage = "SetAVCallState failed : native server exception";
            }
            context->status = napi_generic_failure;
            context->errCode = NapiAVSessionManager::errcode_[ret];
        }
    };
    auto complete = [env](napi_value& output) {
        output = NapiUtils::GetUndefinedValue(env);
    };
    return NapiAsyncWork::Enqueue(env, context, "SetAVCallState", executor, complete);
}

int32_t DoDownload(AVMetaData& meta, const std::string uri)
{
    SLOGI("DoDownload with title %{public}s", meta.GetTitle().c_str());

    std::shared_ptr<Media::PixelMap> pixelMap = nullptr;
    bool ret = NapiUtils::DoDownloadInCommon(pixelMap, uri);
    SLOGI("DoDownload with ret %{public}d, %{public}d", static_cast<int>(ret), static_cast<int>(pixelMap == nullptr));
    if (ret && pixelMap != nullptr) {
        SLOGI("DoDownload success and ResetToBaseMeta");
        meta.ResetToBaseMeta();
        meta.SetMediaImage(AVSessionPixelMapAdapter::ConvertToInner(pixelMap));
        return AVSESSION_SUCCESS;
    }
    return AVSESSION_ERROR;
}

void processErrMsg(std::shared_ptr<ContextBase> context, int32_t ret)
{
    if (ret == ERR_SESSION_NOT_EXIST) {
        context->errMessage = "SetAVMetaData failed : native session not exist";
    } else if (ret == ERR_INVALID_PARAM) {
        context->errMessage = "SetAVMetaData failed : native invalid parameters";
    } else if (ret == ERR_NO_PERMISSION) {
        context->errMessage = "SetAVMetaData failed : native no permission";
    } else {
        context->errMessage = "SetAVMetaData failed : native server exception";
    }
    context->status = napi_generic_failure;
    context->errCode = NapiAVSessionManager::errcode_[ret];
}

bool doMetaDataSetNapi(std::shared_ptr<ContextBase> context, std::shared_ptr<AVSession> sessionPtr, AVMetaData& data,
    bool isRepeatDownload)
{
    SLOGI("do metadata set with check uri alive:%{public}d, pixel alive:%{public}d, session alive:%{public}d",
        static_cast<int>(!data.GetMediaImageUri().empty()),
        static_cast<int>(data.GetMediaImage() != nullptr),
        static_cast<int>(sessionPtr != nullptr));
    if (sessionPtr == nullptr) {
        context->status = napi_generic_failure;
        context->errMessage = "SetAVMetaData failed : session is nullptr";
        context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
        return false;
    }
    auto uri = data.GetMediaImageUri();
    int32_t ret = sessionPtr->SetAVMetaData(data);
    if (ret != AVSESSION_SUCCESS) {
        SLOGE("do metadata set fail, ret:%{public}d", ret);
        processErrMsg(context, ret);
    } else if (data.GetMediaImageUri().empty()) {
        SLOGE("do metadata set with img uri empty");
    } else if (isRepeatDownload) {
        SLOGI("do metadata set with repeat uriSize:%{public}d.", static_cast<int>(uri.size()));
    } else if (data.GetMediaImage() == nullptr) {
        ret = DoDownload(data, uri);
        SLOGI("DoDownload uriSize:%{public}d complete with ret %{public}d", static_cast<int>(uri.size()), ret);
        CHECK_AND_RETURN_RET_LOG(sessionPtr != nullptr, false, "doMetaDataSet without session");
        if (ret != AVSESSION_SUCCESS) {
            SLOGE("DoDownload failed but not repeat setmetadata again");
        } else {
            return true;
        }
    }
    return false;
}

void NapiAVSession::DoLastMetaDataRefresh(NapiAVSession* napiAVSession)
{
    CHECK_AND_RETURN_LOG(napiAVSession != nullptr, "context nullptr!");
    napiAVSession->latestDownloadedAssetId_ = (napiAVSession->metaData_.GetAssetId() !=
        napiAVSession->latestMetadataAssetId_) ? "" : napiAVSession->latestDownloadedAssetId_;
    napiAVSession->latestDownloadedUri_ = (napiAVSession->metaData_.GetMediaImage() != nullptr) ?
        "" : napiAVSession->latestDownloadedUri_;
    napiAVSession->latestMetadataUri_ = napiAVSession->metaData_.GetMediaImageUri();
    napiAVSession->latestMetadataAssetId_ = napiAVSession->metaData_.GetAssetId();
}

bool NapiAVSession::CheckMetaOutOfDate(NapiAVSession* napiAVSession, OHOS::AVSession::AVMetaData& curMeta)
{
    CHECK_AND_RETURN_RET_LOG(napiAVSession != nullptr, true, "context nullptr!");
    return (curMeta.GetAssetId() != napiAVSession->latestMetadataAssetId_) ||
        (!napiAVSession->latestMetadataUri_.empty() &&
        curMeta.GetMediaImageUri() != napiAVSession->latestMetadataUri_) ||
        (napiAVSession->latestDownloadedAssetId_ == napiAVSession->latestMetadataAssetId_ &&
        napiAVSession->latestDownloadedUri_ == napiAVSession->latestMetadataUri_);
}

napi_value NapiAVSession::SetAVMetaData(napi_env env, napi_callback_info info)
{
    AVSESSION_TRACE_SYNC_START("NapiAVSession::SetAVMetadata");
    struct ConcreteContext : public ContextBase {
        AVMetaData metaData;
    };
    auto context = std::make_shared<ConcreteContext>();
    CHECK_AND_RETURN_RET_LOG(context != nullptr, NapiUtils::GetUndefinedValue(env), "SetAVMetaData failed: no memory");
    auto inputParser = [env, context](size_t argc, napi_value* argv) {
        CHECK_ARGS_RETURN_VOID(context, argc == ARGC_ONE, "invalid arguments",
            NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
        context->status = NapiMetaData::GetValue(env, argv[ARGV_FIRST], context->metaData);
        CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get metaData failed",
            NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
    };
    context->GetCbInfo(env, info, inputParser);
    auto complete = [env](napi_value& output) { output = NapiUtils::GetUndefinedValue(env); };
    auto* napiAvSession = reinterpret_cast<NapiAVSession*>(context->native);
    if (napiAvSession == nullptr || napiAvSession->metaData_.EqualWithUri((context->metaData))) {
        SLOGI("Session nullptr or metadata all same");
        auto executor = []() {};
        return NapiAsyncWork::Enqueue(env, context, "SetAVMetaData", executor, complete);
    }
    napiAvSession->metaData_ = context->metaData;
    context->taskId = NAPI_SET_AV_META_DATA_TASK_ID;
    DoLastMetaDataRefresh(napiAvSession);

    auto syncExecutor = AVQueueImgDownloadSyncExecutor(reinterpret_cast<NapiAVSession*>(context->native),
        context->metaData);
    CHECK_AND_PRINT_LOG(AVSessionEventHandler::GetInstance()
        .AVSessionPostTask(syncExecutor, "AVQueueImgDownload"),
        "NapiAVSession AVQueueImgDownload handler postTask failed");
    auto executor = [context]() {
        auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
        bool isRepeatDownload = napiSession->latestDownloadedAssetId_ == napiSession->latestMetadataAssetId_ &&
            napiSession->latestDownloadedUri_ == napiSession->latestMetadataUri_;
        bool res = doMetaDataSetNapi(context, napiSession->session_, context->metaData, isRepeatDownload);
        {
            std::lock_guard<std::mutex> lockGuard(lock_);
            bool isOutOfDate = CheckMetaOutOfDate(napiSession, context->metaData);
            SLOGI("doMetaDataSet res:%{public}d|%{public}d", static_cast<int>(res), !isOutOfDate);
            if (res && !isOutOfDate && napiSession->session_ != nullptr) {
                napiSession->latestDownloadedUri_ = context->metaData.GetMediaImageUri();
                napiSession->latestDownloadedAssetId_ = context->metaData.GetAssetId();
                napiSession->session_->SetAVMetaData(context->metaData);
            }
        }
        context->metaData.Reset();
    };
    return NapiAsyncWork::Enqueue(env, context, "SetAVMetaData", executor, complete);
}

std::function<void()> NapiAVSession::PlaybackStateSyncExecutor(std::shared_ptr<AVSession> session,
    AVPlaybackState playBackState)
{
    return [session, playBackState]() {
        if (session == nullptr) {
            playBackStateRet_ = ERR_SESSION_NOT_EXIST;
            return;
        }
        playBackStateRet_ = session->SetAVPlaybackState(playBackState);
        syncCond_.notify_one();
        std::unique_lock<std::mutex> lock(syncAsyncMutex_);
        auto waitStatus = syncAsyncCond_.wait_for(lock, std::chrono::milliseconds(100));
        if (waitStatus == std::cv_status::timeout) {
            SLOGE("SetAVPlaybackState:%{public}d in syncExecutor timeout after err:%{public}d",
                playBackState.GetState(), playBackStateRet_);
            return;
        }
    };
}

std::function<void()> NapiAVSession::PlaybackStateAsyncExecutor(std::shared_ptr<ContextBase> context)
{
    return [context]() {
        std::unique_lock<std::mutex> lock(syncMutex_);
        auto waitStatus = syncCond_.wait_for(lock, std::chrono::milliseconds(100));

        if (playBackStateRet_ != AVSESSION_SUCCESS) {
            if (playBackStateRet_ == ERR_SESSION_NOT_EXIST) {
                context->errMessage = "SetAVPlaybackState failed : native session not exist";
            } else if (playBackStateRet_ == ERR_INVALID_PARAM) {
                context->errMessage = "SetAVPlaybackState failed : native invalid parameters";
            } else if (playBackStateRet_ == ERR_NO_PERMISSION) {
                context->errMessage = "SetAVPlaybackState failed : native no permission";
            } else {
                context->errMessage = "SetAVPlaybackState failed : native server exception";
            }
            context->status = napi_generic_failure;
            context->errCode = NapiAVSessionManager::errcode_[playBackStateRet_];
        }
        if (waitStatus == std::cv_status::timeout) {
            SLOGE("SetAVPlaybackState in asyncExecutor timeout after err:%{public}d", playBackStateRet_);
            return;
        }
        syncAsyncCond_.notify_one();
    };
}

std::function<void()> NapiAVSession::AVQueueImgDownloadSyncExecutor(NapiAVSession* napiSession,
    OHOS::AVSession::AVMetaData metaData)
{
    return [napiSession, metaData]() {
        AVQueueInfo info = AVQueueInfo();
        CHECK_AND_RETURN_LOG(napiSession != nullptr && napiSession->session_ != nullptr, "avqImg download NoSession");
        CHECK_AND_RETURN_LOG(!metaData.GetAVQueueImageUri().empty() && metaData.GetAVQueueImage() == nullptr,
            "avqImg not match download conditions");

        CHECK_AND_RETURN_LOG(napiSession->latestDownloadedAVQueueId_ != metaData.GetAVQueueId(), "repeat avqId return");
        std::shared_ptr<Media::PixelMap> pixelMap = nullptr;
        bool ret = NapiUtils::DoDownloadInCommon(pixelMap, metaData.GetAVQueueImageUri());
        CHECK_AND_RETURN_LOG(napiSession != nullptr && napiSession->session_ != nullptr, "aft avq download NoSession");
        CHECK_AND_RETURN_LOG(ret && pixelMap != nullptr, "download avqImg fail");
        napiSession->latestDownloadedAVQueueId_ = metaData.GetAVQueueId();
        info.SetAVQueueImage(AVSessionPixelMapAdapter::ConvertToInner(pixelMap));
        info.SetAVQueueId(metaData.GetAVQueueId());
        info.SetAVQueueName(metaData.GetAVQueueName());
        napiSession->session_->UpdateAVQueueInfo(info);
    };
}

napi_value NapiAVSession::SendCustomData(napi_env env, napi_callback_info info)
{
    AVSESSION_TRACE_SYNC_START("NapiAVSession::SendCustomData");
    struct ConcreteContext : public ContextBase {
        AAFwk::WantParams data_;
    };
    auto context = std::make_shared<ConcreteContext>();
    if (context == nullptr) {
        SLOGE("SendCustomData failed : no memory");
        NapiUtils::ThrowError(env, "SendCustomData failed : no memory",
                              NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
        return NapiUtils::GetUndefinedValue(env);
    }
    auto inputParser = [env, context](size_t argc, napi_value* argv) {
        CHECK_ARGS_RETURN_VOID(context, argc == ARGC_ONE, "invalid arguments",
            NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
        context->status = NapiUtils::GetValue(env, argv[ARGV_FIRST], context->data_);
        CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get customData failed",
            NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
    };
    context->GetCbInfo(env, info, inputParser);
    context->taskId = NAPI_SEND_CUSTOM_DATA_TASK_ID;
    auto executor = [context]() {
        auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
        if (napiSession->session_ == nullptr) {
            context->status = napi_generic_failure;
            context->errMessage = "SendCustomData failed : session is nullptr";
            context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
            return;
        }
        int32_t ret = napiSession->session_->SendCustomData(context->data_);
        if (ret != AVSESSION_SUCCESS) {
            if (ret == ERR_SESSION_NOT_EXIST) {
                context->errMessage = "SendCustomData failed : native session not exist";
            } else if (ret == ERR_INVALID_PARAM) {
                context->errMessage = "SendCustomData failed : native invalid parameters";
            } else if (ret == ERR_NO_PERMISSION) {
                context->errMessage = "SendCustomData failed : native no permission";
            } else {
                context->errMessage = "SendCustomData failed : native server exception, \
                    you are advised to : 1.scheduled retry.\
                    2.destroy the current session or session controller and re-create it.";
            }
            context->status = napi_generic_failure;
            context->errCode = NapiAVSessionManager::errcode_[ret];
        }
    };
    auto complete = [env](napi_value& output) { output = NapiUtils::GetUndefinedValue(env); };
    return NapiAsyncWork::Enqueue(env, context, "SendCustomData", executor, complete);
}

napi_value NapiAVSession::SetAVPlaybackState(napi_env env, napi_callback_info info)
{
    AVSESSION_TRACE_SYNC_START("NapiAVSession::SetAVPlaybackState");
    struct ConcreteContext : public ContextBase {
        AVPlaybackState playBackState_;
    };
    auto context = std::make_shared<ConcreteContext>();
    if (context == nullptr) {
        SLOGE("SetAVPlaybackState failed : no memory");
        NapiUtils::ThrowError(env, "SetAVPlaybackState failed : no memory",
                              NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
        return NapiUtils::GetUndefinedValue(env);
    }

    auto inputParser = [env, context](size_t argc, napi_value* argv) {
        CHECK_ARGS_RETURN_VOID(context, argc == ARGC_ONE, "invalid arguments",
            NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
        context->status = NapiPlaybackState::GetValue(env, argv[ARGV_FIRST], context->playBackState_);
        CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get playBackState failed",
            NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
    };
    context->GetCbInfo(env, info, inputParser);
    context->taskId = NAPI_SET_AV_PLAYBACK_STATE_TASK_ID;

    auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
    if (napiSession->session_ == nullptr) {
        SLOGE("SetAVPlaybackState failed : session is nullptr");
        context->status = napi_generic_failure;
        context->errMessage = "SetAVPlaybackState failed : session is nullptr";
        context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
        auto executor = []() {};
        auto complete = [env](napi_value& output) { output = NapiUtils::GetUndefinedValue(env); };
        return NapiAsyncWork::Enqueue(env, context, "SetAVPlaybackState", executor, complete);
    }

    auto syncExecutor = PlaybackStateSyncExecutor(napiSession->session_, context->playBackState_);
    CHECK_AND_PRINT_LOG(AVSessionEventHandler::GetInstance()
        .AVSessionPostTask(syncExecutor, "SetAVPlaybackState"),
        "NapiAVSession SetAVPlaybackState handler postTask failed");

    auto asyncExecutor = PlaybackStateAsyncExecutor(context);
    auto complete = [env](napi_value& output) { output = NapiUtils::GetUndefinedValue(env); };
    return NapiAsyncWork::Enqueue(env, context, "SetAVPlayback", asyncExecutor, complete);
}

napi_value NapiAVSession::SetAVQueueItems(napi_env env, napi_callback_info info)
{
    AVSESSION_TRACE_SYNC_START("NapiAVSession::SetAVQueueItems");
    struct ConcreteContext : public ContextBase { std::vector<AVQueueItem> items_; };
    auto context = std::make_shared<ConcreteContext>();
    if (context == nullptr) {
        NapiUtils::ThrowError(env, "SetAVQueueItems failed : no memory",
            NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
        return NapiUtils::GetUndefinedValue(env);
    }
    auto inputParser = [env, context](size_t argc, napi_value* argv) {
        CHECK_ARGS_RETURN_VOID(context, argc == ARGC_ONE, "invalid arguments",
            NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
        context->status = NapiUtils::GetValue(env, argv[ARGV_FIRST], context->items_);
        CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get queueItems failed",
            NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
        for (auto &item : context->items_) {
            CHECK_ARGS_RETURN_VOID(context, item.IsValid(), "invalid queue item content",
                NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
        }
    };
    context->GetCbInfo(env, info, inputParser);
    context->taskId = NAPI_SET_AV_QUEUE_ITEMS_TASK_ID;
    auto executor = [context]() {
        auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
        if (napiSession->session_ == nullptr) {
            context->status = napi_generic_failure;
            context->errMessage = "SetAVQueueItems failed : session is nullptr";
            context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
            return;
        }
        int32_t ret = napiSession->session_->SetAVQueueItems(context->items_);
        if (ret != AVSESSION_SUCCESS) {
            if (ret == ERR_SESSION_NOT_EXIST) {
                context->errMessage = "SetAVQueueItems failed : native session not exist";
            } else if (ret == ERR_INVALID_PARAM) {
                context->errMessage = "SetAVQueueItems failed : native invalid parameters";
            } else if (ret == ERR_NO_PERMISSION) {
                context->errMessage = "SetAVQueueItems failed : native no permission";
            } else if (ret == ERR_MARSHALLING) {
                context->errMessage = "SetAVQueueItems failed : item number is out of range";
            } else {
                context->errMessage = "SetAVQueueItems failed : native server exception";
            }
            context->status = napi_generic_failure;
            context->errCode = NapiAVSessionManager::errcode_[ret];
        }
    };
    auto complete = [env](napi_value& output) { output = NapiUtils::GetUndefinedValue(env); };
    return NapiAsyncWork::Enqueue(env, context, "SetAVQueueItems", executor, complete);
}

napi_value NapiAVSession::SetAVQueueTitle(napi_env env, napi_callback_info info)
{
    AVSESSION_TRACE_SYNC_START("NapiAVSession::SetAVQueueTitle");
    struct ConcreteContext : public ContextBase {
        std::string title;
    };
    auto context = std::make_shared<ConcreteContext>();
    if (context == nullptr) {
        SLOGE("SetAVQueueTitle failed : no memory");
        NapiUtils::ThrowError(env, "SetAVQueueTitle failed : no memory",
            NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
        return NapiUtils::GetUndefinedValue(env);
    }

    auto inputParser = [env, context](size_t argc, napi_value* argv) {
        CHECK_ARGS_RETURN_VOID(context, argc == ARGC_ONE, "invalid arguments",
            NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
        context->status = NapiUtils::GetValue(env, argv[ARGV_FIRST], context->title);
        CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get queueItems failed",
            NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
    };
    context->GetCbInfo(env, info, inputParser);
    context->taskId = NAPI_SET_AV_QUEUE_TITLE_TASK_ID;

    auto executor = [context]() {
        auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
        if (napiSession->session_ == nullptr) {
            context->status = napi_generic_failure;
            context->errMessage = "SetAVQueueTitle failed : session is nullptr";
            context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
            return;
        }
        int32_t ret = napiSession->session_->SetAVQueueTitle(context->title);
        if (ret != AVSESSION_SUCCESS) {
            if (ret == ERR_SESSION_NOT_EXIST) {
                context->errMessage = "SetAVQueueTitle failed : native session not exist";
            } else if (ret == ERR_INVALID_PARAM) {
                context->errMessage = "SetAVQueueTitle failed : native invalid parameters";
            } else if (ret == ERR_NO_PERMISSION) {
                context->errMessage = "SetAVQueueTitle failed : native no permission";
            } else {
                context->errMessage = "SetAVQueueTitle failed : native server exception";
            }
            context->status = napi_generic_failure;
            context->errCode = NapiAVSessionManager::errcode_[ret];
        }
    };
    auto complete = [env](napi_value& output) {
        output = NapiUtils::GetUndefinedValue(env);
    };
    return NapiAsyncWork::Enqueue(env, context, "SetAVQueueTitle", executor, complete);
}

napi_value NapiAVSession::SetLaunchAbility(napi_env env, napi_callback_info info)
{
    struct ConcreteContext : public ContextBase {
        AbilityRuntime::WantAgent::WantAgent* wantAgent_;
    };
    auto context = std::make_shared<ConcreteContext>();
    if (context == nullptr) {
        SLOGE("SetLaunchAbility failed : no memory");
        NapiUtils::ThrowError(env, "SetLaunchAbility failed : no memory",
                              NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
        return NapiUtils::GetUndefinedValue(env);
    }

    auto inputParser = [env, context](size_t argc, napi_value* argv) {
        CHECK_ARGS_RETURN_VOID(context, argc == ARGC_ONE, "invalid arguments",
            NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
        context->status = NapiUtils::GetValue(env, argv[ARGV_FIRST], context->wantAgent_);
        CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get  wantAgent failed",
            NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
    };
    context->GetCbInfo(env, info, inputParser);

    auto executor = [context]() {
        auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
        if (napiSession->session_ == nullptr) {
            context->status = napi_generic_failure;
            context->errMessage = "SetLaunchAbility failed : session is nullptr";
            context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
            return;
        }
        int32_t ret = napiSession->session_->SetLaunchAbility(*context->wantAgent_);
        if (ret != AVSESSION_SUCCESS) {
            if (ret == ERR_SESSION_NOT_EXIST) {
                context->errMessage = "SetLaunchAbility failed : native session not exist";
            } else if (ret == ERR_NO_PERMISSION) {
                context->errMessage = "SetLaunchAbility failed : native no permission";
            } else {
                context->errMessage = "SetLaunchAbility failed : native server exception";
            }
            context->status = napi_generic_failure;
            context->errCode = NapiAVSessionManager::errcode_[ret];
        }
    };
    auto complete = [env](napi_value& output) {
        output = NapiUtils::GetUndefinedValue(env);
    };
    return NapiAsyncWork::Enqueue(env, context, "SetLaunchAbility", executor, complete);
}

napi_value NapiAVSession::SetExtras(napi_env env, napi_callback_info info)
{
    AVSESSION_TRACE_SYNC_START("NapiAVSession::SetExtras");
    struct ConcreteContext : public ContextBase {
        AAFwk::WantParams extras_;
    };
    auto context = std::make_shared<ConcreteContext>();
    if (context == nullptr) {
        SLOGE("SetExtras failed : no memory");
        NapiUtils::ThrowError(env, "SetExtras failed : no memory", NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
        return NapiUtils::GetUndefinedValue(env);
    }

    auto inputParser = [env, context](size_t argc, napi_value* argv) {
        CHECK_ARGS_RETURN_VOID(context, argc == ARGC_ONE, "invalid arguments",
            NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
        context->status = NapiUtils::GetValue(env, argv[ARGV_FIRST], context->extras_);
        CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get extras failed",
            NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
    };
    context->GetCbInfo(env, info, inputParser);
    context->taskId = NAPI_SET_EXTRAS_TASK_ID;

    auto executor = [context]() {
        auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
        if (napiSession->session_ == nullptr) {
            context->status = napi_generic_failure;
            context->errMessage = "SetExtras failed : session is nullptr";
            context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
            return;
        }
        int32_t ret = napiSession->session_->SetExtras(context->extras_);
        if (ret != AVSESSION_SUCCESS) {
            if (ret == ERR_SESSION_NOT_EXIST) {
                context->errMessage = "SetExtras failed : native session not exist";
            } else if (ret == ERR_INVALID_PARAM) {
                context->errMessage = "SetExtras failed : native invalid parameters";
            } else {
                context->errMessage = "SetExtras failed : native server exception";
            }
            context->status = napi_generic_failure;
            context->errCode = NapiAVSessionManager::errcode_[ret];
        }
    };
    auto complete = [env](napi_value& output) {
        output = NapiUtils::GetUndefinedValue(env);
    };
    return NapiAsyncWork::Enqueue(env, context, "SetExtras", executor, complete);
}

napi_value NapiAVSession::SetAudioStreamId(napi_env env, napi_callback_info info)
{
    struct ConcreteContext : public ContextBase {
        std::vector<int32_t> streamIds_;
    };
    auto context = std::make_shared<ConcreteContext>();
    if (context == nullptr) {
        SLOGE("SetAudioStreamId failed : no memory");
        NapiUtils::ThrowError(env, "SetAudioStreamId failed : no memory",
                              NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
        return NapiUtils::GetUndefinedValue(env);
    }

    auto inputParser = [env, context](size_t argc, napi_value* argv) {
        CHECK_ARGS_RETURN_VOID(context, argc == ARGC_ONE, "invalid arguments",
            NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
        context->status = NapiUtils::GetValue(env, argv[ARGV_FIRST], context->streamIds_);
        CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get streamIds_ failed",
            NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
    };
    context->GetCbInfo(env, info, inputParser);

    auto executor = [context]() {
        auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
        if (napiSession->session_ == nullptr) {
            context->status = napi_generic_failure;
            context->errMessage = "SetAudioStreamId failed : session is nullptr";
            context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
            return;
        }
    };
    auto complete = [env](napi_value& output) {
        output = NapiUtils::GetUndefinedValue(env);
    };
    return NapiAsyncWork::Enqueue(env, context, "SetAudioStreamId", executor, complete);
}

napi_value NapiAVSession::GetController(napi_env env, napi_callback_info info)
{
    struct ConcreteContext : public ContextBase {
        std::shared_ptr<AVSessionController> controller_;
    };
    auto context = std::make_shared<ConcreteContext>();
    if (context == nullptr) {
        SLOGE("GetController failed : no memory");
        NapiUtils::ThrowError(env, "GetController failed : no memory", NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
        return NapiUtils::GetUndefinedValue(env);
    }

    context->GetCbInfo(env, info);

    auto executor = [context]() {
        auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
        if (napiSession->session_ == nullptr) {
            context->status = napi_generic_failure;
            context->errMessage = "GetController failed : session is nullptr";
            context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
            return;
        }
        context->controller_ = napiSession->session_->GetController();
        if (context->controller_ == nullptr) {
            context->status = napi_generic_failure;
            context->errMessage = "GetController failed : native get controller failed";
            context->errCode = NapiAVSessionManager::errcode_[AVSESSION_ERROR];
        }
    };
    auto complete = [env, context](napi_value& output) {
        CHECK_STATUS_RETURN_VOID(context, "get controller failed", NapiAVSessionManager::errcode_[AVSESSION_ERROR]);
        CHECK_ARGS_RETURN_VOID(context, context->controller_ != nullptr, "controller is nullptr",
            NapiAVSessionManager::errcode_[AVSESSION_ERROR]);
        context->status = NapiAVSessionController::NewInstance(env, context->controller_, output);
        CHECK_STATUS_RETURN_VOID(context, "convert native object to js object failed",
            NapiAVSessionManager::errcode_[AVSESSION_ERROR]);
    };
    return NapiAsyncWork::Enqueue(env, context, "GetController", executor, complete);
}

napi_value NapiAVSession::GetAVCastController(napi_env env, napi_callback_info info)
{
#ifdef CASTPLUS_CAST_ENGINE_ENABLE
    struct ConcreteContext : public ContextBase {
        std::shared_ptr<AVCastController> castController_;
    };
    auto context = std::make_shared<ConcreteContext>();
    if (context == nullptr) {
        SLOGE("GetAVCastController failed : no memory");
        NapiUtils::ThrowError(env, "GetAVCastController failed : no memory",
            NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
        return NapiUtils::GetUndefinedValue(env);
    }

    context->GetCbInfo(env, info);

    auto executor = [context]() {
        auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
        if (napiSession->session_ == nullptr) {
            context->status = napi_generic_failure;
            context->errMessage = "GetAVCastController failed : session is nullptr";
            context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
            return;
        }
        context->castController_ = napiSession->session_->GetAVCastController();
        if (context->castController_ == nullptr) {
            context->status = napi_generic_failure;
            context->errMessage = "GetAVCastController failed : native get controller failed";
            context->errCode = NapiAVSessionManager::errcode_[AVSESSION_ERROR];
        }
    };
    auto complete = [env, context](napi_value& output) {
        CHECK_STATUS_RETURN_VOID(context, "get controller failed", NapiAVSessionManager::errcode_[AVSESSION_ERROR]);
        CHECK_ARGS_RETURN_VOID(context, context->castController_ != nullptr, "controller is nullptr",
            NapiAVSessionManager::errcode_[AVSESSION_ERROR]);
        context->status = NapiAVCastController::NewInstance(env, context->castController_, output);
        CHECK_STATUS_RETURN_VOID(context, "convert native object to js object failed",
            NapiAVSessionManager::errcode_[AVSESSION_ERROR]);
    };
    return NapiAsyncWork::Enqueue(env, context, "GetAVCastController", executor, complete);
#else
    return nullptr;
#endif
}

napi_value NapiAVSession::GetOutputDevice(napi_env env, napi_callback_info info)
{
    struct ConcreteContext : public ContextBase {
        OutputDeviceInfo outputDeviceInfo_;
    };
    auto context = std::make_shared<ConcreteContext>();
    if (context == nullptr) {
        SLOGE("GetOutputDevice failed : no memory");
        NapiUtils::ThrowError(env, "GetOutputDevice failed : no memory", NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
        return NapiUtils::GetUndefinedValue(env);
    }

    context->GetCbInfo(env, info);

    auto executor = [context]() {
        auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
        if (napiSession->session_ == nullptr) {
            context->status = napi_generic_failure;
            context->errMessage = "GetOutputDevice failed : session is nullptr";
            context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
            return;
        }
        AVSessionDescriptor descriptor;
        AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId(napiSession->session_->GetSessionId(),
                                                                         descriptor);
        context->outputDeviceInfo_ = descriptor.outputDeviceInfo_;
    };

    auto complete = [env, context](napi_value& output) {
        context->status = NapiUtils::SetValue(env, context->outputDeviceInfo_, output);
        CHECK_STATUS_RETURN_VOID(context, "convert native object to javascript object failed",
            NapiAVSessionManager::errcode_[AVSESSION_ERROR]);
    };
    return NapiAsyncWork::Enqueue(env, context, "GetOutputDevice", executor, complete);
}

napi_value NapiAVSession::GetOutputDeviceSync(napi_env env, napi_callback_info info)
{
    SLOGD("Start GetOutputDeviceSync");
    auto context = std::make_shared<ContextBase>();
    if (context == nullptr) {
        SLOGE("GetOutputDeviceSync failed : no memory");
        NapiUtils::ThrowError(env, "GetOutputDeviceSync failed : no memory",
            NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
        return NapiUtils::GetUndefinedValue(env);
    }

    context->GetCbInfo(env, info, NapiCbInfoParser(), true);

    auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
    if (napiSession->session_ == nullptr) {
        SLOGE("NapiAVSession GetOutputDeviceSync fail:session nullptr");
        NapiUtils::ThrowError(env, "NapiAVSession GetOutputDeviceSync failed : session is nullptr",
            NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST]);
        return NapiUtils::GetUndefinedValue(env);
    }

    AVSessionDescriptor descriptor;
    AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId(napiSession->session_->GetSessionId(),
        descriptor);
    napi_value output {};
    auto status = NapiUtils::SetValue(env, descriptor.outputDeviceInfo_, output);
    if (status != napi_ok) {
        SLOGE("convert native object to javascript object failed");
        NapiUtils::ThrowError(env, "convert native object to javascript object failed",
            NapiAVSessionManager::errcode_[AVSESSION_ERROR]);
        return NapiUtils::GetUndefinedValue(env);
    }
    return output;
}

napi_value NapiAVSession::Activate(napi_env env, napi_callback_info info)
{
    auto context = std::make_shared<ContextBase>();
    if (context == nullptr) {
        SLOGE("Activate failed : no memory");
        NapiUtils::ThrowError(env, "Activate failed : no memory", NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
        return NapiUtils::GetUndefinedValue(env);
    }

    context->GetCbInfo(env, info);

    auto executor = [context]() {
        auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
        if (napiSession->session_ == nullptr) {
            context->status = napi_generic_failure;
            context->errMessage = "Activate session failed : session is nullptr";
            context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
            return;
        }
        int32_t ret = napiSession->session_->Activate();
        if (ret != AVSESSION_SUCCESS) {
            if (ret == ERR_SESSION_NOT_EXIST) {
                context->errMessage = "Activate session failed : native session not exist";
            } else if (ret == ERR_NO_PERMISSION) {
                context->errMessage = "Activate failed : native no permission";
            } else {
                context->errMessage = "Activate session failed : native server exception";
            }
            context->status = napi_generic_failure;
            context->errCode = NapiAVSessionManager::errcode_[ret];
        }
    };
    auto complete = [env](napi_value& output) {
        output = NapiUtils::GetUndefinedValue(env);
    };
    return NapiAsyncWork::Enqueue(env, context, "Activate", executor, complete);
}

napi_value NapiAVSession::Deactivate(napi_env env, napi_callback_info info)
{
    auto context = std::make_shared<ContextBase>();
    if (context == nullptr) {
        SLOGE("Deactivate failed : no memory");
        NapiUtils::ThrowError(env, "Deactivate failed : no memory", NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
        return NapiUtils::GetUndefinedValue(env);
    }

    context->GetCbInfo(env, info);

    auto executor = [context]() {
        auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
        if (napiSession->session_ == nullptr) {
            context->status = napi_generic_failure;
            context->errMessage = "Deactivate session failed : session is nullptr";
            context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
            return;
        }
        int32_t ret = napiSession->session_->Deactivate();
        if (ret != AVSESSION_SUCCESS) {
            if (ret == ERR_SESSION_NOT_EXIST) {
                context->errMessage = "Deactivate session failed : native session not exist";
            } else if (ret == ERR_NO_PERMISSION) {
                context->errMessage = "Deactivate failed : native no permission";
            } else {
                context->errMessage = "Deactivate session failed : native server exception";
            }
            context->status = napi_generic_failure;
            context->errCode = NapiAVSessionManager::errcode_[ret];
        }
    };
    auto complete = [env](napi_value& output) {
        output = NapiUtils::GetUndefinedValue(env);
    };
    return NapiAsyncWork::Enqueue(env, context, "Deactivate", executor, complete);
}

napi_value NapiAVSession::Destroy(napi_env env, napi_callback_info info)
{
    auto context = std::make_shared<ContextBase>();
    if (context == nullptr) {
        SLOGE("Destroy failed : no memory");
        NapiUtils::ThrowError(env, "Destroy failed : no memory", NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
        return NapiUtils::GetUndefinedValue(env);
    }

    context->GetCbInfo(env, info);
    
    SLOGI("Destroy session begin");
    {
        std::lock_guard lockGuard(destroyLock_);
        isNapiSessionDestroy_ = true;
    }
    auto executor = [context]() {
        auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
        if (napiSession->session_ == nullptr) {
            context->status = napi_generic_failure;
            context->errMessage = "Destroy session failed : session is nullptr";
            context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
            return;
        }
        int32_t ret = napiSession->session_->Destroy();
        if (ret == AVSESSION_SUCCESS) {
            napiSession->session_ = nullptr;
            napiSession->callback_ = nullptr;
        } else if (ret == ERR_SESSION_NOT_EXIST) {
            context->status = napi_generic_failure;
            context->errMessage = "Destroy session failed : native session not exist";
            context->errCode = NapiAVSessionManager::errcode_[ret];
        } else if (ret == ERR_NO_PERMISSION) {
            context->status = napi_generic_failure;
            context->errMessage = "Destroy failed : native no permission";
            context->errCode = NapiAVSessionManager::errcode_[ret];
        } else {
            context->status = napi_generic_failure;
            context->errMessage = "Destroy session failed : native server exception";
            context->errCode = NapiAVSessionManager::errcode_[ret];
        }
    };
    auto complete = [env](napi_value& output) {
        output = NapiUtils::GetUndefinedValue(env);
    };
    return NapiAsyncWork::Enqueue(env, context, "Destroy", executor, complete);
}

napi_value NapiAVSession::SetSessionEvent(napi_env env, napi_callback_info info)
{
    AVSESSION_TRACE_SYNC_START("NapiAVSession::SetSessionEvent");
    struct ConcreteContext : public ContextBase {
        std::string event_;
        AAFwk::WantParams args_;
    };
    auto context = std::make_shared<ConcreteContext>();
    if (context == nullptr) {
        SLOGE("SetSessionEvent failed : no memory");
        NapiUtils::ThrowError(env, "SetSessionEvent failed : no memory", NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
        return NapiUtils::GetUndefinedValue(env);
    }

    auto inputParser = [env, context](size_t argc, napi_value* argv) {
        CHECK_ARGS_RETURN_VOID(context, argc == ARGC_TWO, "invalid arguments",
            NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
        context->status = NapiUtils::GetValue(env, argv[ARGV_FIRST], context->event_);
        CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get event failed",
            NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
        context->status = NapiUtils::GetValue(env, argv[ARGV_SECOND], context->args_);
        CHECK_ARGS_RETURN_VOID(context, context->status == napi_ok, "get args failed",
            NapiAVSessionManager::errcode_[ERR_INVALID_PARAM]);
    };
    context->GetCbInfo(env, info, inputParser);
    context->taskId = NAPI_SET_AV_META_DATA_TASK_ID;

    auto executor = [context]() {
        auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
        if (napiSession->session_ == nullptr) {
            context->status = napi_generic_failure;
            context->errMessage = "SetSessionEvent failed : session is nullptr";
            context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
            return;
        }
        int32_t ret = napiSession->session_->SetSessionEvent(context->event_, context->args_);
        if (ret != AVSESSION_SUCCESS) {
            ErrCodeToMessage(ret, context->errMessage);
            context->status = napi_generic_failure;
            context->errCode = NapiAVSessionManager::errcode_[ret];
        }
    };
    auto complete = [env](napi_value& output) {
        output = NapiUtils::GetUndefinedValue(env);
    };
    return NapiAsyncWork::Enqueue(env, context, "SetSessionEvent", executor, complete);
}

napi_value NapiAVSession::ReleaseCast(napi_env env, napi_callback_info info)
{
#ifdef CASTPLUS_CAST_ENGINE_ENABLE
    auto context = std::make_shared<ContextBase>();
    if (context == nullptr) {
        SLOGE("ReleaseCast failed : no memory");
        NapiUtils::ThrowError(env, "ReleaseCast failed : no memory", NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
        return NapiUtils::GetUndefinedValue(env);
    }

    context->GetCbInfo(env, info);

    auto executor = [context]() {
        auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
        if (napiSession->session_ == nullptr) {
            context->status = napi_generic_failure;
            context->errMessage = "ReleaseCast failed : session is nullptr";
            context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
            return;
        }
        int32_t ret = napiSession->session_->ReleaseCast();
        if (ret != AVSESSION_SUCCESS) {
            if (ret == ERR_SESSION_NOT_EXIST) {
                context->errMessage = "ReleaseCast failed : native session not exist";
            } else if (ret == ERR_NO_PERMISSION) {
                context->errMessage = "ReleaseCast failed : native no permission";
            } else {
                context->errMessage = "ReleaseCast failed : native server exception";
            }
            context->status = napi_generic_failure;
            context->errCode = NapiAVSessionManager::errcode_[ret];
        }
    };
    auto complete = [env](napi_value& output) {
        output = NapiUtils::GetUndefinedValue(env);
    };
    return NapiAsyncWork::Enqueue(env, context, "ReleaseCast", executor, complete);
#else
    return nullptr;
#endif
}

napi_value NapiAVSession::GetAllCastDisplays(napi_env env, napi_callback_info info)
{
#ifdef CASTPLUS_CAST_ENGINE_ENABLE
    struct ConcreteContext : public ContextBase {
        std::vector<CastDisplayInfo> castDisplays_;
    };
    auto context = std::make_shared<ConcreteContext>();
    if (context == nullptr) {
        SLOGE("GetAllCastDisplays failed : no memory");
        NapiUtils::ThrowError(env, "GetAllCastDisplays failed : no memory",
            NapiAVSessionManager::errcode_[ERR_NO_MEMORY]);
        return NapiUtils::GetUndefinedValue(env);
    }

    context->GetCbInfo(env, info);

    auto executor = [context]() {
        auto* napiSession = reinterpret_cast<NapiAVSession*>(context->native);
        if (napiSession->session_ == nullptr) {
            context->status = napi_generic_failure;
            context->errMessage = "GetAllCastDisplays failed : session is nullptr";
            context->errCode = NapiAVSessionManager::errcode_[ERR_SESSION_NOT_EXIST];
            return;
        }
        int32_t ret = napiSession->session_->GetAllCastDisplays(context->castDisplays_);
        if (ret != AVSESSION_SUCCESS) {
            if (ret == ERR_SESSION_NOT_EXIST) {
                context->errMessage = "GetAllCastDisplays failed : native session not exist";
            } else if (ret == ERR_NO_PERMISSION) {
                context->errMessage = "GetAllCastDisplays failed : native no permission";
            } else {
                context->errMessage = "GetAllCastDisplays failed : native server exception";
            }
            context->status = napi_generic_failure;
            context->errCode = NapiAVSessionManager::errcode_[ret];
        }
    };

    auto complete = [env, context](napi_value& output) {
        context->status = NapiUtils::SetValue(env, context->castDisplays_, output);
        CHECK_STATUS_RETURN_VOID(context, "convert native object to javascript object failed",
            NapiAVSessionManager::errcode_[AVSESSION_ERROR]);
    };
    return NapiAsyncWork::Enqueue(env, context, "GetAllCastDisplays", executor, complete);
#else
    SLOGE("GetAllCastDisplays CASTPLUS_CAST_ENGINE_ENABLE is not support");
    return ThrowErrorAndReturn(env, "OnEvent failed : no memory", ERR_NO_MEMORY);
#endif
}

void NapiAVSession::ErrCodeToMessage(int32_t errCode, std::string& message)
{
    switch (errCode) {
        case ERR_SESSION_NOT_EXIST:
            message = "SetSessionEvent failed : native session not exist";
            break;
        case ERR_INVALID_PARAM:
            message = "SetSessionEvent failed : native invalid parameters";
            break;
        case ERR_NO_PERMISSION:
            message = "SetSessionEvent failed : native no permission";
            break;
        default:
            message = "SetSessionEvent failed : native server exception";
            break;
    }
}

napi_status NapiAVSession::OnPlay(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
    int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_PLAY);
    CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_PLAY, callback);
}

napi_status NapiAVSession::OnPause(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
    int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_PAUSE);
    CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_PAUSE, callback);
}

napi_status NapiAVSession::OnStop(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
    int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_STOP);
    CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_STOP, callback);
}

napi_status NapiAVSession::OnPlayNext(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
    int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_PLAY_NEXT);
    CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_PLAY_NEXT, callback);
}

napi_status NapiAVSession::OnPlayPrevious(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
    int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_PLAY_PREVIOUS);
    CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_PLAY_PREVIOUS, callback);
}

napi_status NapiAVSession::OnFastForward(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
    int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_FAST_FORWARD);
    CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_FAST_FORWARD, callback);
}

napi_status NapiAVSession::OnRewind(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
    int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_REWIND);
    CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_REWIND, callback);
}

napi_status NapiAVSession::OnSeek(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
    int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_SEEK);
    CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_SEEK, callback);
}

napi_status NapiAVSession::OnSetSpeed(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
    int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_SET_SPEED);
    CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_SET_SPEED, callback);
}

napi_status NapiAVSession::OnSetLoopMode(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
    int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_SET_LOOP_MODE);
    CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_SET_LOOP_MODE, callback);
}

napi_status NapiAVSession::OnSetTargetLoopMode(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
    int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_SET_TARGET_LOOP_MODE);
    CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_SET_TARGET_LOOP_MODE, callback);
}

napi_status NapiAVSession::OnToggleFavorite(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
    int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_TOGGLE_FAVORITE);
    CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_TOGGLE_FAVORITE, callback);
}

napi_status NapiAVSession::OnCustomData(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
    CHECK_AND_RETURN_RET_LOG(callback != nullptr, napi_generic_failure, "callback is nullptr");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_CUSTOM_DATA, callback);
}

napi_status NapiAVSession::OnMediaKeyEvent(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
    int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_MEDIA_KEY_SUPPORT);
    SLOGI("add media key event listen ret %{public}d", static_cast<int>(ret));
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_MEDIA_KEY_EVENT, callback);
}

napi_status NapiAVSession::OnOutputDeviceChange(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_OUTPUT_DEVICE_CHANGE, callback);
}

napi_status NapiAVSession::OnCommonCommand(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_SEND_COMMON_COMMAND, callback);
}

napi_status NapiAVSession::OnSkipToQueueItem(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_SKIP_TO_QUEUE_ITEM, callback);
}

napi_status NapiAVSession::OnAVCallAnswer(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
    int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_AVCALL_ANSWER);
    CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_AVCALL_ANSWER, callback);
}

napi_status NapiAVSession::OnAVCallHangUp(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
    int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_AVCALL_HANG_UP);
    CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_AVCALL_HANG_UP, callback);
}

napi_status NapiAVSession::OnAVCallToggleCallMute(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
    int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_AVCALL_TOGGLE_CALL_MUTE);
    CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_AVCALL_TOGGLE_CALL_MUTE, callback);
}

napi_status NapiAVSession::OnPlayFromAssetId(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
    int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_PLAY_FROM_ASSETID);
    CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_PLAY_FROM_ASSETID, callback);
}

napi_status NapiAVSession::OnPlayWithAssetId(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
    CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure, "session_ is nullptr");
    int32_t ret = napiSession->session_->AddSupportCommand(AVControlCommand::SESSION_CMD_PLAY_WITH_ASSETID);
    CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "add command failed");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_PLAY_WITH_ASSETID, callback);
}

napi_status NapiAVSession::OnCastDisplayChange(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
#ifdef CASTPLUS_CAST_ENGINE_ENABLE
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
                             "NapiAVSessionCallback object is nullptr");
    auto status = napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_DISPLAY_CHANGE, callback);
    CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "AddCallback failed");
    CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
                             "NapiAVSession object is nullptr");
    napiSession->session_->StartCastDisplayListener();
#else
    return napi_generic_failure;
#endif
    return napi_ok;
}

napi_status NapiAVSession::OnCastDisplaySizeChange(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
#ifdef CASTPLUS_CAST_ENGINE_ENABLE
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
                             "NapiAVSessionCallback object is nullptr");
    auto status = napiSession->callback_->AddCallback(env, NapiAVSessionCallback::EVENT_DISPLAY_SIZE_CHANGE, callback);
    CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "AddCallback failed");
    CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
                             "NapiAVSession object is nullptr");
    napiSession->session_->StartCastDisplayListener();
#else
    return napi_generic_failure;
#endif
    return napi_ok;
}

napi_status NapiAVSession::OffPlay(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_PLAY, callback);
    CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
    if (napiSession->callback_ && napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_PLAY)) {
        CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
                                 "NapiAVSession object is nullptr");
        int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_PLAY);
        CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
    }
    return napi_ok;
}

napi_status NapiAVSession::OffPause(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_PAUSE, callback);
    CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
    if (napiSession->callback_ && napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_PAUSE)) {
        CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
                                 "NapiAVSession object is nullptr");
        int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_PAUSE);
        CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
    }
    return napi_ok;
}

napi_status NapiAVSession::OffStop(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_STOP, callback);
    CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
    if (napiSession->callback_ && napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_STOP)) {
        CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
                                 "NapiAVSession object is nullptr");
        int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_STOP);
        CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
    }
    return napi_ok;
}

napi_status NapiAVSession::OffPlayNext(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_PLAY_NEXT, callback);
    CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
    if (napiSession->callback_ && napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_PLAY_NEXT)) {
        CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
                                 "NapiAVSession object is nullptr");
        int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_PLAY_NEXT);
        CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
    }
    return napi_ok;
}

napi_status NapiAVSession::OffPlayPrevious(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_PLAY_PREVIOUS, callback);
    CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");

    if (napiSession->callback_ &&
        napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_PLAY_PREVIOUS)) {
        CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
                                 "NapiAVSession object is nullptr");
        int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_PLAY_PREVIOUS);
        CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
    }
    return napi_ok;
}

napi_status NapiAVSession::OffFastForward(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_FAST_FORWARD, callback);
    CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
    if (napiSession->callback_ &&
        napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_FAST_FORWARD)) {
        CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
                                 "NapiAVSession object is nullptr");
        int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_FAST_FORWARD);
        CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
    }
    return napi_ok;
}

napi_status NapiAVSession::OffRewind(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_REWIND, callback);
    CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
    if (napiSession->callback_ && napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_REWIND)) {
        CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
                                 "NapiAVSession object is nullptr");
        int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_REWIND);
        CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
    }
    return napi_ok;
}

napi_status NapiAVSession::OffSeek(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_SEEK, callback);
    CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
    if (napiSession->callback_ && napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_SEEK)) {
        CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
                                 "NapiAVSession object is nullptr");
        int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_SEEK);
        CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
    }
    return napi_ok;
}

napi_status NapiAVSession::OffSetSpeed(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_SET_SPEED, callback);
    CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
    if (napiSession->callback_ && napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_SET_SPEED)) {
        CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
                                 "NapiAVSession_session is nullptr");
        int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_SET_SPEED);
        CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
    }
    return napi_ok;
}

napi_status NapiAVSession::OffSetLoopMode(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_SET_LOOP_MODE, callback);
    CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
    if (napiSession->callback_ &&
        napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_SET_LOOP_MODE)) {
        CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
                                 "NapiAVSession object is nullptr");
        int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_SET_LOOP_MODE);
        CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
    }
    return napi_ok;
}

napi_status NapiAVSession::OffSetTargetLoopMode(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    auto status = napiSession->callback_->RemoveCallback(env,
        NapiAVSessionCallback::EVENT_SET_TARGET_LOOP_MODE, callback);
    CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
    if (napiSession->callback_ &&
        napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_SET_TARGET_LOOP_MODE)) {
        CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
                                 "NapiAVSession object is nullptr");
        int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_SET_TARGET_LOOP_MODE);
        CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
    }
    return napi_ok;
}

napi_status NapiAVSession::OffToggleFavorite(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_TOGGLE_FAVORITE, callback);
    CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
    if (napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_TOGGLE_FAVORITE)) {
        CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
                                 "NapiAVSession object is nullptr");
        int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_TOGGLE_FAVORITE);
        CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
    }
    return napi_ok;
}

napi_status NapiAVSession::OffMediaKeyEvent(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_MEDIA_KEY_EVENT, callback);
    CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
    if (napiSession->callback_ &&
        napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_MEDIA_KEY_EVENT)) {
        CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
                                 "NapiAVSession object is nullptr");
        int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_MEDIA_KEY_SUPPORT);
        CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
    }
    return napi_ok;
}

napi_status NapiAVSession::OffCustomData(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_CUSTOM_DATA, callback);
}

napi_status NapiAVSession::OffOutputDeviceChange(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_OUTPUT_DEVICE_CHANGE, callback);
}

napi_status NapiAVSession::OffCommonCommand(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_SEND_COMMON_COMMAND, callback);
}

napi_status NapiAVSession::OffSkipToQueueItem(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_SKIP_TO_QUEUE_ITEM, callback);
}

napi_status NapiAVSession::OffAVCallAnswer(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_AVCALL_ANSWER, callback);
}

napi_status NapiAVSession::OffAVCallHangUp(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_AVCALL_HANG_UP, callback);
}

napi_status NapiAVSession::OffAVCallToggleCallMute(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    return napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_AVCALL_TOGGLE_CALL_MUTE, callback);
}

napi_status NapiAVSession::OffPlayFromAssetId(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_PLAY_FROM_ASSETID, callback);
    CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");

    if (napiSession->callback_ &&
        napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_PLAY_FROM_ASSETID)) {
        CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
                                 "NapiAVSession object is nullptr");
        int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_PLAY_FROM_ASSETID);
        CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
    }
    return napi_ok;
}

napi_status NapiAVSession::OffPlayWithAssetId(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
    CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
        "NapiAVSessionCallback object is nullptr");
    auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_PLAY_WITH_ASSETID, callback);
    CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");

    if (napiSession->callback_->IsCallbacksEmpty(NapiAVSessionCallback::EVENT_PLAY_WITH_ASSETID)) {
        CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
                                 "NapiAVSession object is nullptr");
        int32_t ret = napiSession->session_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_PLAY_WITH_ASSETID);
        CHECK_AND_RETURN_RET_LOG(ret == AVSESSION_SUCCESS, napi_generic_failure, "delete cmd failed");
    }
    return napi_ok;
}

napi_status NapiAVSession::OffCastDisplayChange(napi_env env, NapiAVSession* napiSession, napi_value callback)
{
#ifdef CASTPLUS_CAST_ENGINE_ENABLE
    CHECK_AND_RETURN_RET_LOG(napiSession != nullptr, napi_generic_failure, "input param is nullptr");
    CHECK_AND_RETURN_RET_LOG(napiSession->callback_ != nullptr, napi_generic_failure,
                             "NapiAVSessionCallback object is nullptr");
    auto status = napiSession->callback_->RemoveCallback(env, NapiAVSessionCallback::EVENT_DISPLAY_CHANGE, callback);
    CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "RemoveCallback failed");
    CHECK_AND_RETURN_RET_LOG(napiSession->session_ != nullptr, napi_generic_failure,
                             "NapiAVSession object is nullptr");
    napiSession->session_->StopCastDisplayListener();
#else
    return napi_generic_failure;
#endif
    return napi_ok;
}
}