openharmony/multimedia_drm_framework
1
0
Fork 0
mirror of https://github.com/openharmony/multimedia_drm_framework.git synced 2026-07-01 02:07:09 -04:00
Code Issues Packages Projects Releases Wiki Activity

异步接口开发

Browse Source 
Signed-off-by: gezhe <gezhe1@huawei.com>
This commit is contained in:
gezhe
2024-02-07 09:23:53 +08:00
parent c8c1f593d5
commit 32198b8ed5
38 changed files with 1704 additions and 841 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README_zh.md
+3 -3
View File
@@ -55,13 +55,13 @@ DRM框架组件提供以下功能：
~~~js
import drm from '@ohos.multimedia.drm';
~~~
2.判断DRM框架是否支持指定的DRM方案, 示例以'com.drm.clearplay'为例。
2.判断DRM框架是否支持指定的DRM方案, 示例以'com.clearplay.drm'为例。
~~~js
var isSupported = drm.isMediaKeySystemSupported('com.drm.clearplay');
var isSupported = drm.isMediaKeySystemSupported('com.clearplay.drm');
~~~
3.创建MediaKeySystem实例,
~~~js
var keySystem = drm.createMediaKeySystem('com.drm.clearplay');
var keySystem = drm.createMediaKeySystem('com.clearplay.drm');
~~~
4.如无本地DRM证书，需完成证书下载。
~~~js
bundle.json
+3 -2
View File
@@ -20,6 +20,8 @@
"hisysevent_config": [ ],
"deps": {
"components": [
"ability_base",
"ability_runtime",
"safwk",
"napi",
"samgr",
@@ -33,8 +35,7 @@
"hdf_core",
"eventhandler",
"bundle_framework",
"drivers_interface_drm",
"ability_base"
"drivers_interface_drm"
]
},
"build": {
frameworks/c/drm_capi/native_mediakeysession.cpp
+4 -5
View File
@@ -19,7 +19,6 @@
#include <refbase.h>
#include <securec.h>
#include "drm_log.h"
#include "drm_error_code.h"
#include "native_drm_base.h"
#include "native_drm_object.h"
#include "key_session_impl.h"
@@ -68,7 +67,7 @@ Drm_ErrCode OH_MediaKeySession_GenerateMediaKeyRequest(MediaKeySession *mediaKey
}
MediaKeySessionObject *sessionObject = reinterpret_cast<MediaKeySessionObject *>(mediaKeySession);
int ret = sessionObject->sessionImpl_->GenerateMediaKeyRequest(licenseRequestInfo, licenseRequest);
DRM_CHECK_AND_RETURN_RET_LOG((ret == DRM_OK), DRM_ERR_INVALID_VAL,
DRM_CHECK_AND_RETURN_RET_LOG((ret == DRM_ERR_OK), DRM_ERR_INVALID_VAL,
"OH_MediaKeySession_GenerateMediaKeyRequest call Failed!");
Drm_ErrCode result = DealMediaKeyRequest(licenseRequest, mediaKeyRequest);
DRM_INFO_LOG("OH_MediaKeySession_GenerateMediaKeyRequest exit");
@@ -79,7 +78,7 @@ Drm_ErrCode OH_MediaKeySession_ProcessMediaKeyResponse(MediaKeySession *mediaKey
int32_t responseLen, uint8_t *offlineMediaKeyId, int32_t *offlineMediaKeyIdLen)
{
DRM_CHECK_AND_RETURN_RET_LOG(
((mediaKeySession != nullptr) && (response != nullptr) && (responseLen != 0) &&
((mediaKeySession != nullptr) && (response != nullptr) && (responseLen > 0) &&
(offlineMediaKeyId != nullptr) && (offlineMediaKeyIdLen != nullptr)), DRM_ERR_INVALID_VAL,
"params is nullptr!");
MediaKeySessionObject *sessionObject = reinterpret_cast<MediaKeySessionObject *>(mediaKeySession);
@@ -160,7 +159,7 @@ Drm_ErrCode OH_MediaKeySession_GenerateOfflineReleaseRequest(MediaKeySession *me
{
DRM_INFO_LOG("OH_MediaKeySession_GenerateOfflineReleaseRequest enter");
DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySessoin != nullptr) && (offlineMediaKeyId != nullptr) &&
(offlineMediaKeyIdLen != 0) && (releaseRequest != nullptr) && (releaseRequestLen != nullptr)),
(offlineMediaKeyIdLen > 0) && (releaseRequest != nullptr) && (releaseRequestLen != nullptr)),
DRM_ERR_INVALID_VAL, "OH_MediaKeySession_GenerateOfflineReleaseRequest keySession is nullptr!");
std::vector<uint8_t> ReleaseRequest;
std::vector<uint8_t> licenseIdVec(offlineMediaKeyId, offlineMediaKeyId + offlineMediaKeyIdLen);
@@ -189,7 +188,7 @@ Drm_ErrCode OH_MediaKeySession_ProcessOfflineReleaseResponse(MediaKeySession *me
{
DRM_INFO_LOG("OH_MediaKeySession_ProcessOfflineReleaseResponse enter.");
DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySessoin != nullptr) && (offlineMediaKeyId != nullptr) &&
(offlineMediaKeyIdLen != 0) && (releaseReponse != nullptr) && (releaseReponseLen != 0)),
(offlineMediaKeyIdLen > 0) && (releaseReponse != nullptr) && (releaseReponseLen > 0)),
DRM_ERR_INVALID_VAL, "OH_MediaKeySession_ClearMediaKeys keySession is nullptr!");
std::vector<uint8_t> licenseIdVec(offlineMediaKeyId, offlineMediaKeyId + offlineMediaKeyIdLen);
std::vector<uint8_t> responseVec(releaseReponse, releaseReponse + releaseReponseLen);
frameworks/c/drm_capi/native_mediakeysystem.cpp
+7 -8
View File
@@ -19,7 +19,6 @@
#include <refbase.h>
#include <securec.h>
#include "drm_log.h"
#include "drm_error_code.h"
#include "native_drm_common.h"
#include "native_drm_base.h"
#include "native_drm_object.h"
@@ -73,7 +72,7 @@ bool OH_MediaKeySystem_IsSupported3(const char *uuid, const char *mimeType,
IMediaKeySessionService::ContentProtectionLevel securityLevel =
(IMediaKeySessionService::ContentProtectionLevel)ContentProtectionLevel;
if ((securityLevel < IMediaKeySessionService::CONTENT_PROTECTION_LEVEL_UNKNOWN) ||
if ((securityLevel <= IMediaKeySessionService::CONTENT_PROTECTION_LEVEL_UNKNOWN) ||
(securityLevel >= IMediaKeySessionService::CONTENT_PROTECTION_LEVEL_MAX)) {
DRM_ERR_LOG("ContentProtectionLevel is invalid");
return false;
@@ -138,7 +137,7 @@ Drm_ErrCode OH_MediaKeySystem_GetConfigurationString(MediaKeySystem *mediaKeySys
{
DRM_INFO_LOG("OH_GetConfigurationString enter");
DRM_CHECK_AND_RETURN_RET_LOG(
((mediaKeySystem != nullptr) && (configName != nullptr) && (value != nullptr) && (valueLen != 0)),
((mediaKeySystem != nullptr) && (configName != nullptr) && (value != nullptr) && (valueLen > 0)),
DRM_ERR_INVALID_VAL, "OH_GetConfigurationString params is error!");
std::string valuePtr;
@@ -287,7 +286,7 @@ Drm_ErrCode OH_MediaKeySystem_GenerateKeySystemRequest(MediaKeySystem *mediaKeyS
{
DRM_INFO_LOG("OH_MediaKeySystem_GenerateKeySystemRequest enter");
DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (request != nullptr) && (requestLen != nullptr) &&
(defaultUrl != nullptr) && (defaultUrlLen != 0)),
(defaultUrl != nullptr) && (defaultUrlLen > 0)),
DRM_ERR_INVALID_VAL, "OH_MediaKeySystem_GenerateKeySystemRequest mediaKeySystem is nullptr!");
std::vector<uint8_t> requestData;
std::string defaultUrlData;
@@ -316,7 +315,7 @@ Drm_ErrCode OH_MediaKeySystem_ProcessKeySystemResponse(MediaKeySystem *mediaKeyS
uint8_t *response, int32_t responseLen)
{
DRM_INFO_LOG("OH_ProcessKeySystemResponse enter.");
DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (response != nullptr) && (responseLen != 0)),
DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (response != nullptr) && (responseLen > 0)),
DRM_ERR_INVALID_VAL, "OH_ProcessKeySystemResponse mediaKeySystem is nullptr!");
int32_t result = DRM_ERR_OK;
std::vector<uint8_t> keySystemResponse(response, response + responseLen);
@@ -366,7 +365,7 @@ Drm_ErrCode OH_MediaKeySystem_CreateMediaKeySession(MediaKeySystem *mediaKeySyst
MediaKeySession **mediaKeySession)
{
DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (level != nullptr) && (mediaKeySession != nullptr) &&
(*level > CONTENT_PROTECTION_LEVEL_UNKNOWN) && (*level <= CONTENT_PROTECTION_LEVEL_MAX)),
(*level > CONTENT_PROTECTION_LEVEL_UNKNOWN) && (*level < CONTENT_PROTECTION_LEVEL_MAX)),
DRM_ERR_INVALID_VAL, "mediaKeySystem is nullptr!");
struct MediaKeySystemObject *systemObject = reinterpret_cast<MediaKeySystemObject *>(mediaKeySystem);
@@ -442,7 +441,7 @@ Drm_ErrCode OH_MediaKeySystem_GetOfflineMediaKeyStatus(MediaKeySystem *mediaKeyS
{
DRM_INFO_LOG("OH_MediaKeySystem_GetOfflineMediaKeyStatus enter");
DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (offlineMediaKeyId != nullptr) &&
(offlineMediaKeyIdLen != 0) && (status != nullptr)),
(offlineMediaKeyIdLen > 0) && (status != nullptr)),
DRM_ERR_INVALID_VAL, "OH_MediaKeySystem_GetOfflineMediaKeyStatus mediaKeySystem is nullptr!");
int32_t result = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN;
@@ -472,7 +471,7 @@ Drm_ErrCode OH_MediaKeySystem_ClearOfflineMediaKeys(MediaKeySystem *mediaKeySyst
{
DRM_INFO_LOG("OH_RemoveOfflineLMediaKey enter.");
DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (offlineMediaKeyId != nullptr) &&
(offlineMediaKeyIdLen != 0)),
(offlineMediaKeyIdLen > 0)),
DRM_ERR_INVALID_VAL, "OH_GetOfflineMediaKeyStatus mediaKeySystem is nullptr!");
int32_t result = DRM_ERR_OK;
std::vector<uint8_t> licenseIdVec(offlineMediaKeyId, offlineMediaKeyId + offlineMediaKeyIdLen);
frameworks/js/drm_napi/drm_enum_napi.cpp
+1 -1
View File
@@ -15,7 +15,7 @@
#include <map>
#include <vector>
#include "drm_napi_utils.h"
#include "napi_param_utils.h"
#include "drm_enum_napi.h"
namespace OHOS {
frameworks/js/drm_napi/drm_error_code.cpp
+66
View File
@@ -0,0 +1,66 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "drm_error_code.h"
namespace OHOS {
namespace DrmStandard {
napi_status NapiDrmError::ThrowError(napi_env env, const char *napiMessage, int32_t napiCode)
{
napi_value message = nullptr;
napi_value code = nullptr;
napi_value result = nullptr;
napi_create_string_utf8(env, napiMessage, NAPI_AUTO_LENGTH, &message);
napi_create_error(env, nullptr, message, &result);
napi_create_int32(env, napiCode, &code);
napi_set_named_property(env, result, "code", code);
napi_throw(env, result);
return napi_ok;
}
void NapiDrmError::ThrowError(napi_env env, int32_t code)
{
std::string messageValue = GetMessageByCode(code);
napi_throw_error(env, (std::to_string(code)).c_str(), messageValue.c_str());
}
std::string NapiDrmError::GetMessageByCode(int32_t &code)
{
std::string errMessage;
switch (code) {
case DRM_INVALID_PARAM:
errMessage = DRM_INVALID_PARAM_INFO;
break;
case DRM_SERVICE_FATAL_ERROR:
errMessage = DRM_SERVICE_FATAL_ERRO_INFO;
break;
case DRM_UNKNOWN_ERROR:
errMessage = DRM_UNKNOWN_ERROR_INFO;
break;
case DRM_MAX_SYSTEM_NUM_REACHED:
errMessage = DRM_MAX_SYSTEM_NUM_REACHED_INFO;
break;
case DRM_MAX_SESSION_NUM_REACHED:
errMessage = DRM_MAX_SESSION_NUM_REACHED_INFO;
break;
default:
errMessage = DRM_UNKNOWN_ERROR_INFO;
code = DRM_UNKNOWN_ERROR;
break;
}
return errMessage;
}
} // namespace DrmStandard
} // namespace OHOS
frameworks/js/drm_napi/drm_napi.cpp
+1 -1
View File
@@ -14,7 +14,7 @@
*/
#include "ipc_skeleton.h"
#include "drm_napi_utils.h"
#include "napi_param_utils.h"
#include "drm_napi.h"
namespace OHOS {
frameworks/js/drm_napi/key_session_callback_napi.cpp
+102 -106
View File
@@ -14,16 +14,19 @@
*/
#include "drm_log.h"
#include "drm_error_code.h"
#include "drm_napi_utils.h"
#include "key_session_callback_napi.h"
namespace OHOS {
namespace DrmStandard {
MediaKeySessionCallbackNapi::MediaKeySessionCallbackNapi() {}
MediaKeySessionCallbackNapi::MediaKeySessionCallbackNapi(napi_env env)
{
env_ = env;
}
MediaKeySessionCallbackNapi::~MediaKeySessionCallbackNapi() {}
void MediaKeySessionCallbackNapi::SetCallbackReference(const std::string eventType, sptr<CallBackPair> callbackPair)
void MediaKeySessionCallbackNapi::SetCallbackReference(const std::string eventType,
std::shared_ptr<AutoRef> callbackPair)
{
DRM_INFO_LOG("MediaKeySessionCallbackNapi SetCallbackReference");
std::lock_guard<std::mutex> lock(mutex_);
@@ -37,118 +40,111 @@ void MediaKeySessionCallbackNapi::ClearCallbackReference(const std::string event
callbackMap_.erase(eventType);
}
void MediaKeySessionCallbackNapi::SendEvent(const std::string event, int32_t extra, const std::vector<uint8_t> data)
void MediaKeySessionCallbackNapi::WorkCallbackInterruptDone(uv_work_t *work, int status)
{
DRM_INFO_LOG("MediaKeySessionCallbackNapi SendEvent %{public}s", event.c_str());
DRM_NAPI_CHECK_AND_RETURN_LOG(!event.empty(), "Service event code error");
// Js Thread
std::shared_ptr<MediaKeySessionJsCallback> context(static_cast<MediaKeySessionJsCallback *>(work->data),
[work](MediaKeySessionJsCallback *ptr) {
delete ptr;
delete work;
});
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(work != nullptr, "work is nullptr");
MediaKeySessionJsCallback *event = reinterpret_cast<MediaKeySessionJsCallback *>(work->data);
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(event != nullptr, "event is nullptr");
std::string request = event->callbackName;
napi_value result;
napi_value jsCallback = nullptr;
napi_value retVal;
napi_status state;
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(event->callback != nullptr, "event is nullptr");
napi_env env = event->callback->env_;
napi_ref callback = event->callback->cb_;
DRM_NAPI_CHECK_AND_RETURN_LOG(callbackMap_.find(event) != callbackMap_.end(), "Not register this callback yet");
sptr<CallBackPair> item = callbackMap_[event];
napi_handle_scope scope = nullptr;
napi_open_handle_scope(env, &scope);
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(scope != nullptr, "scope is nullptr");
DRM_DEBUG_LOG("JsCallBack %{public}s, uv_queue_work_with_qos start", request.c_str());
do {
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(status != UV_ECANCELED, "%{public}s cancelled", request.c_str());
napi_value jsCallback = nullptr;
napi_status nstatus = napi_get_reference_value(env, callback, &jsCallback);
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(nstatus == napi_ok && jsCallback != nullptr,
"%{public}s get reference value fail", request.c_str());
DRM_NAPI_CHECK_AND_RETURN_LOG(item != nullptr, "sptr callbackPair is nullptr");
napi_env env = item->GetEnv();
napi_ref callbackRef = item->GetCallback();
// Call back function
if (event->callbackName == "keysChange") {
napi_value statusTable;
napi_value hasNewGoodLicense;
nstatus = NapiParamUtils::SetDrmKeysChangeEventInfo(env, event->keysChangeParame,
statusTable, hasNewGoodLicense);
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(nstatus == napi_ok,
"%{public}s fail to create keysession keyschange callback", request.c_str());
napi_value args[ARGS_TWO] = { statusTable, hasNewGoodLicense };
napi_value result = nullptr;
nstatus = napi_call_function(env, nullptr, jsCallback, ARGS_TWO, args, &result);
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(nstatus == napi_ok, "%{public}s fail to call Interrupt callback",
request.c_str());
} else {
napi_value args[ARGS_ONE] = { nullptr };
nstatus = NapiParamUtils::SetDrmEventInfo(env, event->eventParame, args[PARAM0]);
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(nstatus == napi_ok && args[PARAM0] != nullptr,
"%{public}s fail to create keysession callback", request.c_str());
napi_value result = nullptr;
nstatus = napi_call_function(env, nullptr, jsCallback, ARGS_ONE, args, &result);
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(nstatus == napi_ok, "%{public}s fail to call Interrupt callback",
request.c_str());
}
} while (0);
napi_close_handle_scope(env, scope);
}
napi_get_undefined(env, &result);
napi_create_object(env, &result);
napi_value extraValue;
napi_value array = nullptr;
std::string extraData = std::to_string(extra);
napi_create_string_utf8(env, extraData.c_str(), NAPI_AUTO_LENGTH, &extraValue);
state = napi_create_array_with_length(env, data.size(), &array);
DRM_NAPI_CHECK_AND_RETURN_LOG(state == napi_ok, "%{public}s failed to napi_create_array_with_length",
event.c_str());
for (uint32_t i = 0; i < data.size(); i++) {
napi_value number = nullptr;
(void)napi_create_uint32(env, data[i], &number);
(void)napi_set_element(env, array, i, number);
void MediaKeySessionCallbackNapi::SendEvent(const std::string &event, int32_t extra, const std::vector<uint8_t> &data)
{
std::lock_guard<std::mutex> lock(mutex_);
std::unique_ptr<MediaKeySessionJsCallback> cb = std::make_unique<MediaKeySessionJsCallback>();
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(cb != nullptr, "No memory");
cb->callback = callbackMap_[event];
cb->callbackName = event;
cb->eventParame.extra = extra;
cb->eventParame.data.assign(data.begin(), data.end());
return OnJsCallbackInterrupt(cb);
}
void MediaKeySessionCallbackNapi::OnJsCallbackInterrupt(std::unique_ptr<MediaKeySessionJsCallback> &jsCb)
{
uv_loop_s *loop = nullptr;
napi_get_uv_event_loop(env_, &loop);
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(loop != nullptr, "loop nullptr, No memory");
uv_work_t *work = new (std::nothrow) uv_work_t;
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(work != nullptr, "work nullptr, No memory");
if (jsCb.get() == nullptr) {
DRM_DEBUG_LOG("OnJsCallBackInterrupt: jsCb.get() is null");
delete work;
return;
}
work->data = reinterpret_cast<void *>(jsCb.get());
int ret = uv_queue_work_with_qos(
loop, work, [](uv_work_t *work) {}, WorkCallbackInterruptDone, uv_qos_default);
if (ret != 0) {
DRM_DEBUG_LOG("Failed to execute libuv work queue");
delete work;
} else {
jsCb.release();
}
napi_value args[1] = { nullptr };
napi_create_object(env, &args[0]);
napi_set_named_property(env, args[0], "info", array);
napi_set_named_property(env, args[0], "extraInfo", extraValue);
napi_get_reference_value(env, callbackRef, &jsCallback);
state = napi_call_function(env, nullptr, jsCallback, ARGS_ONE, args, &retVal);
DRM_NAPI_CHECK_AND_RETURN_LOG(state == napi_ok, "%{public}s failed to napi_call_function", event.c_str());
}
void MediaKeySessionCallbackNapi::SendEventKeyChanged(
std::map<std::vector<uint8_t>, MediaKeySessionKeyStatus> statusTable, bool hasNewGoodLicense)
{
DRM_INFO_LOG("MediaKeySessionCallbackNapi SendEventKeyChanged");
napi_value result;
napi_value jsCallback = nullptr;
napi_value retVal;
napi_status state;
DRM_NAPI_CHECK_AND_RETURN_LOG(callbackMap_.find("keysChange") != callbackMap_.end(),
"Not register this callback yet");
sptr<CallBackPair> item = callbackMap_["keysChange"];
DRM_NAPI_CHECK_AND_RETURN_LOG(item != nullptr, "sptr callbackPair is nullptr");
napi_env env = item->GetEnv();
napi_ref callbackRef = item->GetCallback();
napi_get_undefined(env, &result);
napi_create_object(env, &result);
uint32_t index = 0;
napi_value map;
napi_create_array_with_length(env, statusTable.size(), &map);
for (auto itemTmp : statusTable) {
napi_value jsObject;
napi_value jsKeyId;
napi_value jsKeyStatus;
napi_create_object(env, &jsObject);
state = napi_create_array_with_length(env, itemTmp.first.size(), &jsKeyId);
DRM_NAPI_CHECK_AND_RETURN_LOG(state == napi_ok, "failed to call napi_create_array_with_length");
for (uint32_t i = 0; i < itemTmp.first.size(); i++) {
napi_value number = nullptr;
(void)napi_create_uint32(env, itemTmp.first[i], &number);
(void)napi_set_element(env, jsKeyId, i, number);
}
napi_set_named_property(env, jsObject, "keyId", jsKeyId);
std::string value;
switch (itemTmp.second) {
case MEDIA_KEY_SESSION_KEY_STATUS_USABLE:
value = "USABLE";
break;
case MEDIA_KEY_SESSION_KEY_STATUS_EXPIRED:
value = "EXPIRED";
break;
case MEDIA_KEY_SESSION_KEY_STATUS_OUTPUT_NOT_ALLOWED:
value = "OUTPUT_NOT_ALLOWED";
break;
case MEDIA_KEY_SESSION_KEY_STATUS_PENDING:
value = "PENDING";
break;
case MEDIA_KEY_SESSION_KEY_STATUS_INTERNAL_ERROR:
value = "INTERNAL_ERROR";
break;
case MEDIA_KEY_SESSION_KEY_STATUS_USABLE_IN_FUTURE:
value = "USABLE_IN_FUTURE";
break;
default:
value = "Fault Status";
break;
}
napi_create_string_utf8(env, value.c_str(), NAPI_AUTO_LENGTH, &jsKeyStatus);
napi_set_named_property(env, jsObject, "value", jsKeyStatus);
napi_set_element(env, map, index, jsObject);
index++;
}
napi_value hasNewGoodLicenseValue;
napi_get_boolean(env, hasNewGoodLicense, &hasNewGoodLicenseValue);
napi_value args[ARGS_TWO] = {map, hasNewGoodLicenseValue};
napi_get_reference_value(env, callbackRef, &jsCallback);
state = napi_call_function(env, nullptr, jsCallback, ARGS_TWO, args, &retVal);
DRM_NAPI_CHECK_AND_RETURN_LOG(state == napi_ok, "failed to napi_call_function keysChange");
std::lock_guard<std::mutex> lock(mutex_);
std::unique_ptr<MediaKeySessionJsCallback> cb = std::make_unique<MediaKeySessionJsCallback>();
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(cb != nullptr, "No memory");
const std::string event = "keysChange";
cb->callback = callbackMap_[event];
cb->callbackName = event;
cb->keysChangeParame.hasNewGoodLicense = hasNewGoodLicense;
cb->keysChangeParame.statusTable = statusTable;
return OnJsCallbackInterrupt(cb);
}
}
}
} // DrmStandardr
} // OHOS
frameworks/js/drm_napi/key_session_napi.cpp
+222 -310
View File
@@ -13,7 +13,7 @@
* limitations under the License.
*/
#include "ipc_skeleton.h"
#include "drm_napi_utils.h"
#include "napi_param_utils.h"
#include "key_session_impl.h"
#include "media_key_system_impl.h"
#include "key_session_napi.h"
@@ -100,17 +100,19 @@ napi_value MediaKeySessionNapi::MediaKeySessionNapiConstructor(napi_env env, nap
return result;
}
obj->keySessionImpl_ = sMediaKeySessionImpl_;
obj->keySessionCallbackNapi_ = new MediaKeySessionCallbackNapi();
obj->keySessionCallbackNapi_ = new MediaKeySessionCallbackNapi(env);
obj->keySessionImpl_->SetCallback(obj->keySessionCallbackNapi_);
status = napi_wrap(env, thisVar, reinterpret_cast<void *>(obj.get()),
MediaKeySessionNapi::MediaKeySessionNapiDestructor, nullptr, nullptr);
if (status == napi_ok) {
ObjectRefMap<MediaKeySessionNapi>::Insert(obj.get());
obj.release();
const std::string propertyName = "MediaKeySessionNative";
SetMediaKeySessionNativeProperty(env, thisVar, propertyName, sMediaKeySessionImpl_);
return thisVar;
} else {
ObjectRefMap<MediaKeySessionNapi>::Erase(obj.get());
DRM_ERR_LOG("MediaKeySessionNapi Failure wrapping js to native napi");
}
}
@@ -123,10 +125,7 @@ void MediaKeySessionNapi::MediaKeySessionNapiDestructor(napi_env env, void *nati
{
DRM_INFO_LOG("MediaKeySessionNapi::MediaKeySessionNapiDestructor enter.");
MediaKeySessionNapi *keySessionNapiObj = reinterpret_cast<MediaKeySessionNapi *>(nativeObject);
if (keySessionNapiObj != nullptr) {
keySessionNapiObj->~MediaKeySessionNapi();
keySessionNapiObj = nullptr;
}
ObjectRefMap<MediaKeySessionNapi>::DecreaseRef(keySessionNapiObj);
DRM_INFO_LOG("MediaKeySessionNapi::MediaKeySessionNapiDestructor exit.");
}
@@ -200,312 +199,200 @@ napi_value MediaKeySessionNapi::Destroy(napi_env env, napi_callback_info info)
napi_get_undefined(env, &result);
status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&keySessionNapi));
if (status == napi_ok && keySessionNapi != nullptr && keySessionNapi->keySessionImpl_ != nullptr) {
keySessionNapi->keySessionImpl_->Release();
keySessionNapi->~MediaKeySessionNapi();
keySessionNapi = nullptr;
int32_t ret = keySessionNapi->keySessionImpl_->Release();
if (ret != DRM_OK) {
DRM_ERR_LOG("keySessionImpl_ Release call Failed!");
NapiDrmError::ThrowError(env, "Release failed.", DRM_SERVICE_FATAL_ERROR);
return nullptr;
}
} else {
DRM_ERR_LOG("MediaKeySessionNapi Release call Failed!");
NapiDrmError::ThrowError(env, "Release failed.", DRM_UNKNOWN_ERROR);
return nullptr;
}
DRM_INFO_LOG("MediaKeySessionNapi::Release exit.");
return result;
}
static napi_value DealMediaKeyRequest(napi_env env, IMediaKeySessionService::MediaKeyRequest &licenseRequest)
bool MediaKeySessionNapi::CheckMediaKeySessionStatus(MediaKeySessionNapi *napi,
std::shared_ptr<MediaKeySessionAsyncContext> context)
{
const char *requestTypeEnum;
napi_value requestType;
napi_value mData;
napi_value mDefaultURL;
napi_value result = nullptr;
if (licenseRequest.requestType == IMediaKeySessionService::REQUEST_TYPE_UNKNOWN) {
requestTypeEnum = "MEDIA_KEY_REQUEST_TYPE_UNKNOWN";
} else if (licenseRequest.requestType == IMediaKeySessionService::REQUEST_TYPE_INITIAL) {
requestTypeEnum = "MEDIA_KEY_REQUEST_TYPE_INITIAL";
} else if (licenseRequest.requestType == IMediaKeySessionService::REQUEST_TYPE_RENEWAL) {
requestTypeEnum = "MEDIA_KEY_REQUEST_TYPE_RENEWAL";
} else if (licenseRequest.requestType == IMediaKeySessionService::REQUEST_TYPE_RELEASE) {
requestTypeEnum = "MEDIA_KEY_REQUEST_TYPE_RELEASE";
} else if (licenseRequest.requestType == IMediaKeySessionService::REQUEST_TYPE_NONE) {
requestTypeEnum = "MEDIA_KEY_REQUEST_TYPE_NONE";
} else if (licenseRequest.requestType == IMediaKeySessionService::REQUEST_TYPE_UPDATE) {
requestTypeEnum = "MEDIA_KEY_REQUEST_TYPE_UPDATE";
} else if (licenseRequest.requestType < IMediaKeySessionService::REQUEST_TYPE_UNKNOWN ||
licenseRequest.requestType > IMediaKeySessionService::REQUEST_TYPE_UPDATE) {
DRM_ERR_LOG("Do not understand licenseRequest.requestType enum!");
return result;
DRM_NAPI_CHECK_AND_RETURN_LOG(napi != nullptr, false, "napi object is nullptr.");
if (napi->keySessionImpl_ == nullptr) {
context->SignError(DRM_SERVICE_FATAL_ERROR);
return false;
}
napi_status status = napi_create_string_utf8(env, requestTypeEnum, NAPI_AUTO_LENGTH, &requestType);
if (status != napi_ok) {
DRM_ERR_LOG("requestType error!");
return result;
}
napi_create_object(env, &result);
napi_set_named_property(env, result, "mediaKeyRequestType", requestType);
size_t mDataLen = licenseRequest.mData.size();
NAPI_CALL(env, napi_create_array(env, &mData));
for (size_t i = 0; i < mDataLen; i++) {
napi_value item;
napi_create_int32(env, licenseRequest.mData[i], &item);
napi_set_element(env, mData, i, item);
}
napi_set_named_property(env, result, "data", mData);
status = napi_create_string_utf8(env, licenseRequest.mDefaultURL.c_str(), NAPI_AUTO_LENGTH, &mDefaultURL);
if (status != napi_ok) {
DRM_ERR_LOG("mDefaultURL error!");
return result;
}
napi_set_named_property(env, result, "defaultURL", mDefaultURL);
return result;
return true;
}
static napi_status FillTmpOptionalData(napi_env env, napi_value *argv, uint32_t optionalDataCount,
std::map<std::string, std::string> &tmpOptionalData)
bool MediaKeySessionNapi::CheckContextStatus(std::shared_ptr<MediaKeySessionAsyncContext> context)
{
napi_status status = napi_ok;
if (optionalDataCount > 0) {
for (size_t i = 0; i < optionalDataCount; i++) {
napi_value tmpData;
napi_value tmpName;
napi_value tmpValue;
size_t nameLength = 0;
size_t valueLength = 0;
status = napi_get_element(env, argv[PARAM3], i, &tmpData);
DRM_CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "Could not able to read optionalData element!");
status = napi_get_named_property(env, tmpData, "name", &tmpName);
DRM_CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "Could not able to read optionalData property!");
status = napi_get_named_property(env, tmpData, "value", &tmpValue);
DRM_CHECK_AND_RETURN_RET_LOG(status == napi_ok, status, "Could not able to read optionalData property!");
status = napi_get_value_string_utf8(env, tmpName, nullptr, 0, &nameLength);
DRM_CHECK_AND_RETURN_RET_LOG(status == napi_ok, status,
"Could not able to transfer optionalData buffer info!");
status = napi_get_value_string_utf8(env, tmpValue, nullptr, 0, &valueLength);
DRM_CHECK_AND_RETURN_RET_LOG(status == napi_ok, status,
"Could not able to transfer optionalData buffer info!");
std::string name(nameLength, 0);
status = napi_get_value_string_utf8(env, tmpName, &name[0], nameLength + 1, &nameLength);
DRM_CHECK_AND_RETURN_RET_LOG(status == napi_ok, status,
"Could not able to transfer optionalData buffer info!");
std::string value(valueLength, 0);
status = napi_get_value_string_utf8(env, tmpValue, &value[0], valueLength + 1, &valueLength);
DRM_CHECK_AND_RETURN_RET_LOG(status == napi_ok, status,
"Could not able to transfer optionalData buffer info!");
DRM_INFO_LOG("%{public}s: name : %{public}s", __func__, name.c_str());
DRM_INFO_LOG("%{public}s: value : %{public}s", __func__, value.c_str());
tmpOptionalData.insert(std::make_pair(name, value));
}
DRM_NAPI_CHECK_AND_RETURN_LOG(context != nullptr, false, "context object is nullptr.");
if (context->native == nullptr) {
context->SignError(DRM_SERVICE_FATAL_ERROR);
return false;
}
return status;
return true;
}
napi_value MediaKeySessionNapi::GenerateMediaKeyRequest(napi_env env, napi_callback_info info)
{
DRM_INFO_LOG("MediaKeySessionNapi::GenerateMediaKeyRequest enter");
auto context = std::make_shared<MediaKeySessionAsyncContext>();
if (context == nullptr) {
DRM_ERR_LOG("GenerateMediaKeyRequest failed.");
NapiDrmError::ThrowError(env, "GenerateMediaKeyRequest failed.", DRM_UNKNOWN_ERROR);
return NapiParamUtils::GetUndefinedValue(env);
}
size_t argc = ARGS_FOUR;
napi_value argv[ARGS_FOUR] = {0};
napi_value thisVar = nullptr;
napi_status status;
char buffer[PATH_MAX];
size_t length = 0;
bool isTypeArray;
void *initData = nullptr;
size_t initDataLen;
size_t offset;
napi_value arraybuffer = nullptr;
napi_typedarray_type type;
auto inputParser = [env, context](size_t argc, napi_value *argv) {
NAPI_CHECK_ARGS_RETURN_VOID(context, argc <= ARGS_FOUR, "invalid arguments", DRM_INVALID_PARAM);
context->mediaKeyRequestInfo.mimeType = NapiParamUtils::GetStringArgument(env, argv[PARAM0]);
context->status = NapiParamUtils::GetValueUint8Array(env, context->mediaKeyRequestInfo.initData, argv[PARAM1]);
NAPI_CHECK_STATUS_RETURN_VOID(context, "generateMediaKeyRequest failed!", DRM_INVALID_PARAM);
int32_t mediaKeyType = 0;
context->status = NapiParamUtils::GetValueInt32(env, mediaKeyType, argv[PARAM2]);
NAPI_CHECK_STATUS_RETURN_VOID(context, "generateMediaKeyRequest failed!", DRM_INVALID_PARAM);
context->mediaKeyRequestInfo.mediaKeyType = (IMediaKeySessionService::MediaKeyType)mediaKeyType;
context->status =
NapiParamUtils::GetValueOptionsData(env, context->mediaKeyRequestInfo.optionalData, argv[PARAM3]);
NAPI_CHECK_STATUS_RETURN_VOID(context, "generateMediaKeyRequest failed!", DRM_INVALID_PARAM);
};
context->GetCbInfo(env, info, inputParser);
IMediaKeySessionService::MediaKeyRequestInfo licenseRequestInfo;
IMediaKeySessionService::MediaKeyRequest licenseRequest;
MediaKeySessionNapi *keySessionNapi = nullptr;
auto executor = [context]() {
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(CheckContextStatus(context), "context object state is error.");
auto obj = reinterpret_cast<MediaKeySessionNapi *>(context->native);
ObjectRefMap objectGuard(obj);
auto *napiMediaKeySession = objectGuard.GetPtr();
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(CheckMediaKeySessionStatus(napiMediaKeySession, context),
"MediaKeySession state is error.");
context->intValue = napiMediaKeySession->keySessionImpl_->GenerateMediaKeyRequest(context->mediaKeyRequestInfo,
context->mediaKeyRequest);
if (context->intValue != DRM_OK) {
context->SignError(DRM_SERVICE_FATAL_ERROR);
}
};
DRM_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
NAPI_ASSERT(env, argc <= ARGS_FOUR, "requires 4 parameters maximum");
DRM_CHECK_AND_RETURN_RET_LOG(napi_get_value_string_utf8(env, argv[PARAM0], buffer, PATH_MAX, &length) == napi_ok,
nullptr, "Could not able to read mimeType argument!");
napi_is_typedarray(env, argv[PARAM1], &isTypeArray);
DRM_CHECK_AND_RETURN_RET_LOG(isTypeArray, nullptr, "argv[PARAM1] is not array!");
napi_get_typedarray_info(env, argv[PARAM1], &type, &initDataLen, &initData, &arraybuffer, &offset);
DRM_CHECK_AND_RETURN_RET_LOG(initData != nullptr, nullptr, "napi_get_typedarray_info faild!");
uint8_t *initDataPtr = reinterpret_cast<uint8_t *>(initData);
std::vector<uint8_t> initDataStr(initDataPtr, initDataPtr + initDataLen);
int32_t licenseType = 0;
status = napi_get_value_int32(env, argv[PARAM2], &licenseType);
DRM_CHECK_AND_RETURN_RET_LOG(status == napi_ok, nullptr, "Could not able to read licenseType argument!");
// optional data
std::map<std::string, std::string> tmpOptionalData;
uint32_t optionalDataCount = 0;
status = napi_get_array_length(env, argv[PARAM3], &optionalDataCount);
DRM_CHECK_AND_RETURN_RET_LOG(status == napi_ok, nullptr, "Could not able to read optionalData argument!");
status = FillTmpOptionalData(env, argv, optionalDataCount, tmpOptionalData);
DRM_CHECK_AND_RETURN_RET_LOG(status == napi_ok, nullptr, "FillTmpOptionalData faild!");
licenseRequestInfo.mediaKeyType = (IMediaKeySessionService::MediaKeyType)licenseType;
licenseRequestInfo.mimeType = std::string(buffer);
licenseRequestInfo.initData = initDataStr;
licenseRequestInfo.optionalData = tmpOptionalData;
status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&keySessionNapi));
DRM_CHECK_AND_RETURN_RET_LOG((keySessionNapi != nullptr && keySessionNapi->keySessionImpl_ != nullptr), nullptr,
"MediaKeySessionNapi get keySessionNapi fail!");
int32_t ret = keySessionNapi->keySessionImpl_->GenerateMediaKeyRequest(licenseRequestInfo, licenseRequest);
DRM_CHECK_AND_RETURN_RET_LOG((ret == DRM_OK), nullptr, "MediaKeySessionNapi GenerateMediaKeyRequest call Failed!");
napi_value result = DealMediaKeyRequest(env, licenseRequest);
DRM_INFO_LOG("MediaKeySessionNapi::GenerateMediaKeyRequest exit");
return result;
auto complete = [env, context](napi_value &output) {
NapiParamUtils::SetMediaKeyRequest(env, context->mediaKeyRequest, output);
};
DRM_INFO_LOG("MediaKeySessionNapi::GenerateMediaKeyRequest exit.");
return NapiAsyncWork::Enqueue(env, context, "GenerateMediaKeyRequest", executor, complete);
}
napi_value MediaKeySessionNapi::ProcessMediaKeyResponse(napi_env env, napi_callback_info info)
{
DRM_INFO_LOG("MediaKeySessionNapi::ProcessMediaKeyResponse enter.");
napi_value result = nullptr;
size_t argc = ARGS_ONE;
napi_value argv[ARGS_ONE] = {0};
napi_value thisVar = nullptr;
napi_status status;
bool isTypeArray;
void *reponseData = nullptr;
size_t reponseDataLen;
size_t offset;
napi_value arraybuffer = nullptr;
napi_typedarray_type type;
std::vector<uint8_t> licenseId;
MediaKeySessionNapi *keySessionNapi = nullptr;
DRM_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
NAPI_ASSERT(env, argc <= ARGS_ONE, "requires 1 parameters maximum");
napi_is_typedarray(env, argv[PARAM0], &isTypeArray);
if (!isTypeArray) {
DRM_ERR_LOG("reponse is not array! ");
return nullptr;
auto context = std::make_shared<MediaKeySessionAsyncContext>();
if (context == nullptr) {
DRM_ERR_LOG("ProcessMediaKeyResponse failed.");
NapiDrmError::ThrowError(env, "ProcessMediaKeyResponse failed.", DRM_UNKNOWN_ERROR);
return NapiParamUtils::GetUndefinedValue(env);
}
napi_get_typedarray_info(env, argv[PARAM0], &type, &reponseDataLen, &reponseData, &arraybuffer, &offset);
if (reponseData == nullptr) {
DRM_ERR_LOG("napi_get_typedarray_info faild! Could not able to read reponseData argument!");
return nullptr;
}
uint8_t *reponseDataPtr = reinterpret_cast<uint8_t *>(reponseData);
std::vector<uint8_t> licenseResponse(reponseDataPtr, reponseDataPtr + reponseDataLen);
status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&keySessionNapi));
if (status == napi_ok && keySessionNapi != nullptr && keySessionNapi->keySessionImpl_ != nullptr) {
int32_t ret = keySessionNapi->keySessionImpl_->ProcessMediaKeyResponse(licenseId, licenseResponse);
DRM_CHECK_AND_RETURN_RET_LOG((ret == DRM_OK), nullptr,
"MediaKeySessionNapi ProcessMediaKeyResponse call Failed!");
size_t licenseIdLen = licenseId.size();
NAPI_CALL(env, napi_create_array(env, &result));
for (size_t i = 0; i < licenseIdLen; i++) {
napi_value item;
napi_create_int32(env, licenseId[i], &item);
napi_set_element(env, result, i, item);
auto inputParser = [env, context](size_t argc, napi_value *argv) {
NAPI_CHECK_ARGS_RETURN_VOID(context, argc == ARGS_ONE, "invalid arguments", DRM_INVALID_PARAM);
context->status = NapiParamUtils::GetValueUint8Array(env, context->response, argv[PARAM0]);
NAPI_CHECK_STATUS_RETURN_VOID(context, "ProcessMediaKeyResponse failed!", DRM_INVALID_PARAM);
};
context->GetCbInfo(env, info, inputParser);
auto executor = [context]() {
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(CheckContextStatus(context), "context object state is error.");
auto obj = reinterpret_cast<MediaKeySessionNapi *>(context->native);
ObjectRefMap objectGuard(obj);
auto *napiMediaKeySession = objectGuard.GetPtr();
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(CheckMediaKeySessionStatus(napiMediaKeySession, context),
"MediaKeySession state is error.");
context->intValue =
napiMediaKeySession->keySessionImpl_->ProcessMediaKeyResponse(context->licenseId, context->response);
if (context->intValue != DRM_OK) {
context->SignError(DRM_SERVICE_FATAL_ERROR);
}
} else {
DRM_ERR_LOG("MediaKeySessionNapi ProcessMediaKeyResponse call Failed!");
}
};
auto complete = [env, context](napi_value &output) {
NapiParamUtils::SetValueUint8Array(env, context->licenseId, output);
};
DRM_INFO_LOG("MediaKeySessionNapi::ProcessMediaKeyResponse exit.");
return result;
return NapiAsyncWork::Enqueue(env, context, "ProcessMediaKeyResponse", executor, complete);
}
napi_value MediaKeySessionNapi::GenerateOfflineReleaseRequest(napi_env env, napi_callback_info info)
{
DRM_INFO_LOG("MediaKeySessionNapi::GenerateOfflineReleaseRequest enter");
napi_value result = nullptr;
size_t argc = ARGS_ONE;
napi_value argv[ARGS_ONE] = {0};
napi_value thisVar = nullptr;
napi_status status;
bool isTypeArray;
void *licenseId = nullptr;
size_t licenseIdLen;
size_t offset;
napi_value arraybuffer = nullptr;
napi_typedarray_type type;
std::vector<uint8_t> releaseRequest;
MediaKeySessionNapi *keySessionNapi = nullptr;
DRM_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
NAPI_ASSERT(env, argc <= ARGS_ONE, "requires 1 parameters maximum");
napi_is_typedarray(env, argv[PARAM0], &isTypeArray);
if (!isTypeArray) {
DRM_ERR_LOG("licenseId is not array!");
return nullptr;
}
napi_get_typedarray_info(env, argv[PARAM0], &type, &licenseIdLen, &licenseId, &arraybuffer, &offset);
if (licenseId == nullptr) {
DRM_ERR_LOG("napi_get_typedarray_info faild! Could not able to read licenseId argument!");
return nullptr;
}
uint8_t *licenseIdPtr = reinterpret_cast<uint8_t *>(licenseId);
std::vector<uint8_t> licenseIdVec(licenseIdPtr, licenseIdPtr + licenseIdLen);
status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&keySessionNapi));
if (status == napi_ok && keySessionNapi != nullptr && keySessionNapi->keySessionImpl_ != nullptr) {
int32_t ret = keySessionNapi->keySessionImpl_->GenerateOfflineReleaseRequest(licenseIdVec, releaseRequest);
DRM_CHECK_AND_RETURN_RET_LOG((ret == DRM_OK), nullptr,
"MediaKeySessionNapi GenerateOfflineReleaseRequest call Failed!");
} else {
DRM_ERR_LOG("MediaKeySessionNapi ProcessMediaKeyResponse call Failed!");
return nullptr;
auto context = std::make_shared<MediaKeySessionAsyncContext>();
if (context == nullptr) {
DRM_ERR_LOG("GenerateOfflineReleaseRequest failed.");
NapiDrmError::ThrowError(env, "GenerateOfflineReleaseRequest failed.", DRM_UNKNOWN_ERROR);
return NapiParamUtils::GetUndefinedValue(env);
}
size_t releaseRequestLen = releaseRequest.size();
NAPI_CALL(env, napi_create_array(env, &result));
for (size_t i = 0; i < releaseRequestLen; i++) {
napi_value item;
napi_create_int32(env, releaseRequest[i], &item);
napi_set_element(env, result, i, item);
}
auto inputParser = [env, context](size_t argc, napi_value *argv) {
NAPI_CHECK_ARGS_RETURN_VOID(context, argc == ARGS_ONE, "invalid arguments", DRM_INVALID_PARAM);
context->status = NapiParamUtils::GetValueUint8Array(env, context->releaseLicenseId, argv[PARAM0]);
NAPI_CHECK_STATUS_RETURN_VOID(context, "GenerateOfflineReleaseRequest failed", DRM_INVALID_PARAM);
};
context->GetCbInfo(env, info, inputParser);
DRM_INFO_LOG("MediaKeySessionNapi::GenerateOfflineReleaseRequest exit");
return result;
auto executor = [context]() {
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(CheckContextStatus(context), "context object state is error.");
auto obj = reinterpret_cast<MediaKeySessionNapi *>(context->native);
ObjectRefMap objectGuard(obj);
auto *napiMediaKeySession = objectGuard.GetPtr();
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(CheckMediaKeySessionStatus(napiMediaKeySession, context),
"MediaKeySession state is error.");
context->intValue = napiMediaKeySession->keySessionImpl_->GenerateOfflineReleaseRequest(
context->releaseLicenseId, context->releaseRequest);
if (context->intValue != DRM_OK) {
context->SignError(DRM_SERVICE_FATAL_ERROR);
}
};
auto complete = [env, context](napi_value &output) {
NapiParamUtils::SetValueUint8Array(env, context->releaseRequest, output);
};
DRM_INFO_LOG("MediaKeySessionNapi::GenerateOfflineReleaseRequest exit.");
return NapiAsyncWork::Enqueue(env, context, "GenerateOfflineReleaseRequest", executor, complete);
}
napi_value MediaKeySessionNapi::ProcessOfflineReleaseResponse(napi_env env, napi_callback_info info)
{
DRM_INFO_LOG("MediaKeySessionNapi::ProcessOfflineReleaseResponse enter.");
napi_value result = nullptr;
size_t argc = ARGS_TWO;
napi_value argv[ARGS_TWO] = {0};
napi_value thisVar = nullptr;
napi_status status;
bool isTypeArray;
void *licenseId = nullptr;
size_t licenseIdLen;
size_t offset;
napi_value arraybuffer = nullptr;
napi_typedarray_type type;
void *response = nullptr;
size_t responseLen;
auto context = std::make_shared<MediaKeySessionAsyncContext>();
if (context == nullptr) {
DRM_ERR_LOG("ProcessOfflineReleaseResponse failed.");
NapiDrmError::ThrowError(env, "ProcessOfflineReleaseResponse failed.", DRM_UNKNOWN_ERROR);
return NapiParamUtils::GetUndefinedValue(env);
}
DRM_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
NAPI_ASSERT(env, argc <= ARGS_TWO, "requires 2 parameters maximum");
auto inputParser = [env, context](size_t argc, napi_value *argv) {
NAPI_CHECK_ARGS_RETURN_VOID(context, argc == ARGS_TWO, "invalid arguments", DRM_INVALID_PARAM);
context->status = NapiParamUtils::GetValueUint8Array(env, context->releaseResponseLicenseId, argv[PARAM0]);
NAPI_CHECK_STATUS_RETURN_VOID(context, "GetValueUint8Array failed", DRM_INVALID_PARAM);
context->status = NapiParamUtils::GetValueUint8Array(env, context->releaseResponse, argv[PARAM1]);
NAPI_CHECK_STATUS_RETURN_VOID(context, "ProcessOfflineReleaseResponse failed", DRM_INVALID_PARAM);
};
context->GetCbInfo(env, info, inputParser);
napi_is_typedarray(env, argv[PARAM0], &isTypeArray);
DRM_CHECK_AND_RETURN_RET_LOG(isTypeArray, nullptr, "argv[PARAM0] is not array!");
napi_get_typedarray_info(env, argv[PARAM0], &type, &licenseIdLen, &licenseId, &arraybuffer, &offset);
DRM_CHECK_AND_RETURN_RET_LOG(licenseId != nullptr, nullptr, "napi_get_typedarray_info faild!");
uint8_t *licenseIdPtr = reinterpret_cast<uint8_t *>(licenseId);
std::vector<uint8_t> licenseIdVec(licenseIdPtr, licenseIdPtr + licenseIdLen);
napi_is_typedarray(env, argv[PARAM1], &isTypeArray);
DRM_CHECK_AND_RETURN_RET_LOG(isTypeArray, nullptr, "argv[PARAM1] is not array!");
napi_get_typedarray_info(env, argv[PARAM1], &type, &responseLen, &response, &arraybuffer, &offset);
DRM_CHECK_AND_RETURN_RET_LOG(response != nullptr, nullptr, "napi_get_typedarray_info faild!");
uint8_t *responsePtr = reinterpret_cast<uint8_t *>(response);
std::vector<uint8_t> responseVec(responsePtr, responsePtr + responseLen);
MediaKeySessionNapi *keySessionNapi = nullptr;
status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&keySessionNapi));
DRM_CHECK_AND_RETURN_RET_LOG((keySessionNapi != nullptr && keySessionNapi->keySessionImpl_ != nullptr), nullptr,
"MediaKeySessionNapi get keySessionNapi fail!");
int32_t ret = keySessionNapi->keySessionImpl_->ProcessOfflineReleaseResponse(licenseIdVec, responseVec);
DRM_CHECK_AND_RETURN_RET_LOG((ret == DRM_OK), nullptr,
"MediaKeySessionNapi ProcessOfflineReleaseResponse call Failed!");
auto executor = [context]() {
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(CheckContextStatus(context), "context object state is error.");
auto obj = reinterpret_cast<MediaKeySessionNapi *>(context->native);
ObjectRefMap objectGuard(obj);
auto *napiMediaKeySession = objectGuard.GetPtr();
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(CheckMediaKeySessionStatus(napiMediaKeySession, context),
"MediaKeySession state is error.");
context->intValue = napiMediaKeySession->keySessionImpl_->ProcessOfflineReleaseResponse(
context->releaseResponseLicenseId, context->releaseResponse);
if (context->intValue != DRM_OK) {
context->SignError(DRM_SERVICE_FATAL_ERROR);
}
};
auto complete = [env, context](napi_value &output) { output = NapiParamUtils::GetUndefinedValue(env); };
DRM_INFO_LOG("MediaKeySessionNapi::ProcessOfflineReleaseResponse exit.");
return result;
return NapiAsyncWork::Enqueue(env, context, "ProcessOfflineReleaseResponse", executor, complete);
}
static napi_value vectorToJsArray(napi_env env, std::map<std::string, std::string> &licenseStatus)
@@ -550,10 +437,14 @@ napi_value MediaKeySessionNapi::CheckMediaKeyStatus(napi_env env, napi_callback_
DRM_CHECK_AND_RETURN_RET_LOG((ret == DRM_OK), nullptr, "MediaKeySessionNapi CheckMediaKeyStatus call Failed!");
} else {
DRM_ERR_LOG("MediaKeySessionNapi CheckMediaKeyStatus call Failed!");
NapiDrmError::ThrowError(env, "MediaKeySessionNapi CheckMediaKeyStatus call Failed!", DRM_UNKNOWN_ERROR);
return nullptr;
}
if (licenseStatus.size() == 0) {
DRM_ERR_LOG("Licence not exist.");
NapiDrmError::ThrowError(env, "MediaKeySessionNapi CheckMediaKeyStatus call Failed!",
DRM_SERVICE_FATAL_ERROR);
return nullptr;
}
result = vectorToJsArray(env, licenseStatus);
@@ -564,45 +455,36 @@ napi_value MediaKeySessionNapi::CheckMediaKeyStatus(napi_env env, napi_callback_
napi_value MediaKeySessionNapi::RestoreOfflineMediaKeys(napi_env env, napi_callback_info info)
{
DRM_INFO_LOG("MediaKeySessionNapi::RestoreOfflineMediaKeys enter.");
napi_value result = nullptr;
size_t argc = ARGS_ONE;
napi_value argv[ARGS_ONE] = {0};
napi_value thisVar = nullptr;
napi_status status;
bool isTypeArray;
void *licenseId = nullptr;
size_t licenseIdLen;
size_t offset;
napi_value arraybuffer = nullptr;
napi_typedarray_type type;
MediaKeySessionNapi *keySessionNapi = nullptr;
DRM_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
NAPI_ASSERT(env, argc <= ARGS_ONE, "requires 1 parameters maximum");
napi_is_typedarray(env, argv[PARAM0], &isTypeArray);
if (!isTypeArray) {
DRM_ERR_LOG("licenseId is not array!");
return nullptr;
}
napi_get_typedarray_info(env, argv[PARAM0], &type, &licenseIdLen, &licenseId, &arraybuffer, &offset);
if (licenseId == nullptr) {
DRM_ERR_LOG("napi_get_typedarray_info faild! Could not able to read licenseId argument!");
return nullptr;
}
uint8_t *licenseIdPtr = reinterpret_cast<uint8_t *>(licenseId);
std::vector<uint8_t> licenseIdVec(licenseIdPtr, licenseIdPtr + licenseIdLen);
status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&keySessionNapi));
if (status == napi_ok && keySessionNapi != nullptr && keySessionNapi->keySessionImpl_ != nullptr) {
int32_t ret = keySessionNapi->keySessionImpl_->RestoreOfflineMediaKeys(licenseIdVec);
DRM_CHECK_AND_RETURN_RET_LOG((ret == DRM_OK), nullptr,
"MediaKeySessionNapi RestoreOfflineMediaKeys call Failed!");
} else {
DRM_ERR_LOG("MediaKeySessionNapi RestoreOfflineMediaKeys call Failed!");
auto context = std::make_shared<MediaKeySessionAsyncContext>();
if (context == nullptr) {
DRM_ERR_LOG("RestoreOfflineMediaKeys failed.");
NapiDrmError::ThrowError(env, "RestoreOfflineMediaKeys failed.", DRM_UNKNOWN_ERROR);
return NapiParamUtils::GetUndefinedValue(env);
}
auto inputParser = [env, context](size_t argc, napi_value *argv) {
NAPI_CHECK_ARGS_RETURN_VOID(context, argc == ARGS_ONE, "invalid arguments", DRM_INVALID_PARAM);
context->status = NapiParamUtils::GetValueUint8Array(env, context->restoreLicenseId, argv[PARAM0]);
NAPI_CHECK_STATUS_RETURN_VOID(context, "RestoreOfflineMediaKeys failed", DRM_INVALID_PARAM);
};
context->GetCbInfo(env, info, inputParser);
auto executor = [context]() {
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(CheckContextStatus(context), "context object state is error.");
auto obj = reinterpret_cast<MediaKeySessionNapi *>(context->native);
ObjectRefMap objectGuard(obj);
auto *napiMediaKeySession = objectGuard.GetPtr();
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(CheckMediaKeySessionStatus(napiMediaKeySession, context),
"MediaKeySession state is error.");
context->intValue = napiMediaKeySession->keySessionImpl_->RestoreOfflineMediaKeys(context->restoreLicenseId);
if (context->intValue != DRM_OK) {
context->SignError(DRM_SERVICE_FATAL_ERROR);
}
};
auto complete = [env, context](napi_value &output) { output = NapiParamUtils::GetUndefinedValue(env); };
DRM_INFO_LOG("MediaKeySessionNapi::RestoreOfflineMediaKeys exit.");
return result;
return NapiAsyncWork::Enqueue(env, context, "RestoreOfflineMediaKeys", executor, complete);
}
napi_value MediaKeySessionNapi::ClearMediaKeys(napi_env env, napi_callback_info info)
@@ -622,9 +504,17 @@ napi_value MediaKeySessionNapi::ClearMediaKeys(napi_env env, napi_callback_info
status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&keySessionNapi));
if (status == napi_ok && keySessionNapi != nullptr && keySessionNapi->keySessionImpl_ != nullptr) {
int32_t ret = keySessionNapi->keySessionImpl_->ClearMediaKeys();
DRM_CHECK_AND_RETURN_RET_LOG((ret == DRM_OK), nullptr, "MediaKeySessionNapi ClearMediaKeys call Failed!");
if (ret != DRM_OK) {
DRM_ERR_LOG("MediaKeySessionNapi ClearMediaKeys call Failed!");
NapiDrmError::ThrowError(env, "MediaKeySessionNapi ClearMediaKeys call Failed!",
DRM_SERVICE_FATAL_ERROR);
return nullptr;
}
} else {
DRM_ERR_LOG("MediaKeySessionNapi ClearMediaKeys call Failed!");
NapiDrmError::ThrowError(env, "MediaKeySessionNapi ClearMediaKeys call Failed!",
DRM_UNKNOWN_ERROR);
return nullptr;
}
DRM_INFO_LOG("MediaKeySessionNapi::ClearMediaKeys exit.");
@@ -641,7 +531,11 @@ napi_value MediaKeySessionNapi::RequireSecureDecoderModule(napi_env env, napi_ca
DRM_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
napi_get_undefined(env, &result);
NAPI_ASSERT(env, argc <= ARGS_ONE, "requires 1 parameters maximum");
if (argc != ARGS_ONE) {
NapiDrmError::ThrowError(env, "RequireSecureDecoderModule faild", DRM_INVALID_PARAM);
DRM_ERR_LOG("invalid arguments.");
return nullptr;
}
char mimeTypeBuf[PATH_MAX];
size_t length = 0;
@@ -653,12 +547,19 @@ napi_value MediaKeySessionNapi::RequireSecureDecoderModule(napi_env env, napi_ca
bool statusValue;
MediaKeySessionNapi *keySessionNapi = nullptr;
napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&keySessionNapi));
DRM_CHECK_AND_RETURN_RET_LOG((keySessionNapi != nullptr), nullptr, "MediaKeySessionNapi get keySessionNapi fail!");
if (keySessionNapi == nullptr) {
DRM_ERR_LOG("napi_unwrapcall Failed!");
NapiDrmError::ThrowError(env, "napi_unwrapcall failed.", DRM_UNKNOWN_ERROR);
return nullptr;
}
DRM_CHECK_AND_RETURN_RET_LOG((keySessionNapi->keySessionImpl_ != nullptr), nullptr, "keySessionImpl_ == nullptr.");
int32_t ret = keySessionNapi->keySessionImpl_->RequireSecureDecoderModule(mimeType, &statusValue);
DRM_CHECK_AND_RETURN_RET_LOG((ret == DRM_OK), nullptr,
"MediaKeySessionNapi RequireSecureDecoderModule call Failed!");
if (ret != DRM_OK) {
DRM_ERR_LOG("keySessionImpl_ RequireSecureDecoderModule call Failed!");
NapiDrmError::ThrowError(env, "RequireSecureDecoderModule failed.", DRM_SERVICE_FATAL_ERROR);
return nullptr;
}
status = napi_get_boolean(env, statusValue, &result);
DRM_INFO_LOG("napi_get_boolean call success!,statusValue:%{public}d.", statusValue);
@@ -677,15 +578,20 @@ napi_value MediaKeySessionNapi::GetContentProtectionLevel(napi_env env, napi_cal
DRM_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
NAPI_ASSERT(env, argc <= ARGS_ONE, "requires 1 parameters maximum");
IMediaKeySessionService::ContentProtectionLevel level = (IMediaKeySessionService::ContentProtectionLevel)0;
napi_status status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&keySessionNapi));
if (status == napi_ok && keySessionNapi != nullptr && keySessionNapi->keySessionImpl_ != nullptr) {
int32_t ret = keySessionNapi->keySessionImpl_->GetContentProtectionLevel(&level);
if (ret != DRM_OK) {
DRM_ERR_LOG("keySessionImpl_ GetContentProtectionLevel call Failed!");
NapiDrmError::ThrowError(env, "GetContentProtectionLevel failed.", DRM_SERVICE_FATAL_ERROR);
return nullptr;
}
DRM_CHECK_AND_RETURN_RET_LOG((ret == DRM_OK), nullptr,
"MediaKeySessionNapi GetContentProtectionLevel call Failed!");
} else {
DRM_ERR_LOG("MediaKeySessionNapi GetContentProtectionLevel call Failed!");
NapiDrmError::ThrowError(env, "GetContentProtectionLevel failed.", DRM_UNKNOWN_ERROR);
return nullptr;
}
@@ -694,7 +600,7 @@ napi_value MediaKeySessionNapi::GetContentProtectionLevel(napi_env env, napi_cal
return result;
}
void MediaKeySessionNapi::SetEventCallbackReference(const std::string eventType, sptr<CallBackPair> callbackPair)
void MediaKeySessionNapi::SetEventCallbackReference(const std::string eventType, std::shared_ptr<AutoRef> callbackPair)
{
DRM_INFO_LOG("MediaKeySessionNapi::SetEventCallbackReference");
std::lock_guard<std::mutex> lock(mutex_);
@@ -728,11 +634,13 @@ napi_value MediaKeySessionNapi::SetEventCallback(napi_env env, napi_callback_inf
NAPI_ASSERT(env, argc == ARGS_TWO, "only requires 2 parameters");
if (thisVar == nullptr || argv[PARAM0] == nullptr || argv[PARAM1] == nullptr) {
DRM_ERR_LOG("Failed to retrieve arguments in SetEventCallback!");
NapiDrmError::ThrowError(env, "SetEventCallback faild", DRM_INVALID_PARAM);
return result;
}
napi_valuetype valueType = napi_undefined;
if (napi_typeof(env, argv[PARAM0], &valueType) != napi_ok || valueType != napi_string ||
napi_typeof(env, argv[PARAM1], &valueType) != napi_ok || valueType != napi_function) {
NapiDrmError::ThrowError(env, "SetEventCallback faild", DRM_INVALID_PARAM);
return result;
}
@@ -746,11 +654,12 @@ napi_value MediaKeySessionNapi::SetEventCallback(napi_env env, napi_callback_inf
napi_create_reference(env, argv[PARAM1], 1, &callbackRef);
DRM_INFO_LOG("SetEventCallback event is %{public}s", eventType.c_str());
sptr<CallBackPair> callbackPair = new CallBackPair(env, callbackRef);
std::shared_ptr<AutoRef> callbackPair = std::make_shared<AutoRef>(env, callbackRef);
keySessionNapi->SetEventCallbackReference(eventType, callbackPair);
DRM_INFO_LOG("MediaKeySessionNapi::SetEventCallback out");
} else {
DRM_ERR_LOG("MediaKeySessionNapi SetEventCallback failed!");
NapiDrmError::ThrowError(env, "MediaKeySessionNapi SetEventCallback failed!", DRM_UNKNOWN_ERROR);
}
return result;
}
@@ -767,11 +676,13 @@ napi_value MediaKeySessionNapi::UnsetEventCallback(napi_env env, napi_callback_i
NAPI_ASSERT(env, argc == ARGS_ONE, "only requires 1 parameters");
if (thisVar == nullptr || argv[PARAM0] == nullptr) {
DRM_ERR_LOG("Failed to retrieve arguments in UnsetEventCallback!");
NapiDrmError::ThrowError(env, "MediaKeySessionNapi UnsetEventCallback failed!", DRM_INVALID_PARAM);
return result;
}
napi_valuetype valueType = napi_undefined;
if (napi_typeof(env, argv[PARAM0], &valueType) != napi_ok || valueType != napi_string) {
DRM_ERR_LOG("Failed to retrieve reasonable arguments in UnsetEventCallback!");
NapiDrmError::ThrowError(env, "MediaKeySessionNapi UnsetEventCallback failed!", DRM_INVALID_PARAM);
return result;
}
@@ -786,6 +697,7 @@ napi_value MediaKeySessionNapi::UnsetEventCallback(napi_env env, napi_callback_i
DRM_INFO_LOG("MediaKeySessionNapi::UnsetEventCallback out");
} else {
DRM_ERR_LOG("MediaKeySessionNapi UnsetEventCallback failed!");
NapiDrmError::ThrowError(env, "MediaKeySessionNapi UnsetEventCallback failed!", DRM_UNKNOWN_ERROR);
}
return result;
}
frameworks/js/drm_napi/media_key_system_callback_napi.cpp
+79 -37
View File
@@ -14,16 +14,19 @@
*/
#include "drm_log.h"
#include "drm_error_code.h"
#include "drm_napi_utils.h"
#include "media_key_system_callback_napi.h"
namespace OHOS {
namespace DrmStandard {
MediaKeySystemCallbackNapi::MediaKeySystemCallbackNapi() {}
MediaKeySystemCallbackNapi::MediaKeySystemCallbackNapi(napi_env env)
{
env_ = env;
}
MediaKeySystemCallbackNapi::~MediaKeySystemCallbackNapi() {}
void MediaKeySystemCallbackNapi::SetCallbackReference(const std::string eventType, sptr<CallBackPair> callbackPair)
void MediaKeySystemCallbackNapi::SetCallbackReference(const std::string eventType,
std::shared_ptr<AutoRef> callbackPair)
{
DRM_INFO_LOG("MediaKeySystemCallbackNapi SetCallbackReference");
std::lock_guard<std::mutex> lock(mutex_);
@@ -37,47 +40,86 @@ void MediaKeySystemCallbackNapi::ClearCallbackReference(const std::string eventT
callbackMap_.erase(eventType);
}
void MediaKeySystemCallbackNapi::SendEvent(const std::string event, int32_t extra,
const std::vector<uint8_t> data)
void MediaKeySystemCallbackNapi::WorkCallbackInterruptDone(uv_work_t *work, int status)
{
DRM_INFO_LOG("MediaKeySystemCallbackNapi SendEvent %{public}s", event.c_str());
DRM_NAPI_CHECK_AND_RETURN_LOG(!event.empty(), "Service event code error");
// Js Thread
std::shared_ptr<MediaKeySystemJsCallback> context(static_cast<MediaKeySystemJsCallback *>(work->data),
[work](MediaKeySystemJsCallback *ptr) {
delete ptr;
delete work;
});
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(work != nullptr, "work is nullptr");
MediaKeySystemJsCallback *event = reinterpret_cast<MediaKeySystemJsCallback *>(work->data);
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(event != nullptr, "event is nullptr");
std::string request = event->callbackName;
napi_value result;
napi_value jsCallback = nullptr;
napi_value retVal;
napi_status state;
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(event->callback != nullptr, "event is nullptr");
napi_env env = event->callback->env_;
napi_ref callback = event->callback->cb_;
DRM_NAPI_CHECK_AND_RETURN_LOG(callbackMap_.find(event) != callbackMap_.end(), "Not register this callback yet");
sptr<CallBackPair> item = callbackMap_[event];
napi_handle_scope scope = nullptr;
napi_open_handle_scope(env, &scope);
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(scope != nullptr, "scope is nullptr");
DRM_DEBUG_LOG("JsCallBack %{public}s, uv_queue_work_with_qos start", request.c_str());
do {
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(status != UV_ECANCELED, "%{public}s cancelled", request.c_str());
DRM_NAPI_CHECK_AND_RETURN_LOG(item != nullptr, "sptr callbackPair is nullptr");
napi_env env = item->GetEnv();
napi_ref callbackRef = item->GetCallback();
napi_value jsCallback = nullptr;
napi_status nstatus = napi_get_reference_value(env, callback, &jsCallback);
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(nstatus == napi_ok && jsCallback != nullptr,
"%{public}s get reference value fail", request.c_str());
napi_get_undefined(env, &result);
napi_create_object(env, &result);
// Call back function
napi_value args[ARGS_ONE] = { nullptr };
nstatus = NapiParamUtils::SetDrmEventInfo(env, event->eventParame, args[PARAM0]);
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(nstatus == napi_ok && args[PARAM0] != nullptr,
"%{public}s fail to create keysystem callback", request.c_str());
napi_value extraValue;
std::string extraData = std::to_string(extra);
napi_create_string_utf8(env, extraData.c_str(), NAPI_AUTO_LENGTH, &extraValue);
napi_value array = nullptr;
state = napi_create_array_with_length(env, data.size(), &array);
DRM_NAPI_CHECK_AND_RETURN_LOG(state == napi_ok,
"%{public}s failed to napi_create_array_with_length", event.c_str());
for (uint32_t i = 0; i < data.size(); i++) {
napi_value number = nullptr;
(void)napi_create_uint32(env, data[i], &number);
(void)napi_set_element(env, array, i, number);
const size_t argCount = ARGS_ONE;
napi_value result = nullptr;
nstatus = napi_call_function(env, nullptr, jsCallback, argCount, args, &result);
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(nstatus == napi_ok, "%{public}s fail to call Interrupt callback",
request.c_str());
} while (0);
napi_close_handle_scope(env, scope);
}
void MediaKeySystemCallbackNapi::SendEvent(const std::string &event, int32_t extra, const std::vector<uint8_t> &data)
{
std::lock_guard<std::mutex> lock(mutex_);
std::unique_ptr<MediaKeySystemJsCallback> cb = std::make_unique<MediaKeySystemJsCallback>();
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(cb != nullptr, "No memory");
cb->callback = callbackMap_[event];
cb->callbackName = event;
cb->eventParame.extra = extra;
cb->eventParame.data.assign(data.begin(), data.end());
return OnJsCallbackInterrupt(cb);
}
void MediaKeySystemCallbackNapi::OnJsCallbackInterrupt(std::unique_ptr<MediaKeySystemJsCallback> &jsCb)
{
uv_loop_s *loop = nullptr;
napi_get_uv_event_loop(env_, &loop);
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(loop != nullptr, "loop nullptr, No memory");
uv_work_t *work = new (std::nothrow) uv_work_t;
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(work != nullptr, "work nullptr, No memory");
if (jsCb.get() == nullptr) {
DRM_DEBUG_LOG("OnJsCallBackInterrupt: jsCb.get() is null");
delete work;
return;
}
work->data = reinterpret_cast<void *>(jsCb.get());
int ret = uv_queue_work_with_qos(
loop, work, [](uv_work_t *work) {}, WorkCallbackInterruptDone, uv_qos_default);
if (ret != 0) {
DRM_DEBUG_LOG("Failed to execute libuv work queue");
delete work;
} else {
jsCb.release();
}
napi_value args[1] = { nullptr };
napi_create_object(env, &args[0]);
napi_set_named_property(env, args[0], "info", array);
napi_set_named_property(env, args[0], "extraInfo", extraValue);
napi_get_reference_value(env, callbackRef, &jsCallback);
state = napi_call_function(env, nullptr, jsCallback, ARGS_ONE, args, &retVal);
DRM_NAPI_CHECK_AND_RETURN_LOG(state == napi_ok,
"%{public}s failed to napi_call_function", event.c_str());
}
} // namespace DrmStandard
} // namespace OHOS
frameworks/js/drm_napi/media_key_system_napi.cpp
+154 -99
View File
@@ -12,9 +12,10 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "drm_napi_utils.h"
#include "key_session_napi.h"
#include "media_key_system_napi.h"
#include "napi_param_utils.h"
namespace OHOS {
namespace DrmStandard {
thread_local napi_ref MediaKeySystemNapi::sConstructor_ = nullptr;
@@ -100,15 +101,16 @@ napi_value MediaKeySystemNapi::MediaKeySystemNapiConstructor(napi_env env, napi_
return result;
}
obj->mediaKeySystemImpl_ = MediaKeySystemNapi::sMediaKeySystemImpl_;
obj->mediaKeySystemCallbackNapi_ = new (std::nothrow) MediaKeySystemCallbackNapi();
obj->mediaKeySystemCallbackNapi_ = new (std::nothrow) MediaKeySystemCallbackNapi(env);
obj->mediaKeySystemImpl_->SetCallback(obj->mediaKeySystemCallbackNapi_);
status = napi_wrap(env, jsThis, reinterpret_cast<void *>(obj.get()),
MediaKeySystemNapi::MediaKeySystemNapiDestructor, nullptr, nullptr);
if (status == napi_ok) {
ObjectRefMap<MediaKeySystemNapi>::Insert(obj.get());
obj.release();
return jsThis;
} else {
ObjectRefMap<MediaKeySystemNapi>::Erase(obj.get());
DRM_ERR_LOG("Failure wrapping js to native napi");
}
DRM_ERR_LOG("will call IsMediaKeySystemSupported");
@@ -140,25 +142,28 @@ napi_value MediaKeySystemNapi::CreateMediaKeySystemInstance(napi_env env, napi_c
size_t uuidBufferLen = 0;
status = napi_get_value_string_utf8(env, argv[PARAM0], uuidBuffer, PATH_MAX, &uuidBufferLen);
if (status != napi_ok) {
NapiDrmError::ThrowError(env, "CreateMediaKeySystemInstance faild.", DRM_INVALID_PARAM);
DRM_ERR_LOG("Could not able to read uuid argument!");
return nullptr;
}
uuid = std::string(uuidBuffer);
int32_t retCode = MediaKeySystemFactoryImpl::GetInstance()->CreateMediaKeySystem(uuid,
int32_t ret = MediaKeySystemFactoryImpl::GetInstance()->CreateMediaKeySystem(uuid,
&MediaKeySystemNapi::sMediaKeySystemImpl_);
if (retCode != DRM_OK || MediaKeySystemNapi::sMediaKeySystemImpl_ == nullptr) {
DRM_ERR_LOG("MediaKeySystemNapi sMediaKeySystemImpl_ get failed!!!");
if (ret != DRM_OK) {
NapiDrmError::ThrowError(env, "CreateMediaKeySystemInstance faild.", ret);
DRM_ERR_LOG("CreateMediaKeySystem failed!");
return nullptr;
}
status = napi_new_instance(env, ctor, 0, nullptr, &result);
MediaKeySystemNapi::sMediaKeySystemImpl_ = nullptr;
if (status == napi_ok) {
DRM_ERR_LOG("CreateMediaKeySystemInstance 164");
DRM_INFO_LOG("MediaKeySystemNapi::CreateMediaKeySystemInstance exit.");
return result;
} else {
DRM_ERR_LOG("New instance could not be obtained");
}
}
NapiDrmError::ThrowError(env, "CreateMediaKeySystem faild.", DRM_UNKNOWN_ERROR);
napi_get_undefined(env, &result);
DRM_INFO_LOG("MediaKeySystemNapi::CreateMediaKeySystemInstance exit.");
return result;
@@ -168,9 +173,7 @@ void MediaKeySystemNapi::MediaKeySystemNapiDestructor(napi_env env, void *native
{
DRM_INFO_LOG("MediaKeySystemNapi::MediaKeySystemNapiDestructor enter.");
MediaKeySystemNapi *mediaKeySystemNapi = reinterpret_cast<MediaKeySystemNapi *>(nativeObject);
if (mediaKeySystemNapi != nullptr) {
mediaKeySystemNapi->~MediaKeySystemNapi();
}
ObjectRefMap<MediaKeySystemNapi>::DecreaseRef(mediaKeySystemNapi);
DRM_INFO_LOG("MediaKeySystemNapi::MediaKeySystemNapiDestructor exit.");
}
@@ -191,9 +194,14 @@ napi_value MediaKeySystemNapi::IsMediaKeySystemSupported(napi_env env, napi_call
}
std::string uuid = std::string(buffer);
if (uuid.length() == 0 || uuid.length() > MAX_STRING_SIZE) {
NapiDrmError::ThrowError(env, "IsMediaKeySystemSupported faild.", DRM_INVALID_PARAM);
DRM_ERR_LOG("uuid lenth is not able to zero or more 256!");
return nullptr;
}
if (MediaKeySystemFactoryImpl::GetInstance() == nullptr) {
NapiDrmError::ThrowError(env, "IsMediaKeySystemSupported faild.", DRM_SERVICE_FATAL_ERROR);
return nullptr;
}
if (argc == ARGS_ONE) {
bool isSurpportted = MediaKeySystemFactoryImpl::GetInstance()->IsMediaKeySystemSupported(uuid);
napi_get_boolean(env, isSurpportted, &result);
@@ -201,6 +209,7 @@ napi_value MediaKeySystemNapi::IsMediaKeySystemSupported(napi_env env, napi_call
}
buffer[0] = '\0';
if (napi_get_value_string_utf8(env, argv[PARAM1], buffer, PATH_MAX, &length) != napi_ok) {
NapiDrmError::ThrowError(env, "IsMediaKeySystemSupported faild.", DRM_INVALID_PARAM);
DRM_ERR_LOG("Could not able to read mimeType argument!");
return nullptr;
}
@@ -212,15 +221,16 @@ napi_value MediaKeySystemNapi::IsMediaKeySystemSupported(napi_env env, napi_call
}
buffer[0] = '\0';
int32_t jsContentProtectionLevel = -1;
int32_t jsContentProtectionLevel = DRM_ERROR;
if (napi_get_value_int32(env, argv[PARAM2], &jsContentProtectionLevel) != napi_ok) {
DRM_ERR_LOG("Could not able to read securityLevel argument!");
return nullptr;
}
IMediaKeySessionService::ContentProtectionLevel securityLevel =
(IMediaKeySessionService::ContentProtectionLevel)jsContentProtectionLevel;
if ((securityLevel < IMediaKeySessionService::CONTENT_PROTECTION_LEVEL_UNKNOWN) ||
if ((securityLevel <= IMediaKeySessionService::CONTENT_PROTECTION_LEVEL_UNKNOWN) ||
(securityLevel >= IMediaKeySessionService::CONTENT_PROTECTION_LEVEL_MAX)) {
NapiDrmError::ThrowError(env, "IsMediaKeySystemSupported faild.", DRM_INVALID_PARAM);
DRM_ERR_LOG("jsContentProtectionLevel is invalid");
return nullptr;
}
@@ -232,6 +242,7 @@ napi_value MediaKeySystemNapi::IsMediaKeySystemSupported(napi_env env, napi_call
DRM_INFO_LOG("MediaKeySystemNapi::IsMediaKeySystemSupported exit.");
return result;
}
NapiDrmError::ThrowError(env, "IsMediaKeySystemSupported faild.", DRM_INVALID_PARAM);
DRM_INFO_LOG("MediaKeySystemNapi::IsMediaKeySystemSupported exit.");
return nullptr;
}
@@ -254,19 +265,13 @@ napi_value MediaKeySystemNapi::CreateMediaKeySession(napi_env env, napi_callback
} else {
DRM_CHECK_AND_RETURN_RET_LOG(napi_get_value_int32(env, argv[PARAM0], &jsContentProtectionLevel) == napi_ok,
nullptr, "MediaKeySystemNapi napi get jsContentProtectionLevel failure!");
IMediaKeySessionService::ContentProtectionLevel securityLevel =
(IMediaKeySessionService::ContentProtectionLevel)jsContentProtectionLevel;
if ((securityLevel < IMediaKeySessionService::CONTENT_PROTECTION_LEVEL_UNKNOWN) ||
(securityLevel > IMediaKeySessionService::CONTENT_PROTECTION_LEVEL_MAX)) {
DRM_ERR_LOG("ContentProtectionLevel is invalid");
return nullptr;
}
}
napi_get_undefined(env, &result);
IMediaKeySessionService::ContentProtectionLevel securityLevel =
static_cast<IMediaKeySessionService::ContentProtectionLevel>(jsContentProtectionLevel);
if (securityLevel < IMediaKeySessionService::ContentProtectionLevel::CONTENT_PROTECTION_LEVEL_UNKNOWN ||
securityLevel > IMediaKeySessionService::ContentProtectionLevel::CONTENT_PROTECTION_LEVEL_MAX) {
if (securityLevel <= IMediaKeySessionService::ContentProtectionLevel::CONTENT_PROTECTION_LEVEL_UNKNOWN ||
securityLevel >= IMediaKeySessionService::ContentProtectionLevel::CONTENT_PROTECTION_LEVEL_MAX) {
NapiDrmError::ThrowError(env, "CreateMediaKeySession faild.", DRM_INVALID_PARAM);
DRM_ERR_LOG("securityLevel is error!!!");
return nullptr;
}
@@ -274,7 +279,8 @@ napi_value MediaKeySystemNapi::CreateMediaKeySession(napi_env env, napi_callback
if (status == napi_ok && mediaKeySystemNapi != nullptr && mediaKeySystemNapi->mediaKeySystemImpl_ != nullptr) {
int32_t ret = mediaKeySystemNapi->mediaKeySystemImpl_->CreateMediaKeySession(
(IMediaKeySessionService::ContentProtectionLevel)securityLevel, &keySessionImpl);
if (ret != DRM_OK || keySessionImpl == nullptr) {
if (ret != DRM_OK) {
NapiDrmError::ThrowError(env, "CreateMediaKeySession failed", ret);
DRM_ERR_LOG("MediaKeySystemNapi::CreateMediaKeySession get failed!!!");
return nullptr;
}
@@ -308,6 +314,7 @@ napi_value MediaKeySystemNapi::SetConfigurationString(napi_env env, napi_callbac
status = napi_get_value_string_utf8(env, argv[PARAM0], nameBuffer, PATH_MAX, &nameBufferLen);
if (status != napi_ok) {
NapiDrmError::ThrowError(env, "SetConfigurationString faild.", DRM_INVALID_PARAM);
DRM_ERR_LOG("Could not able to read name argument!");
return nullptr;
}
@@ -315,11 +322,13 @@ napi_value MediaKeySystemNapi::SetConfigurationString(napi_env env, napi_callbac
status = napi_get_value_string_utf8(env, argv[PARAM1], valueBuffer, PATH_MAX, &valueBufferLen);
if (status != napi_ok) {
DRM_ERR_LOG("Could not able to read value argument!");
NapiDrmError::ThrowError(env, "SetConfigurationString faild.", DRM_INVALID_PARAM);
return nullptr;
}
value = std::string(valueBuffer);
if (value.length() == 0) {
DRM_ERR_LOG("String Parameter length cannot be zero!");
NapiDrmError::ThrowError(env, "SetConfigurationString faild.", DRM_INVALID_PARAM);
return nullptr;
}
status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&mediaKeySystemNapi));
@@ -327,10 +336,12 @@ napi_value MediaKeySystemNapi::SetConfigurationString(napi_env env, napi_callbac
int32_t ret = mediaKeySystemNapi->mediaKeySystemImpl_->SetConfigurationString(name, value);
if (ret != napi_ok) {
DRM_ERR_LOG("napi SetConfiguration faild!");
NapiDrmError::ThrowError(env, "SetConfigurationString faild.", DRM_SERVICE_FATAL_ERROR);
return nullptr;
}
} else {
DRM_ERR_LOG("mediaKeySystemNapi SetConfiguration call Failed!");
NapiDrmError::ThrowError(env, "SetConfigurationString faild.", DRM_UNKNOWN_ERROR);
return nullptr;
}
@@ -354,16 +365,22 @@ napi_value MediaKeySystemNapi::GetConfigurationString(napi_env env, napi_callbac
DRM_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
NAPI_ASSERT(env, argc <= ARGS_TWO, "requires 2 parameters maximum");
napi_get_value_string_utf8(env, argv[PARAM0], nameStr, PATH_MAX, &nameStrLength);
status = napi_get_value_string_utf8(env, argv[PARAM0], nameStr, PATH_MAX, &nameStrLength);
if (status != napi_ok) {
NapiDrmError::ThrowError(env, "GetConfigurationString faild.", DRM_INVALID_PARAM);
return nullptr;
}
std::string name = std::string(nameStr);
status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&mediaKeySystemNapi));
if (status == napi_ok && mediaKeySystemNapi != nullptr && mediaKeySystemNapi->mediaKeySystemImpl_ != nullptr) {
int32_t ret = mediaKeySystemNapi->mediaKeySystemImpl_->GetConfigurationString(name, value);
if (ret != napi_ok) {
NapiDrmError::ThrowError(env, "GetConfigurationString faild.", DRM_SERVICE_FATAL_ERROR);
DRM_ERR_LOG("napi GetConfiguration faild!");
return nullptr;
}
} else {
NapiDrmError::ThrowError(env, "GetConfigurationString faild.", DRM_UNKNOWN_ERROR);
DRM_ERR_LOG("mediaKeySystemNapi GetConfigurationString Failed!");
return nullptr;
}
@@ -398,17 +415,20 @@ napi_value MediaKeySystemNapi::SetConfigurationByteArray(napi_env env, napi_call
status = napi_get_value_string_utf8(env, argv[PARAM0], nameBuffer, PATH_MAX, &nameBufferLen);
if (status != napi_ok) {
NapiDrmError::ThrowError(env, "SetConfigurationByteArray faild.", DRM_INVALID_PARAM);
DRM_ERR_LOG("Could not able to read name argument!");
return nullptr;
}
name = std::string(nameBuffer);
napi_is_typedarray(env, argv[PARAM1], &isTypeArray);
if (!isTypeArray) {
NapiDrmError::ThrowError(env, "SetConfigurationByteArray faild.", DRM_INVALID_PARAM);
DRM_ERR_LOG("argv[PARAM1] value is not array!");
return nullptr;
}
napi_get_typedarray_info(env, argv[PARAM1], &type, &valueDataLen, &valueData, &arraybuffer, &offset);
if (valueData == nullptr) {
NapiDrmError::ThrowError(env, "SetConfigurationByteArray faild.", DRM_INVALID_PARAM);
DRM_ERR_LOG("napi_get_typedarray_info faild!");
return nullptr;
}
@@ -418,10 +438,12 @@ napi_value MediaKeySystemNapi::SetConfigurationByteArray(napi_env env, napi_call
if (status == napi_ok && mediaKeySystemNapi != nullptr && mediaKeySystemNapi->mediaKeySystemImpl_ != nullptr) {
int32_t ret = mediaKeySystemNapi->mediaKeySystemImpl_->SetConfigurationByteArray(name, value);
if (ret != napi_ok) {
NapiDrmError::ThrowError(env, "SetConfigurationByteArray faild.", DRM_SERVICE_FATAL_ERROR);
DRM_ERR_LOG("napi SetConfigurationByteArray faild!");
return nullptr;
}
} else {
NapiDrmError::ThrowError(env, "SetConfigurationByteArray faild.", DRM_UNKNOWN_ERROR);
DRM_ERR_LOG("mediaKeySystemNapi SetConfigurationByteArray call Failed!");
return nullptr;
}
@@ -446,16 +468,23 @@ napi_value MediaKeySystemNapi::GetConfigurationByteArray(napi_env env, napi_call
DRM_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
NAPI_ASSERT(env, argc <= ARGS_TWO, "requires 2 parameters maximum");
napi_get_value_string_utf8(env, argv[PARAM0], nameStr, PATH_MAX, &nameStrLength);
status = napi_get_value_string_utf8(env, argv[PARAM0], nameStr, PATH_MAX, &nameStrLength);
if (status != napi_ok) {
NapiDrmError::ThrowError(env, "GetConfigurationByteArray faild.", DRM_INVALID_PARAM);
DRM_ERR_LOG("Could not able to read name argument!");
return nullptr;
}
std::string name = std::string(nameStr);
status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&mediaKeySystemNapi));
if (status == napi_ok && mediaKeySystemNapi != nullptr && mediaKeySystemNapi->mediaKeySystemImpl_ != nullptr) {
int32_t ret = mediaKeySystemNapi->mediaKeySystemImpl_->GetConfigurationByteArray(name, value);
if (ret != napi_ok) {
NapiDrmError::ThrowError(env, "GetConfigurationByteArray faild.", DRM_SERVICE_FATAL_ERROR);
DRM_ERR_LOG("napi GetConfiguration faild!");
return nullptr;
}
} else {
NapiDrmError::ThrowError(env, "GetConfigurationByteArray faild.", DRM_UNKNOWN_ERROR);
DRM_ERR_LOG("mediaKeySystemNapi GetConfigurationByteArray Failed!");
return nullptr;
}
@@ -489,10 +518,12 @@ napi_value MediaKeySystemNapi::GetMaxContentProtectionLevel(napi_env env, napi_c
if (status == napi_ok && mediaKeySystemNapi != nullptr && mediaKeySystemNapi->mediaKeySystemImpl_ != nullptr) {
int32_t ret = mediaKeySystemNapi->mediaKeySystemImpl_->GetMaxContentProtectionLevel(&level);
if (ret != napi_ok) {
NapiDrmError::ThrowError(env, "GetMaxContentProtectionLevel faild.", DRM_SERVICE_FATAL_ERROR);
DRM_ERR_LOG("mediaKeySystemImpl_->GetCertificateStatus faild!");
return nullptr;
}
} else {
NapiDrmError::ThrowError(env, "GetMaxContentProtectionLevel faild.", DRM_UNKNOWN_ERROR);
DRM_ERR_LOG("MediaKeySystemNapi GetMaxContentProtectionLevel call Failed!");
return nullptr;
}
@@ -502,93 +533,94 @@ napi_value MediaKeySystemNapi::GetMaxContentProtectionLevel(napi_env env, napi_c
return result;
}
bool MediaKeySystemNapi::CheckMediaKeySystemStatus(MediaKeySystemNapi *napi,
std::shared_ptr<MediaKeySystemAsyncContext> context)
{
DRM_NAPI_CHECK_AND_RETURN_LOG(napi != nullptr, false, "napi object is nullptr.");
if (napi->mediaKeySystemImpl_ == nullptr) {
context->SignError(DRM_SERVICE_FATAL_ERROR);
return false;
}
return true;
}
bool MediaKeySystemNapi::CheckContextStatus(std::shared_ptr<MediaKeySystemAsyncContext> context)
{
DRM_NAPI_CHECK_AND_RETURN_LOG(context != nullptr, false, "context object is nullptr.");
if (context->native == nullptr) {
context->SignError(DRM_SERVICE_FATAL_ERROR);
return false;
}
return true;
}
napi_value MediaKeySystemNapi::GenerateKeySystemRequest(napi_env env, napi_callback_info info)
{
DRM_INFO_LOG("MediaKeySystemNapi::GenerateKeySystemRequest enter");
napi_value result = nullptr;
napi_value thisVar = nullptr;
napi_status status;
size_t argc = ARGS_ZERO;
napi_value argv[ARGS_ZERO];
std::vector<uint8_t> request;
std::string defaultUrl;
napi_value mDefaultURL;
napi_value mData;
auto context = std::make_shared<MediaKeySystemAsyncContext>();
if (context == nullptr) {
DRM_ERR_LOG("GenerateKeySystemRequest failed.");
NapiDrmError::ThrowError(env, "GenerateKeySystemRequest failed.", DRM_UNKNOWN_ERROR);
return NapiParamUtils::GetUndefinedValue(env);
}
MediaKeySystemNapi *mediaKeySystemNapi = nullptr;
DRM_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&mediaKeySystemNapi));
if (status == napi_ok && mediaKeySystemNapi != nullptr && mediaKeySystemNapi->mediaKeySystemImpl_ != nullptr) {
int32_t ret = mediaKeySystemNapi->mediaKeySystemImpl_->GenerateKeySystemRequest(request, defaultUrl);
if (ret != napi_ok) {
DRM_ERR_LOG("napi GenerateKeySystemRequest faild!");
return nullptr;
context->GetCbInfo(env, info);
auto executor = [context]() {
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(CheckContextStatus(context), "context object state is error.");
auto obj = reinterpret_cast<MediaKeySystemNapi *>(context->native);
ObjectRefMap objectGuard(obj);
auto *napiMediaKeySystem = objectGuard.GetPtr();
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(CheckMediaKeySystemStatus(napiMediaKeySystem, context),
"context object state is error.");
context->intValue = napiMediaKeySystem->mediaKeySystemImpl_->GenerateKeySystemRequest(
context->provisionRequest.data, context->provisionRequest.defaultURL);
if (context->intValue != 0) {
context->SignError(DRM_SERVICE_FATAL_ERROR);
}
} else {
DRM_ERR_LOG("mediaKeySystemNapi GenerateKeySystemRequest call Failed!");
return nullptr;
}
NAPI_CALL(env, napi_create_object(env, &result));
size_t requestLen = request.size();
NAPI_CALL(env, napi_create_array(env, &mData));
for (size_t i = 0; i < requestLen; i++) {
napi_value item;
napi_create_int32(env, request[i], &item);
napi_set_element(env, mData, i, item);
}
NAPI_CALL(env, napi_create_string_utf8(env, defaultUrl.c_str(), NAPI_AUTO_LENGTH, &mDefaultURL));
NAPI_CALL(env, napi_set_named_property(env, result, "defaultURL", mDefaultURL));
NAPI_CALL(env, napi_set_named_property(env, result, "data", mData));
};
auto complete = [env, context](napi_value &output) {
NapiParamUtils::SetProvisionRequest(env, context->provisionRequest, output);
};
DRM_INFO_LOG("MediaKeySystemNapi::GenerateKeySystemRequest exit");
return result;
return NapiAsyncWork::Enqueue(env, context, "GenerateKeySystemRequest", executor, complete);
}
napi_value MediaKeySystemNapi::ProcessKeySystemResponse(napi_env env, napi_callback_info info)
{
DRM_INFO_LOG("MediaKeySystemNapi::ProcessKeySystemResponse enter.");
napi_value result = nullptr;
size_t argc = ARGS_TWO;
napi_value argv[ARGS_TWO] = {0};
napi_value thisVar = nullptr;
napi_status status;
bool isTypeArray;
void *reponseData = nullptr;
size_t reponseDataLen;
size_t offset;
napi_value arraybuffer = nullptr;
napi_typedarray_type type;
MediaKeySystemNapi *mediaKeySystemNapi = nullptr;
auto context = std::make_shared<MediaKeySystemAsyncContext>();
if (context == nullptr) {
DRM_ERR_LOG("ProcessKeySystemResponse failed.");
NapiDrmError::ThrowError(env, "ProcessKeySystemResponse failed.", DRM_UNKNOWN_ERROR);
return NapiParamUtils::GetUndefinedValue(env);
}
DRM_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
NAPI_ASSERT(env, argc <= ARGS_ONE, "requires 1 parameters maximum");
napi_is_typedarray(env, argv[PARAM0], &isTypeArray);
if (!isTypeArray) {
DRM_ERR_LOG("argv[PARAM0] reponse is not array!");
return nullptr;
}
napi_get_typedarray_info(env, argv[PARAM0], &type, &reponseDataLen, &reponseData, &arraybuffer, &offset);
if (reponseData == nullptr) {
DRM_ERR_LOG("napi_get_typedarray_info faild!");
return nullptr;
}
uint8_t *reponseDataPtr = reinterpret_cast<uint8_t *>(reponseData);
std::vector<uint8_t> keySystemResponse(reponseDataPtr, reponseDataPtr + reponseDataLen);
status = napi_unwrap(env, thisVar, reinterpret_cast<void **>(&mediaKeySystemNapi));
if (status == napi_ok && mediaKeySystemNapi != nullptr && mediaKeySystemNapi->mediaKeySystemImpl_ != nullptr) {
int32_t ret = mediaKeySystemNapi->mediaKeySystemImpl_->ProcessKeySystemResponse(keySystemResponse);
if (ret != napi_ok) {
DRM_ERR_LOG("napi ProcessKeySystemResponse faild!");
return nullptr;
auto inputParser = [env, context](size_t argc, napi_value *argv) {
NAPI_CHECK_ARGS_RETURN_VOID(context, argc == ARGS_ONE, "invalid arguments", DRM_INVALID_PARAM);
context->status = NapiParamUtils::GetValueUint8Array(env, context->response, argv[PARAM0]);
NAPI_CHECK_STATUS_RETURN_VOID(context, "ProcessKeySystemResponse failed", DRM_INVALID_PARAM);
};
context->GetCbInfo(env, info, inputParser);
auto executor = [context]() {
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(CheckContextStatus(context), "context object state is error.");
auto obj = reinterpret_cast<MediaKeySystemNapi *>(context->native);
ObjectRefMap objectGuard(obj);
auto *napiMediaKeySystem = objectGuard.GetPtr();
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(CheckMediaKeySystemStatus(napiMediaKeySystem, context),
"context object state is error.");
context->intValue = napiMediaKeySystem->mediaKeySystemImpl_->ProcessKeySystemResponse(context->response);
if (context->intValue != DRM_OK) {
context->SignError(DRM_SERVICE_FATAL_ERROR);
}
} else {
DRM_ERR_LOG("mediaKeySystemNapi ProcessKeySystemResponse call Failed!");
return nullptr;
}
};
auto complete = [env](napi_value &output) { output = NapiParamUtils::GetUndefinedValue(env); };
DRM_INFO_LOG("MediaKeySystemNapi::ProcessKeySystemResponse exit.");
return result;
return NapiAsyncWork::Enqueue(env, context, "ProcessKeySystemResponse", executor, complete);
}
static napi_value vectorToJsArray(napi_env env, std::vector<IMediaKeySystemService::MetircKeyValue> &metrics)
@@ -628,10 +660,12 @@ napi_value MediaKeySystemNapi::GetStatistics(napi_env env, napi_callback_info in
if (status == napi_ok && mediaKeySystemNapi != nullptr && mediaKeySystemNapi->mediaKeySystemImpl_ != nullptr) {
int32_t ret = mediaKeySystemNapi->mediaKeySystemImpl_->GetStatistics(metrics);
if (ret != napi_ok) {
NapiDrmError::ThrowError(env, "GetStatistics faild.", DRM_SERVICE_FATAL_ERROR);
DRM_ERR_LOG("mediaKeySystemImpl_->GetStatistics faild!");
return nullptr;
}
} else {
NapiDrmError::ThrowError(env, "GetStatistics faild.", DRM_UNKNOWN_ERROR);
DRM_ERR_LOG("mediaKeySystemNapi GetStatistics Failed!");
return nullptr;
}
@@ -656,10 +690,12 @@ napi_value MediaKeySystemNapi::GetCertificateStatus(napi_env env, napi_callback_
if (status == napi_ok && mediaKeySystemNapi != nullptr && mediaKeySystemNapi->mediaKeySystemImpl_ != nullptr) {
int32_t ret = mediaKeySystemNapi->mediaKeySystemImpl_->GetCertificateStatus(&certStatus);
if (ret != napi_ok) {
NapiDrmError::ThrowError(env, "GetCertificateStatus faild.", DRM_SERVICE_FATAL_ERROR);
DRM_ERR_LOG("mediaKeySystemImpl_->GetCertificateStatus faild!");
return nullptr;
}
} else {
NapiDrmError::ThrowError(env, "GetCertificateStatus faild.", DRM_UNKNOWN_ERROR);
DRM_ERR_LOG("mediaKeySystemNapi GetCertificateStatus Failed!");
return nullptr;
}
@@ -726,11 +762,14 @@ napi_value MediaKeySystemNapi::GetOfflineMediaKeyIds(napi_env env, napi_callback
if (status == napi_ok && mediaKeySystemNapi != nullptr && mediaKeySystemNapi->mediaKeySystemImpl_ != nullptr) {
int32_t ret = mediaKeySystemNapi->mediaKeySystemImpl_->GetOfflineMediaKeyIds(licenseIds);
if (ret != napi_ok) {
NapiDrmError::ThrowError(env, "GetOfflineMediaKeyIds faild.", DRM_SERVICE_FATAL_ERROR);
DRM_ERR_LOG("napi GetOfflineMediaKeyIds faild!");
return nullptr;
}
} else {
NapiDrmError::ThrowError(env, "GetOfflineMediaKeyIds faild.", DRM_UNKNOWN_ERROR);
DRM_ERR_LOG("MediaKeySystemNapi GetOfflineMediaKeyIds call Failed!");
return nullptr;
}
result = vectorToJs2DArray(env, licenseIds);
@@ -758,11 +797,13 @@ napi_value MediaKeySystemNapi::GetOfflineMediaKeyStatus(napi_env env, napi_callb
NAPI_ASSERT(env, argc <= ARGS_ONE, "requires 1 parameters maximum");
napi_is_typedarray(env, argv[PARAM0], &isTypeArray);
if (!isTypeArray) {
NapiDrmError::ThrowError(env, "GetOfflineMediaKeyStatus faild.", DRM_INVALID_PARAM);
DRM_ERR_LOG("argv[PARAM0] is not array!");
return nullptr;
}
napi_get_typedarray_info(env, argv[PARAM0], &type, &licenseIdLen, &licenseId, &arraybuffer, &offset);
if (licenseId == nullptr) {
NapiDrmError::ThrowError(env, "GetOfflineMediaKeyStatus faild.", DRM_INVALID_PARAM);
DRM_ERR_LOG("napi_get_typedarray_info faild!");
return nullptr;
}
@@ -775,10 +816,12 @@ napi_value MediaKeySystemNapi::GetOfflineMediaKeyStatus(napi_env env, napi_callb
int32_t ret =
mediaKeySystemNapi->mediaKeySystemImpl_->GetOfflineMediaKeyStatus(licenseIdVec, offlineMediaKeyStatus);
if (ret != napi_ok) {
NapiDrmError::ThrowError(env, "GetOfflineMediaKeyStatus faild.", DRM_SERVICE_FATAL_ERROR);
DRM_ERR_LOG("napi GetOfflineMediaKeyStatus faild!");
return nullptr;
}
} else {
NapiDrmError::ThrowError(env, "GetOfflineMediaKeyStatus faild.", DRM_UNKNOWN_ERROR);
DRM_ERR_LOG("MediaKeySystemNapi GetOfflineMediaKeyStatus call Failed!");
return nullptr;
}
@@ -808,6 +851,7 @@ napi_value MediaKeySystemNapi::ClearOfflineMediaKeys(napi_env env, napi_callback
NAPI_ASSERT(env, argc <= ARGS_ONE, "requires 2 parameters maximum");
napi_is_typedarray(env, argv[PARAM0], &isTypeArray);
if (!isTypeArray) {
NapiDrmError::ThrowError(env, "ClearOfflineMediaKeys faild.", DRM_INVALID_PARAM);
DRM_ERR_LOG("argv[PARAM0] is not array!");
return nullptr;
}
@@ -823,10 +867,13 @@ napi_value MediaKeySystemNapi::ClearOfflineMediaKeys(napi_env env, napi_callback
int32_t ret = mediaKeySystemNapi->mediaKeySystemImpl_->ClearOfflineMediaKeys(licenseIdVec);
if (ret != napi_ok) {
DRM_ERR_LOG("napi ClearOfflineMediaKeys faild!");
NapiDrmError::ThrowError(env, "ClearOfflineMediaKeys faild.", DRM_SERVICE_FATAL_ERROR);
return nullptr;
}
} else {
DRM_ERR_LOG("MediaKeySystemNapi ClearOfflineMediaKeys call Failed!");
NapiDrmError::ThrowError(env, "ClearOfflineMediaKeys faild.", DRM_UNKNOWN_ERROR);
return nullptr;
}
DRM_INFO_LOG("MediaKeySystemNapi::ClearOfflineMediaKeys exit.");
@@ -852,19 +899,21 @@ napi_value MediaKeySystemNapi::Destroy(napi_env env, napi_callback_info info)
if (status == napi_ok && mediaKeySystemNapi != nullptr && mediaKeySystemNapi->mediaKeySystemImpl_ != nullptr) {
int32_t ret = mediaKeySystemNapi->mediaKeySystemImpl_->Release();
if (ret != napi_ok) {
NapiDrmError::ThrowError(env, "Destroy faild.", DRM_SERVICE_FATAL_ERROR);
DRM_ERR_LOG("mediaKeySystemImpl_->GetCertificateStatus faild!");
return nullptr;
}
mediaKeySystemNapi->~MediaKeySystemNapi();
mediaKeySystemNapi = nullptr;
MediaKeySystemFactoryImpl::GetInstance()->keySystemNumber--;
} else {
NapiDrmError::ThrowError(env, "Destroy faild.", DRM_UNKNOWN_ERROR);
DRM_ERR_LOG("mediaKeySystemNapi Destroy Failed!");
return nullptr;
}
DRM_INFO_LOG("MediaKeySystemNapi::Release exit.");
return result;
}
void MediaKeySystemNapi::SaveEventCallbackReferrence(const std::string eventType, sptr<CallBackPair> callbackPair)
void MediaKeySystemNapi::SaveEventCallbackReferrence(const std::string eventType, std::shared_ptr<AutoRef> callbackPair)
{
DRM_INFO_LOG("MediaKeySystemNapi::SaveEventCallbackReferrence");
std::lock_guard<std::mutex> lock(mutex_);
@@ -897,12 +946,14 @@ napi_value MediaKeySystemNapi::SetEventCallback(napi_env env, napi_callback_info
DRM_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
NAPI_ASSERT(env, argc == ARGS_TWO, "only requires 2 parameters");
if (thisVar == nullptr || argv[PARAM0] == nullptr || argv[PARAM1] == nullptr) {
NapiDrmError::ThrowError(env, "SetEventCallback faild.", DRM_INVALID_PARAM);
DRM_ERR_LOG("Failed to retrieve arguments in SetEventCallback!");
return result;
}
napi_valuetype valueType = napi_undefined;
if (napi_typeof(env, argv[PARAM0], &valueType) != napi_ok || valueType != napi_string ||
napi_typeof(env, argv[PARAM1], &valueType) != napi_ok || valueType != napi_function) {
NapiDrmError::ThrowError(env, "SetEventCallback faild.", DRM_INVALID_PARAM);
return result;
}
@@ -916,10 +967,11 @@ napi_value MediaKeySystemNapi::SetEventCallback(napi_env env, napi_callback_info
napi_create_reference(env, argv[PARAM1], 1, &callbackRef);
DRM_INFO_LOG("SetEventCallback event is %{public}s", eventType.c_str());
sptr<CallBackPair> callbackPair = new CallBackPair(env, callbackRef);
std::shared_ptr<AutoRef> callbackPair = std::make_shared<AutoRef>(env, callbackRef);
mediaKeySystemNapi->SaveEventCallbackReferrence(eventType, callbackPair);
DRM_INFO_LOG("mediaKeySystemNapi::SetEventCallback out");
} else {
NapiDrmError::ThrowError(env, "SetEventCallback faild.", DRM_UNKNOWN_ERROR);
DRM_ERR_LOG("mediaKeySystemNapi SetEventCallback failed!");
}
return result;
@@ -937,11 +989,13 @@ napi_value MediaKeySystemNapi::UnsetEventCallback(napi_env env, napi_callback_in
NAPI_ASSERT(env, argc == ARGS_ONE, "only requires 1 parameters");
if (thisVar == nullptr || argv[PARAM0] == nullptr) {
DRM_ERR_LOG("Failed to retrieve arguments in UnsetEventCallback!");
NapiDrmError::ThrowError(env, "UnsetEventCallback faild.", DRM_INVALID_PARAM);
return result;
}
napi_valuetype valueType = napi_undefined;
if (napi_typeof(env, argv[PARAM0], &valueType) != napi_ok || valueType != napi_string) {
DRM_ERR_LOG("Failed to retrieve reasonable arguments in UnsetEventCallback!");
NapiDrmError::ThrowError(env, "UnsetEventCallback faild.", DRM_INVALID_PARAM);
return result;
}
@@ -955,6 +1009,7 @@ napi_value MediaKeySystemNapi::UnsetEventCallback(napi_env env, napi_callback_in
mediaKeySystemNapi->ClearEventCallbackReferrence(eventType);
DRM_INFO_LOG("MediaKeySystemNapi::UnsetEventCallback out");
} else {
NapiDrmError::ThrowError(env, "UnsetEventCallback faild.", DRM_UNKNOWN_ERROR);
DRM_ERR_LOG("MediaKeySystemNapi UnsetEventCallback failed!");
}
return result;
frameworks/js/drm_napi/napi_async_work.cpp
+162
View File
@@ -0,0 +1,162 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "napi_async_work.h"
namespace OHOS {
namespace DrmStandard {
ContextBase::~ContextBase()
{
DRM_DEBUG_LOG("no memory leak after callback or promise[resolved/rejected]");
if (env != nullptr) {
if (work != nullptr) {
napi_delete_async_work(env, work);
}
if (callbackRef != nullptr) {
napi_delete_reference(env, callbackRef);
}
napi_delete_reference(env, selfRef);
env = nullptr;
callbackRef = nullptr;
selfRef = nullptr;
}
}
void ContextBase::GetCbInfo(napi_env envi, napi_callback_info info, NapiCbInfoParser parser, bool sync)
{
env = envi;
size_t argc = ARGC_MAX;
napi_value argv[ARGC_MAX] = {nullptr};
status = napi_get_cb_info(env, info, &argc, argv, &self, nullptr);
NAPI_CHECK_STATUS_RETURN_VOID(this, "napi_get_cb_info failed!", DRM_INVALID_PARAM);
NAPI_CHECK_ARGS_RETURN_VOID(this, argc <= ARGC_MAX, "too many arguments!", DRM_INVALID_PARAM);
NAPI_CHECK_ARGS_RETURN_VOID(this, self != nullptr, "no JavaScript this argument!", DRM_INVALID_PARAM);
napi_create_reference(env, self, 1, &selfRef);
status = napi_unwrap(env, self, &native);
NAPI_CHECK_STATUS_RETURN_VOID(this, "self unwrap failed!", DRM_INVALID_PARAM);
if (!sync && (argc > 0)) {
// get the last arguments :: <callback>
size_t index = argc - 1;
napi_valuetype type = napi_undefined;
napi_status tyst = napi_typeof(env, argv[index], &type);
if ((tyst == napi_ok) && (type == napi_function)) {
status = napi_create_reference(env, argv[index], 1, &callbackRef);
NAPI_CHECK_STATUS_RETURN_VOID(this, "ref callback failed!", DRM_INVALID_PARAM);
argc = index;
DRM_DEBUG_LOG("async callback, no promise");
} else {
DRM_DEBUG_LOG("no callback, async promise");
}
}
if (parser) {
parser(argc, argv);
} else {
NAPI_CHECK_ARGS_RETURN_VOID(this, argc == 0, "required no arguments!", DRM_INVALID_PARAM);
}
}
void ContextBase::SignError(int32_t code)
{
status = napi_generic_failure;
errCode = code;
errMessage = NapiDrmError::GetMessageByCode(errCode);
}
napi_value NapiAsyncWork::Enqueue(napi_env env, std::shared_ptr<ContextBase> ctxt, const std::string &name,
NapiAsyncExecute execute, NapiAsyncComplete complete)
{
DRM_DEBUG_LOG("name=%{public}s", name.c_str());
ctxt->execute = std::move(execute);
ctxt->complete = std::move(complete);
ctxt->taskName = name;
napi_value promise = nullptr;
if (ctxt->callbackRef == nullptr) {
napi_create_promise(ctxt->env, &ctxt->deferred, &promise);
DRM_DEBUG_LOG("create deferred promise");
} else {
napi_get_undefined(ctxt->env, &promise);
}
napi_value resource = nullptr;
napi_create_string_utf8(ctxt->env, name.c_str(), NAPI_AUTO_LENGTH, &resource);
napi_create_async_work(
ctxt->env, nullptr, resource,
[](napi_env env, void* data) {
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(data != nullptr, "napi_async_execute_callback nullptr");
auto ctxt = reinterpret_cast<ContextBase*>(data);
DRM_DEBUG_LOG("napi_async_execute_callback ctxt->status=%{public}d", ctxt->status);
if (ctxt->execute && ctxt->status == napi_ok) {
ctxt->execute();
}
},
[](napi_env env, napi_status status, void* data) {
DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(data != nullptr, "napi_async_complete_callback nullptr");
auto ctxt = reinterpret_cast<ContextBase*>(data);
DRM_DEBUG_LOG("napi_async_complete_callback status=%{public}d, ctxt->status=%{public}d",
status, ctxt->status);
if ((status != napi_ok) && (ctxt->status == napi_ok)) {
ctxt->status = status;
}
if ((ctxt->complete) && (status == napi_ok) && (ctxt->status == napi_ok)) {
ctxt->complete(ctxt->output);
}
CommonCallbackRoutine(ctxt);
},
reinterpret_cast<void*>(ctxt.get()), &ctxt->work);
napi_queue_async_work_with_qos(ctxt->env, ctxt->work, napi_qos_user_initiated);
ctxt->hold = ctxt; // save crossing-thread ctxt.
return promise;
}
void NapiAsyncWork::CommonCallbackRoutine(ContextBase *ctxt)
{
napi_value result[RESULT_ALL] = {nullptr};
if (ctxt->status == napi_ok) {
napi_get_undefined(ctxt->env, &result[RESULT_ERROR]);
if (ctxt->output == nullptr) {
napi_get_undefined(ctxt->env, &ctxt->output);
}
result[RESULT_DATA] = ctxt->output;
} else {
napi_value message = nullptr;
napi_value code = nullptr;
napi_create_string_utf8(ctxt->env, ctxt->errMessage.c_str(), NAPI_AUTO_LENGTH, &message);
napi_create_error(ctxt->env, nullptr, message, &result[RESULT_ERROR]);
napi_create_int32(ctxt->env, ctxt->errCode, &code);
napi_set_named_property(ctxt->env, result[RESULT_ERROR], "code", code);
napi_get_undefined(ctxt->env, &result[RESULT_DATA]);
}
if (ctxt->deferred != nullptr) {
if (ctxt->status == napi_ok) {
DRM_DEBUG_LOG("deferred promise resolved");
napi_resolve_deferred(ctxt->env, ctxt->deferred, result[RESULT_DATA]);
} else {
DRM_DEBUG_LOG("deferred promise rejected");
napi_reject_deferred(ctxt->env, ctxt->deferred, result[RESULT_ERROR]);
}
} else {
napi_value callback = nullptr;
napi_get_reference_value(ctxt->env, ctxt->callbackRef, &callback);
napi_value callbackResult = nullptr;
DRM_DEBUG_LOG("call callback function");
napi_call_function(ctxt->env, nullptr, callback, RESULT_ALL, result, &callbackResult);
}
ctxt->hold->execute = nullptr;
ctxt->hold->complete = nullptr;
ctxt->hold.reset(); // release ctxt.
}
} // namespace DrmStandard
} // namespace OHOS
frameworks/js/drm_napi/napi_param_utils.cpp
+282
View File
@@ -0,0 +1,282 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "napi_param_utils.h"
namespace OHOS {
namespace DrmStandard {
napi_value NapiParamUtils::GetUndefinedValue(napi_env env)
{
napi_value result {};
napi_get_undefined(env, &result);
return result;
}
napi_status NapiParamUtils::GetValueInt32(const napi_env &env, int32_t &value, napi_value in)
{
napi_status status = napi_get_value_int32(env, in, &value);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "GetValueInt32 napi_get_value_int32 failed");
return status;
}
napi_status NapiParamUtils::SetValueInt32(const napi_env &env, const int32_t &value, napi_value &result)
{
napi_status status = napi_create_int32(env, value, &result);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "SetValueInt32 napi_create_int32 failed");
return status;
}
napi_status NapiParamUtils::GetValueInt32(const napi_env &env, const std::string &fieldStr, int32_t &value,
napi_value in)
{
napi_value jsValue = nullptr;
napi_status status = napi_get_named_property(env, in, fieldStr.c_str(), &jsValue);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "GetValueInt32 napi_get_named_property failed");
status = GetValueInt32(env, value, jsValue);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "GetValueInt32 napi_get_value_int32 failed");
return status;
}
napi_status NapiParamUtils::SetValueInt32(const napi_env &env, const std::string &fieldStr, const int32_t value,
napi_value &result)
{
napi_value jsValue = nullptr;
napi_status status = SetValueInt32(env, value, jsValue);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "SetValueInt32 napi_create_int32 failed");
status = napi_set_named_property(env, result, fieldStr.c_str(), jsValue);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "SetValueInt32 napi_create_int32 failed");
return status;
}
std::string NapiParamUtils::GetStringArgument(napi_env env, napi_value value)
{
std::string strValue = "";
size_t bufLength = 0;
napi_status status = napi_get_value_string_utf8(env, value, nullptr, 0, &bufLength);
if (status == napi_ok && bufLength > 0 && bufLength < PATH_MAX) {
strValue.reserve(bufLength + 1);
strValue.resize(bufLength);
status = napi_get_value_string_utf8(env, value, strValue.data(), bufLength + 1, &bufLength);
if (status == napi_ok) {
DRM_DEBUG_LOG("argument = %{public}s", strValue.c_str());
}
}
return strValue;
}
napi_status NapiParamUtils::SetValueString(const napi_env &env, const std::string &stringValue, napi_value &result)
{
napi_status status = napi_create_string_utf8(env, stringValue.c_str(), NAPI_AUTO_LENGTH, &result);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "SetValueString napi_create_string_utf8 failed");
return status;
}
napi_status NapiParamUtils::SetValueString(const napi_env &env, const std::string &fieldStr,
const std::string &stringValue, napi_value &result)
{
napi_value value = nullptr;
napi_status status = SetValueString(env, stringValue.c_str(), value);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "SetValueString failed");
status = napi_set_named_property(env, result, fieldStr.c_str(), value);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "SetValueString napi_set_named_property failed");
return status;
}
napi_status NapiParamUtils::SetValueUint8Array(const napi_env &env, const std::vector<uint8_t> &value,
napi_value &result)
{
napi_status status = napi_create_array(env, &result);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "SetValueUint8Array napi_create_array failed");
for (size_t i = 0; i < value.size(); i++) {
napi_value item;
napi_create_int32(env, value[i], &item);
napi_set_element(env, result, i, item);
}
return status;
}
napi_status NapiParamUtils::SetValueUint8Array(const napi_env &env, const std::string &fieldStr,
const std::vector<uint8_t> &value, napi_value &result)
{
napi_value jsValue = nullptr;
napi_status status = SetValueUint8Array(env, value, jsValue);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "SetValueUint8Array failed");
status = napi_set_named_property(env, result, fieldStr.c_str(), jsValue);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "napi_set_named_property failed");
return status;
}
napi_status NapiParamUtils::GetValueUint8Array(const napi_env &env, std::vector<uint8_t> &value, napi_value in)
{
void *reponseData = nullptr;
size_t reponseDataLen;
size_t offset;
napi_value arraybuffer = nullptr;
napi_typedarray_type type;
napi_status status = napi_get_typedarray_info(env, in, &type, &reponseDataLen, &reponseData, &arraybuffer, &offset);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "napi_get_typedarray_info failed");
uint8_t *reponseDataPtr = reinterpret_cast<uint8_t *>(reponseData);
std::vector<uint8_t> initDataStr(reponseDataPtr, reponseDataPtr + reponseDataLen);
value.assign(initDataStr.begin(), initDataStr.end());
return status;
}
napi_status NapiParamUtils::SetValueBoolean(const napi_env &env, const bool boolValue, napi_value &result)
{
napi_status status = napi_get_boolean(env, boolValue, &result);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "SetValueBoolean napi_get_boolean failed");
return status;
}
napi_status NapiParamUtils::SetValueMap(const napi_env &env,
std::map<std::vector<uint8_t>, MediaKeySessionKeyStatus> statusTable, napi_value &statusTableMap)
{
uint32_t index = 0;
napi_status status;
napi_create_array_with_length(env, statusTable.size(), &statusTableMap);
for (auto itemTmp : statusTable) {
napi_value jsObject;
napi_value jsKeyId;
napi_value jsKeyStatus;
napi_create_object(env, &jsObject);
status = napi_create_array_with_length(env, itemTmp.first.size(), &jsKeyId);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "failed to call napi_create_array_with_length");
for (uint32_t i = 0; i < itemTmp.first.size(); i++) {
napi_value number = nullptr;
(void)napi_create_uint32(env, itemTmp.first[i], &number);
(void)napi_set_element(env, jsKeyId, i, number);
}
status = napi_set_named_property(env, jsObject, "keyId", jsKeyId);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "failed to call napi_set_named_property");
std::string value;
switch (itemTmp.second) {
case MEDIA_KEY_SESSION_KEY_STATUS_USABLE:
value = "USABLE";
break;
case MEDIA_KEY_SESSION_KEY_STATUS_EXPIRED:
value = "EXPIRED";
break;
case MEDIA_KEY_SESSION_KEY_STATUS_OUTPUT_NOT_ALLOWED:
value = "OUTPUT_NOT_ALLOWED";
break;
case MEDIA_KEY_SESSION_KEY_STATUS_PENDING:
value = "PENDING";
break;
case MEDIA_KEY_SESSION_KEY_STATUS_INTERNAL_ERROR:
value = "INTERNAL_ERROR";
break;
case MEDIA_KEY_SESSION_KEY_STATUS_USABLE_IN_FUTURE:
value = "USABLE_IN_FUTURE";
break;
default:
value = "Fault Status";
break;
}
status = napi_create_string_utf8(env, value.c_str(), NAPI_AUTO_LENGTH, &jsKeyStatus);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "failed to call napi_create_string_utf8");
status = napi_set_named_property(env, jsObject, "value", jsKeyStatus);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "failed to call napi_set_named_property");
status = napi_set_element(env, statusTableMap, index, jsObject);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "failed to call napi_set_element");
index++;
}
return status;
}
napi_status NapiParamUtils::GetValueOptionsData(const napi_env &env, std::map<std::string, std::string> &valueMap,
napi_value in)
{
uint32_t optionalDataCount = 0;
napi_status status = napi_get_array_length(env, in, &optionalDataCount);
if (optionalDataCount > 0) {
for (size_t i = 0; i < optionalDataCount; i++) {
napi_value tmpData;
napi_value tmpName;
napi_value tmpValue;
size_t nameLength = 0;
size_t valueLength = 0;
status = napi_get_element(env, in, i, &tmpData);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "Could not able to read optionalData element!");
status = napi_get_named_property(env, tmpData, "name", &tmpName);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "Could not able to read optionalData property!");
status = napi_get_named_property(env, tmpData, "value", &tmpValue);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "Could not able to read optionalData property!");
status = napi_get_value_string_utf8(env, tmpName, nullptr, 0, &nameLength);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status,
"Could not able to transfer optionalData buffer info!");
status = napi_get_value_string_utf8(env, tmpValue, nullptr, 0, &valueLength);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status,
"Could not able to transfer optionalData buffer info!");
std::string name(nameLength, 0);
status = napi_get_value_string_utf8(env, tmpName, &name[0], nameLength + 1, &nameLength);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status,
"Could not able to transfer optionalData buffer info!");
std::string value(valueLength, 0);
status = napi_get_value_string_utf8(env, tmpValue, &value[0], valueLength + 1, &valueLength);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status,
"Could not able to transfer optionalData buffer info!");
valueMap.insert(std::make_pair(name, value));
}
}
return status;
}
napi_status NapiParamUtils::SetProvisionRequest(const napi_env &env, const NapiProvisionRequest &provisionRequest,
napi_value &result)
{
napi_status status = napi_create_object(env, &result);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "SetProvisionRequest napi_create_object failed");
status = SetValueString(env, "defaultURL", provisionRequest.defaultURL, result);
status = SetValueUint8Array(env, "data", provisionRequest.data, result);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "SetProvisionRequest SetValueUint8Array failed");
return status;
}
napi_status NapiParamUtils::SetMediaKeyRequest(const napi_env &env,
const IMediaKeySessionService::MediaKeyRequest &mediaKeyRequest, napi_value &result)
{
napi_status status = napi_create_object(env, &result);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "SetMediaKeyRequest napi_create_object failed");
status = SetValueInt32(env, "mediaKeyRequestType", mediaKeyRequest.requestType, result);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "SetMediaKeyRequest SetValueInt32 failed");
status = SetValueUint8Array(env, "data", mediaKeyRequest.mData, result);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "SetMediaKeyRequest SetValueUint8Array failed");
status = SetValueString(env, "defaultURL", mediaKeyRequest.mDefaultURL, result);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "SetMediaKeyRequest SetValueString failed");
return status;
}
napi_status NapiParamUtils::SetDrmEventInfo(const napi_env &env, DrmEventParame &eventParame, napi_value &result)
{
napi_status status = napi_create_object(env, &result);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "SetDrmEventInfo napi_create_object failed");
status = SetValueUint8Array(env, "info", eventParame.data, result);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "SetDrmEventInfo SetValueUint8Array failed");
status = SetValueString(env, "extraInfo", std::to_string(eventParame.extra), result);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "SetDrmEventInfo SetValueString failed");
return status;
}
napi_status NapiParamUtils::SetDrmKeysChangeEventInfo(const napi_env &env, DrmKeysChangeEventParame &eventParame,
napi_value &statusTable, napi_value &hasNewGoodLicense)
{
napi_status status = SetValueMap(env, eventParame.statusTable, statusTable);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "SetDrmKeysChangeEventInfo SetValueMap failed");
status = SetValueBoolean(env, eventParame.hasNewGoodLicense, hasNewGoodLicense);
DRM_NAPI_CHECK_AND_RETURN_LOG(status == napi_ok, status, "SetDrmKeysChangeEventInfo SetValueBoolean failed");
return napi_ok;
}
} // namespace DrmStandard
} // namespace OHOS
frameworks/native/BUILD.gn
+2
View File
@@ -79,6 +79,8 @@ ohos_shared_library("drm_framework") {
deps = []
external_deps = [
"ability_runtime:abilitykit_native",
"ability_runtime:napi_base_context",
"c_utils:utils",
"hilog:libhilog",
"hisysevent:libhisysevent",
frameworks/native/drm/key_session_impl.cpp
-1
View File
@@ -97,7 +97,6 @@ int32_t MediaKeySessionImpl::GenerateOfflineReleaseRequest(std::vector<uint8_t>
DRM_INFO_LOG("MediaKeySessionImpl::GenerateOfflineReleaseRequest enter.");
std::lock_guard<std::mutex> lock(mutex_);
int32_t retCode = DRM_OK;
if (keySessionServiceProxy_ == nullptr) {
DRM_ERR_LOG("MediaKeySessionImpl::GenerateOfflineReleaseRequest keySessionServiceProxy_ is null");
return DRM_SERVICE_ERROR;
frameworks/native/drm/media_key_system_factory_impl.cpp
+28 -20
View File
@@ -15,6 +15,8 @@
#include "media_key_system_factory_impl.h"
#include "i_mediakeysystem_service.h"
#include "drm_error_code.h"
#include "napi_param_utils.h"
namespace OHOS {
namespace DrmStandard {
@@ -95,15 +97,15 @@ bool MediaKeySystemFactoryImpl::IsMediaKeySystemSupported(std::string &uuid)
{
DRM_INFO_LOG("MediaKeySystemFactoryImpl::IsMediaKeySystemSupported enter.");
std::lock_guard<std::mutex> lock(mutex_);
int32_t retCode = DRM_OK;
int32_t ret = DRM_OK;
bool isSurpported = false;
if (serviceProxy_ == nullptr) {
DRM_ERR_LOG("MediaKeySystemFactoryImpl::IsMediaKeySystemSupported serviceProxy_ is null");
return isSurpported;
}
retCode = serviceProxy_->IsMediaKeySystemSupported(uuid, &isSurpported);
if (retCode != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemFactoryImpl::IsMediaKeySystemSupported failed, retCode: %{public}d", retCode);
ret = serviceProxy_->IsMediaKeySystemSupported(uuid, &isSurpported);
if (ret != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemFactoryImpl::IsMediaKeySystemSupported failed, ret: %{public}d", ret);
}
DRM_INFO_LOG("MediaKeySystemFactoryImpl::IsMediaKeySystemSupported exit.");
@@ -114,16 +116,16 @@ bool MediaKeySystemFactoryImpl::IsMediaKeySystemSupported(std::string &uuid, std
{
DRM_INFO_LOG("MediaKeySystemFactoryImpl::IsMediaKeySystemSupported enter.");
std::lock_guard<std::mutex> lock(mutex_);
int32_t retCode = DRM_OK;
int32_t ret = DRM_OK;
bool isSurpported = false;
if (serviceProxy_ == nullptr) {
DRM_ERR_LOG("MediaKeySystemFactoryImpl::IsMediaKeySystemSupported serviceProxy_ is null");
return isSurpported;
}
retCode = serviceProxy_->IsMediaKeySystemSupported(uuid, mimeType, &isSurpported);
if (retCode != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemFactoryImpl::IsMediaKeySystemSupported failed, retCode: %{public}d", retCode);
ret = serviceProxy_->IsMediaKeySystemSupported(uuid, mimeType, &isSurpported);
if (ret != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemFactoryImpl::IsMediaKeySystemSupported failed, ret: %{public}d", ret);
}
DRM_INFO_LOG("MediaKeySystemFactoryImpl::IsMediaKeySystemSupported exit.");
@@ -135,16 +137,16 @@ bool MediaKeySystemFactoryImpl::IsMediaKeySystemSupported(std::string &uuid, std
{
DRM_INFO_LOG("MediaKeySystemFactoryImpl::IsMediaKeySystemSupported enter.");
std::lock_guard<std::mutex> lock(mutex_);
int32_t retCode = DRM_OK;
int32_t ret = DRM_OK;
bool isSurpported = false;
if (serviceProxy_ == nullptr) {
DRM_ERR_LOG("MediaKeySystemFactoryImpl::IsMediaKeySystemSupported serviceProxy_ is null");
return isSurpported;
}
retCode = serviceProxy_->IsMediaKeySystemSupported(uuid, mimeType, securityLevel, &isSurpported);
if (retCode != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemFactoryImpl::IsMediaKeySystemSupported failed, retCode: %{public}d", retCode);
ret = serviceProxy_->IsMediaKeySystemSupported(uuid, mimeType, securityLevel, &isSurpported);
if (ret != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemFactoryImpl::IsMediaKeySystemSupported failed, ret: %{public}d", ret);
}
DRM_INFO_LOG("MediaKeySystemFactoryImpl::IsMediaKeySystemSupported exit.");
@@ -156,31 +158,37 @@ int32_t MediaKeySystemFactoryImpl::CreateMediaKeySystem(std::string &uuid, sptr<
DRM_INFO_LOG("MediaKeySystemFactoryImpl:: CreateMediaKeySystem enter.");
sptr<IMediaKeySystemService> mediaKeySystemProxy = nullptr;
sptr<MediaKeySystemImpl> localMediaKeySystemImpl = nullptr;
int32_t retCode = DRM_OK;
int32_t ret = DRM_OK;
if (mediaKeySystemImpl == nullptr) {
DRM_ERR_LOG("MediaKeySystemImpl:: mediaKeySystemImpl is nullptr");
return DRM_INVALID_ARG;
return DRM_INVALID_PARAM;
}
if (serviceProxy_ == nullptr) {
DRM_ERR_LOG("MediaKeySystemFactoryImpl:: serviceProxy_ == nullptr");
return DRM_SERVICE_ERROR;
return DRM_SERVICE_FATAL_ERROR;
}
retCode = serviceProxy_->CreateMediaKeySystem(uuid, mediaKeySystemProxy);
if (retCode == DRM_OK) {
ret = serviceProxy_->CreateMediaKeySystem(uuid, mediaKeySystemProxy);
if (ret == DRM_OK) {
if (mediaKeySystemProxy != nullptr) {
localMediaKeySystemImpl = new (std::nothrow) MediaKeySystemImpl(mediaKeySystemProxy);
if (localMediaKeySystemImpl == nullptr) {
DRM_ERR_LOG("Failed to new MediaKeySystemImpl");
return DRM_ALLOC_ERROR;
return DRM_SERVICE_FATAL_ERROR;
}
keySystemNumber++;
if (keySystemNumber > KEY_SYSTEM_MAX_NUMBER) {
keySystemNumber--;
DRM_ERR_LOG("The number of MediaKeySystem is greater than 64");
return DRM_MAX_SYSTEM_NUM_REACHED;
}
} else {
DRM_ERR_LOG("mediaKeySystemProxy is nullptr");
return DRM_UNKNOWN_ERROR;
}
} else {
DRM_ERR_LOG("Failed to get session object from mediakeysystem service!, %{public}d", retCode);
return DRM_SERVICE_ERROR;
DRM_ERR_LOG("Failed to get session object from mediakeysystem service!, %{public}d", ret);
return DRM_SERVICE_FATAL_ERROR;
}
*mediaKeySystemImpl = localMediaKeySystemImpl;
DRM_INFO_LOG("MediaKeySystemFactoryImpl:: CreateMediaKeySystem exit.");
frameworks/native/drm/media_key_system_impl.cpp
+81 -62
View File
@@ -15,6 +15,8 @@
#include "media_key_system_impl.h"
#include "i_mediakeysystem_service.h"
#include "drm_error_code.h"
#include "napi_param_utils.h"
namespace OHOS {
namespace DrmStandard {
@@ -52,15 +54,15 @@ int32_t MediaKeySystemImpl::GenerateKeySystemRequest(std::vector<uint8_t> &reque
{
DRM_INFO_LOG("MediaKeySystemImpl::GenerateKeySystemRequest enter.");
std::lock_guard<std::mutex> lock(mutex_);
int32_t retCode = DRM_OK;
int32_t ret = DRM_OK;
if (serviceProxy_ == nullptr) {
DRM_ERR_LOG("MediaKeySystemImpl::GenerateKeySystemRequest serviceProxy_ is null");
return DRM_SERVICE_ERROR;
}
retCode = serviceProxy_->GenerateKeySystemRequest(request, defaultUrl);
if (retCode != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::GenerateKeySystemRequest failed, retCode: %{public}d", retCode);
ret = serviceProxy_->GenerateKeySystemRequest(request, defaultUrl);
if (ret != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::GenerateKeySystemRequest failed, ret: %{public}d", ret);
return DRM_SERVICE_ERROR;
}
DRM_INFO_LOG("MediaKeySystemImpl::GenerateKeySystemRequest exit.");
@@ -71,15 +73,15 @@ int32_t MediaKeySystemImpl::ProcessKeySystemResponse(const std::vector<uint8_t>
{
DRM_INFO_LOG("MediaKeySystemImpl::ProcessKeySystemResponse enter.");
std::lock_guard<std::mutex> lock(mutex_);
int32_t retCode = DRM_OK;
int32_t ret = DRM_OK;
if (serviceProxy_ == nullptr) {
DRM_ERR_LOG("MediaKeySystemImpl::ProcessKeySystemResponse serviceProxy_ is null");
return DRM_SERVICE_ERROR;
}
retCode = serviceProxy_->ProcessKeySystemResponse(response);
if (retCode != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::ProcessKeySystemResponse failed, retCode: %{public}d", retCode);
ret = serviceProxy_->ProcessKeySystemResponse(response);
if (ret != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::ProcessKeySystemResponse failed, ret: %{public}d", ret);
return DRM_SERVICE_ERROR;
}
DRM_INFO_LOG("MediaKeySystemImpl::ProcessKeySystemResponse exit.");
@@ -91,15 +93,15 @@ int32_t MediaKeySystemImpl::SetConfigurationString(std::string &configName, std:
DRM_INFO_LOG("MediaKeySystemImpl::SetConfiguration enter, configName:%{public}s, value:%{public}s.",
configName.c_str(), value.c_str());
std::lock_guard<std::mutex> lock(mutex_);
int32_t retCode = DRM_OK;
int32_t ret = DRM_OK;
if (serviceProxy_ == nullptr) {
DRM_ERR_LOG("MediaKeySystemImpl::SetConfiguration serviceProxy_ is null");
return DRM_SERVICE_ERROR;
}
retCode = serviceProxy_->SetConfigurationString(configName, value);
if (retCode != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::SetConfiguration failed, retCode: %{public}d", retCode);
ret = serviceProxy_->SetConfigurationString(configName, value);
if (ret != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::SetConfiguration failed, ret: %{public}d", ret);
return DRM_SERVICE_ERROR;
}
DRM_INFO_LOG("MediaKeySystemImpl::SetConfiguration exit.");
@@ -110,15 +112,15 @@ int32_t MediaKeySystemImpl::GetConfigurationString(std::string &configName, std:
{
DRM_INFO_LOG("MediaKeySystemImpl::GetConfiguration enter, configName:%{public}s.", configName.c_str());
std::lock_guard<std::mutex> lock(mutex_);
int32_t retCode = DRM_OK;
int32_t ret = DRM_OK;
if (serviceProxy_ == nullptr) {
DRM_ERR_LOG("MediaKeySystemImpl::GetConfiguration serviceProxy_ is null");
return DRM_SERVICE_ERROR;
}
retCode = serviceProxy_->GetConfigurationString(configName, value);
if (retCode != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::GetConfiguration failed, retCode: %{public}d", retCode);
ret = serviceProxy_->GetConfigurationString(configName, value);
if (ret != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::GetConfiguration failed, ret: %{public}d", ret);
return DRM_SERVICE_ERROR;
}
@@ -130,15 +132,15 @@ int32_t MediaKeySystemImpl::SetConfigurationByteArray(std::string &configName, s
{
DRM_INFO_LOG("MediaKeySystemImpl::SetConfiguration enter, configName:%{public}s.", configName.c_str());
std::lock_guard<std::mutex> lock(mutex_);
int32_t retCode = DRM_OK;
int32_t ret = DRM_OK;
if (serviceProxy_ == nullptr) {
DRM_ERR_LOG("MediaKeySystemImpl::SetConfiguration serviceProxy_ is null");
return DRM_SERVICE_ERROR;
}
retCode = serviceProxy_->SetConfigurationByteArray(configName, value);
if (retCode != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::SetConfiguration failed, retCode: %{public}d", retCode);
ret = serviceProxy_->SetConfigurationByteArray(configName, value);
if (ret != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::SetConfiguration failed, ret: %{public}d", ret);
return DRM_SERVICE_ERROR;
}
DRM_INFO_LOG("MediaKeySystemImpl::SetConfiguration exit.");
@@ -149,15 +151,15 @@ int32_t MediaKeySystemImpl::GetConfigurationByteArray(std::string &configName, s
{
DRM_INFO_LOG("MediaKeySystemImpl::GetConfiguration enter, configName:%{public}s.", configName.c_str());
std::lock_guard<std::mutex> lock(mutex_);
int32_t retCode = DRM_OK;
int32_t ret = DRM_OK;
if (serviceProxy_ == nullptr) {
DRM_ERR_LOG("MediaKeySystemImpl::GetConfiguration serviceProxy_ is null");
return DRM_SERVICE_ERROR;
}
retCode = serviceProxy_->GetConfigurationByteArray(configName, value);
if (retCode != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::GetConfiguration failed, retCode: %{public}d", retCode);
ret = serviceProxy_->GetConfigurationByteArray(configName, value);
if (ret != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::GetConfiguration failed, ret: %{public}d", ret);
return DRM_SERVICE_ERROR;
}
@@ -170,30 +172,47 @@ int32_t MediaKeySystemImpl::CreateMediaKeySession(IMediaKeySessionService::Conte
DRM_INFO_LOG("MediaKeySystemImpl::CreateMediaKeySession enter.");
sptr<IMediaKeySessionService> keySessionProxy = nullptr;
sptr<MediaKeySessionImpl> localMediaKeySessionImpl = nullptr;
int32_t retCode = DRM_OK;
int32_t ret = DRM_OK;
/* To determine if any members in the keySession list have been destroyed,
* the keySessionNumber needs to be reduced by one
*/
for (size_t i = 0; i < keySessionVec.size(); i++) {
/* In the case of initial and complete destruction,
* all members of the keySession list are null pointers
*/
if (keySessionNumber > 0 && keySessionVec[i] == nullptr) {
keySessionNumber--;
keySessionVec.erase(keySessionVec.begin() + i);
}
}
if (serviceProxy_ == nullptr) {
DRM_ERR_LOG("MediaKeySystemImpl:: serviceProxy_ == nullptr");
return DRM_SERVICE_ERROR;
return DRM_SERVICE_FATAL_ERROR;
}
retCode = serviceProxy_->CreateMediaKeySession(securityLevel, keySessionProxy);
if (retCode == DRM_OK) {
ret = serviceProxy_->CreateMediaKeySession(securityLevel, keySessionProxy);
if (ret == DRM_OK) {
if (keySessionProxy != nullptr) {
localMediaKeySessionImpl = new (std::nothrow) MediaKeySessionImpl(keySessionProxy);
if (localMediaKeySessionImpl == nullptr) {
DRM_ERR_LOG("Failed to new MediaKeySessionImpl");
return DRM_ALLOC_ERROR;
return DRM_SERVICE_FATAL_ERROR;
}
if (keySessionNumber > KEY_SESSION_MAX_NUMBER) {
DRM_ERR_LOG("The number of MediaKeySession is greater than 64");
return DRM_MAX_SESSION_NUM_REACHED;
}
keySessionNumber++;
} else {
DRM_ERR_LOG("Failed to CreateMediaKeySessionImpl with session is null");
return DRM_UNKNOWN_ERROR;
}
} else {
DRM_ERR_LOG("Failed to get session object from mediakeysystem service!, %{public}d", retCode);
return DRM_SERVICE_ERROR;
DRM_ERR_LOG("Failed to get session object from mediakeysystem service!, %{public}d", ret);
return DRM_SERVICE_FATAL_ERROR;
}
*keySessionImpl = localMediaKeySessionImpl;
keySessionVec.push_back(localMediaKeySessionImpl);
DRM_INFO_LOG("MediaKeySystemImpl::CreateMediaKeySession exit.");
return DRM_OK;
}
@@ -202,15 +221,15 @@ int32_t MediaKeySystemImpl::GetStatistics(std::vector<IMediaKeySystemService::Me
{
DRM_INFO_LOG("MediaKeySystemImpl::GetStatistics enter.");
std::lock_guard<std::mutex> lock(mutex_);
int32_t retCode = DRM_OK;
int32_t ret = DRM_OK;
if (serviceProxy_ == nullptr) {
DRM_ERR_LOG("MediaKeySystemImpl::GetStatistics serviceProxy_ is null");
return DRM_SERVICE_ERROR;
}
retCode = serviceProxy_->GetStatistics(metrics);
if (retCode != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::GetStatistics failed, retCode: %{public}d", retCode);
ret = serviceProxy_->GetStatistics(metrics);
if (ret != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::GetStatistics failed, ret: %{public}d", ret);
return DRM_SERVICE_ERROR;
}
DRM_INFO_LOG("MediaKeySystemImpl::GetStatistics exit.");
@@ -221,17 +240,17 @@ int32_t MediaKeySystemImpl::GetMaxContentProtectionLevel(IMediaKeySessionService
{
DRM_INFO_LOG("MediaKeySystemImpl::GetMaxContentProtectionLevel enter.");
std::lock_guard<std::mutex> lock(mutex_);
int32_t retCode = DRM_OK;
int32_t ret = DRM_OK;
if (serviceProxy_ == nullptr) {
DRM_ERR_LOG("MediaKeySystemImpl::GetMaxContentProtectionLevel serviceProxy_ is null");
return DRM_SERVICE_ERROR;
}
retCode =
ret =
serviceProxy_->GetMaxContentProtectionLevel((IMediaKeySessionService::ContentProtectionLevel *)securityLevel);
DRM_ERR_LOG("MediaKeySystemImpl::GetMaxContentProtectionLevel 277");
if (retCode != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::GetMaxContentProtectionLevel failed, retCode: %{public}d", retCode);
if (ret != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::GetMaxContentProtectionLevel failed, ret: %{public}d", ret);
return DRM_SERVICE_ERROR;
}
DRM_INFO_LOG("MediaKeySystemImpl::GetMaxContentProtectionLevel exit.");
@@ -242,15 +261,15 @@ int32_t MediaKeySystemImpl::GetOfflineMediaKeyIds(std::vector<std::vector<uint8_
{
DRM_INFO_LOG("MediaKeySystemImpl::GetOfflineMediaKeyIds enter.");
std::lock_guard<std::mutex> lock(mutex_);
int32_t retCode = DRM_OK;
int32_t ret = DRM_OK;
if (serviceProxy_ == nullptr) {
DRM_ERR_LOG("MediaKeySystemImpl::GetOfflineMediaKeyIds serviceProxy_ is null");
return DRM_SERVICE_ERROR;
}
retCode = serviceProxy_->GetOfflineMediaKeyIds(licenseIds);
if (retCode != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::GetOfflineMediaKeyIds failed, retCode: %{public}d", retCode);
ret = serviceProxy_->GetOfflineMediaKeyIds(licenseIds);
if (ret != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::GetOfflineMediaKeyIds failed, ret: %{public}d", ret);
return DRM_SERVICE_ERROR;
}
DRM_INFO_LOG("MediaKeySystemImpl::GetOfflineMediaKeyIds exit");
@@ -262,15 +281,15 @@ int32_t MediaKeySystemImpl::GetOfflineMediaKeyStatus(std::vector<uint8_t> &licen
{
DRM_INFO_LOG("MediaKeySystemImpl::GetOfflineMediaKeyStatus enter.");
std::lock_guard<std::mutex> lock(mutex_);
int32_t retCode = DRM_OK;
int32_t ret = DRM_OK;
if (serviceProxy_ == nullptr) {
DRM_ERR_LOG("MediaKeySystemImpl::GetOfflineMediaKeyStatus serviceProxy_ is null");
return DRM_SERVICE_ERROR;
}
retCode = serviceProxy_->GetOfflineMediaKeyStatus(licenseId, status);
if (retCode != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::GetOfflineMediaKeyStatus failed, retCode: %{public}d", retCode);
ret = serviceProxy_->GetOfflineMediaKeyStatus(licenseId, status);
if (ret != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::GetOfflineMediaKeyStatus failed, ret: %{public}d", ret);
return DRM_SERVICE_ERROR;
}
DRM_INFO_LOG("MediaKeySystemImpl::GetOfflineMediaKeyStatus exit.");
@@ -281,14 +300,14 @@ int32_t MediaKeySystemImpl::ClearOfflineMediaKeys(std::vector<uint8_t> &licenseI
{
DRM_INFO_LOG("MediaKeySystemImpl::ClearOfflineMediaKeys enter.");
std::lock_guard<std::mutex> lock(mutex_);
int32_t retCode = DRM_OK;
int32_t ret = DRM_OK;
if (serviceProxy_ == nullptr) {
DRM_ERR_LOG("MediaKeySystemImpl::ClearOfflineMediaKeys serviceProxy_ is null");
return DRM_SERVICE_ERROR;
}
retCode = serviceProxy_->ClearOfflineMediaKeys(licenseId);
if (retCode != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::ClearOfflineMediaKeys failed, retCode: %{public}d", retCode);
ret = serviceProxy_->ClearOfflineMediaKeys(licenseId);
if (ret != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::ClearOfflineMediaKeys failed, ret: %{public}d", ret);
return DRM_SERVICE_ERROR;
}
DRM_INFO_LOG("MediaKeySystemImpl::ClearOfflineMediaKeys exit");
@@ -299,16 +318,16 @@ int32_t MediaKeySystemImpl::GetCertificateStatus(IMediaKeySystemService::Certifi
{
DRM_INFO_LOG("MediaKeySystemImpl::GetCertificateStatus enter.");
std::lock_guard<std::mutex> lock(mutex_);
int32_t retCode = DRM_OK;
int32_t ret = DRM_OK;
if (serviceProxy_ == nullptr) {
DRM_ERR_LOG("MediaKeySystemImpl::GetCertificateStatus serviceProxy_ is null");
return DRM_SERVICE_ERROR;
}
retCode = serviceProxy_->GetCertificateStatus((IMediaKeySystemService::CertificateStatus *)certStatus);
ret = serviceProxy_->GetCertificateStatus((IMediaKeySystemService::CertificateStatus *)certStatus);
DRM_ERR_LOG("MediaKeySystemImpl::GetCertificateStatus 277");
if (retCode != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::GetCertificateStatus failed, retCode: %{public}d", retCode);
if (ret != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::GetCertificateStatus failed, ret: %{public}d", ret);
return DRM_SERVICE_ERROR;
}
DRM_INFO_LOG("MediaKeySystemImpl::GetCertificateStatus exit.");
@@ -321,11 +340,11 @@ int32_t MediaKeySystemImpl::SetCallback(const sptr<MediaKeySystemImplCallback> &
DRM_CHECK_AND_RETURN_RET_LOG(callback != nullptr, DRM_INVALID_ARG, "callback is nullptr");
mediaKeySystemApplicationCallback_ = callback;
int32_t retCode = DRM_ERROR;
int32_t ret = DRM_ERROR;
serviceCallback_ = new (std::nothrow) MediaKeySystemCallback(this);
if (serviceCallback_ == nullptr) {
DRM_ERR_LOG("MediaKeySystemImpl:: MediaKeySystemCallback alloc failed");
return retCode;
return ret;
}
std::lock_guard<std::mutex> lock(mutex_);
@@ -333,13 +352,13 @@ int32_t MediaKeySystemImpl::SetCallback(const sptr<MediaKeySystemImplCallback> &
DRM_ERR_LOG("MediaKeySystemImpl::SetCallback serviceProxy_ is null");
return DRM_SERVICE_ERROR;
}
retCode = serviceProxy_->SetCallback(serviceCallback_);
if (retCode != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::SetCallback failed, retCode: %{public}d", retCode);
ret = serviceProxy_->SetCallback(serviceCallback_);
if (ret != DRM_OK) {
DRM_ERR_LOG("MediaKeySystemImpl::SetCallback failed, ret: %{public}d", ret);
return DRM_SERVICE_ERROR;
}
DRM_INFO_LOG("MediaKeySystemImpl::SetCallback exit.");
return retCode;
return ret;
}
sptr<MediaKeySystemImplCallback> MediaKeySystemImpl::GetApplicationCallback()
frameworks/native/test/unittest/BUILD.gn
+1
View File
@@ -55,6 +55,7 @@ ohos_unittest("drm_framework_capi_unittest_v1_0") {
deps = [
"../../../../frameworks/native:drm_framework",
"../../../../interfaces/kits/c/drm_capi:native_drm",
"../../../../interfaces/kits/js/drm_napi:drm_napi",
"../../../../services/drm_service:drm_service",
"//third_party/googletest:gmock_main",
]
frameworks/native/test/unittest/src/drm_framework_unittest.cpp
-3
View File
@@ -18,7 +18,6 @@
#include <refbase.h>
#include <securec.h>
#include "drm_log.h"
#include "drm_error_code.h"
#include "native_drm_base.h"
#include "native_drm_object.h"
#include "key_session_impl.h"
@@ -29,7 +28,6 @@
#include "native_drm_common.h"
#include "native_drm_err.h"
#include "gmock/gmock.h"
#include "drm_error_code.h"
#include "native_drm_base.h"
#include "native_drm_object.h"
#include "key_session_impl.h"
@@ -49,7 +47,6 @@
#include "drm_types.h"
#include "drm_framework_unittest.h"
#include "drm_log.h"
#include "drm_error_code.h"
#define DRM_SAMPLE_CHECK_AND_RETURN_RET_LOG(cond, ret, fmt, ...) \
do { \
interfaces/inner_api/native/drm/key_session_impl.h
+1 -1
View File
@@ -39,7 +39,7 @@ class MediaKeySessionImplCallback : public RefBase {
public:
MediaKeySessionImplCallback() = default;
virtual ~MediaKeySessionImplCallback() = default;
virtual void SendEvent(const std::string event, int32_t extra, const std::vector<uint8_t> data) = 0;
virtual void SendEvent(const std::string &event, int32_t extra, const std::vector<uint8_t> &data) = 0;
virtual void SendEventKeyChanged(std::map<std::vector<uint8_t>, MediaKeySessionKeyStatus> statusTable,
bool hasNewGoodLicense) = 0;
};
interfaces/inner_api/native/drm/media_key_system_factory_impl.h
+1 -1
View File
@@ -24,7 +24,6 @@
#include "i_mediakeysystemfactory_service.h"
#include "drm_death_recipient.h"
#include "drm_log.h"
#include "drm_error_code.h"
namespace OHOS {
namespace DrmStandard {
@@ -39,6 +38,7 @@ public:
bool IsMediaKeySystemSupported(std::string &uuid, std::string &mimeType,
IMediaKeySessionService::ContentProtectionLevel securityLevel);
int32_t CreateMediaKeySystem(std::string &uuid, sptr<MediaKeySystemImpl> *mediaKeySystemImpl);
int32_t keySystemNumber = 0;
private:
void MediaKeySystemServerDied(pid_t pid);
interfaces/inner_api/native/drm/media_key_system_impl.h
+3 -2
View File
@@ -21,7 +21,6 @@
#include "nocopyable.h"
#include "system_ability_definition.h"
#include "drm_log.h"
#include "drm_error_code.h"
#include "drm_death_recipient.h"
#include "key_session_impl.h"
#include "i_mediakeysystem_service.h"
@@ -36,7 +35,7 @@ class MediaKeySystemImplCallback : public RefBase {
public:
MediaKeySystemImplCallback() = default;
virtual ~MediaKeySystemImplCallback() = default;
virtual void SendEvent(const std::string event, int32_t extra, const std::vector<uint8_t> data) = 0;
virtual void SendEvent(const std::string &event, int32_t extra, const std::vector<uint8_t> &data) = 0;
};
class MediaKeySystemImpl : public RefBase {
@@ -71,6 +70,8 @@ private:
sptr<IMediaKeySystemService> serviceProxy_;
sptr<MediaKeySystemImplCallback> mediaKeySystemApplicationCallback_;
sptr<IMeidaKeySystemServiceCallback> serviceCallback_;
std::vector<sptr<MediaKeySessionImpl>> keySessionVec;
uint32_t keySessionNumber = 0;
};
class MediaKeySystemCallback : public MeidaKeySystemServiceCallbackStub {
interfaces/kits/c/drm_capi/common/native_drm_object.h
+2 -2
View File
@@ -83,7 +83,7 @@ public:
callback_ = nullptr;
}
void SendEvent(const std::string event, int32_t extra, const std::vector<uint8_t> data) override
void SendEvent(const std::string &event, int32_t extra, const std::vector<uint8_t> &data) override
{
DRM_INFO_LOG("MediaKeySystemCallbackCapi SendEvent.");
std::lock_guard<std::mutex> lock(mutex_);
@@ -150,7 +150,7 @@ public:
callback_ = {};
}
void SendEvent(const std::string event, int32_t extra, const std::vector<uint8_t> data) override
void SendEvent(const std::string &event, int32_t extra, const std::vector<uint8_t> &data) override
{
DRM_INFO_LOG("MediaKeySessionCallbackCapi SendEvent.");
std::lock_guard<std::mutex> lock(mutex_);
interfaces/kits/js/drm_napi/BUILD.gn
+5 -1
View File
@@ -30,7 +30,6 @@ ohos_copy("drm_declaration") {
ohos_shared_library("drm_napi") {
include_dirs = [
"./../../../../frameworks/js/common",
"./../../../../frameworks/js/drm_napi",
"./../../../../frameworks/native/drm",
"./../../../../frameworks/native/common",
@@ -45,15 +44,20 @@ ohos_shared_library("drm_napi") {
]
sources = [
"./../../../../frameworks/js/drm_napi/drm_enum_napi.cpp",
"./../../../../frameworks/js/drm_napi/drm_error_code.cpp",
"./../../../../frameworks/js/drm_napi/drm_napi.cpp",
"./../../../../frameworks/js/drm_napi/key_session_callback_napi.cpp",
"./../../../../frameworks/js/drm_napi/key_session_napi.cpp",
"./../../../../frameworks/js/drm_napi/media_key_system_callback_napi.cpp",
"./../../../../frameworks/js/drm_napi/media_key_system_napi.cpp",
"./../../../../frameworks/js/drm_napi/napi_async_work.cpp",
"./../../../../frameworks/js/drm_napi/napi_param_utils.cpp",
"./../../../../frameworks/js/drm_napi/native_module_ohos_drm.cpp",
]
deps = [ "./../../../../frameworks/native:drm_framework" ]
external_deps = [
"ability_runtime:abilitykit_native",
"ability_runtime:napi_base_context",
"access_token:libtokenid_sdk",
"c_utils:utils",
"hilog:libhilog",
interfaces/kits/js/drm_napi/include/key_session_callback_napi.h
+19 -4
View File
@@ -21,22 +21,37 @@
#include "napi/native_api.h"
#include "napi/native_node_api.h"
#include "common_napi.h"
#include "napi_param_utils.h"
#include "napi_async_work.h"
namespace OHOS {
namespace DrmStandard {
class MediaKeySessionCallbackNapi : public MediaKeySessionImplCallback {
public:
explicit MediaKeySessionCallbackNapi();
explicit MediaKeySessionCallbackNapi(napi_env env);
virtual ~MediaKeySessionCallbackNapi();
void SetCallbackReference(const std::string eventType, sptr<CallBackPair> callbackPair);
void SetCallbackReference(const std::string eventType, std::shared_ptr<AutoRef> callbackPair);
void ClearCallbackReference(const std::string eventType);
void SendEvent(const std::string event, int32_t extra, const std::vector<uint8_t> data) override;
void SendEvent(const std::string &event, int32_t extra, const std::vector<uint8_t> &data) override;
void SendEventKeyChanged(std::map<std::vector<uint8_t>, MediaKeySessionKeyStatus> statusTable,
bool hasNewGoodLicense) override;
private:
struct MediaKeySessionJsCallback {
std::shared_ptr<AutoRef> callback = nullptr;
std::string callbackName = "unknown";
DrmEventParame eventParame;
DrmKeysChangeEventParame keysChangeParame;
};
static void WorkCallbackStateChangeDone(uv_work_t *work, int status);
static void WorkCallbackInterruptDone(uv_work_t *work, int status);
void OnJsCallbackInterrupt(std::unique_ptr<MediaKeySessionJsCallback> &jsCb);
void OnJsCallbackStateChange(std::unique_ptr<MediaKeySessionJsCallback> &jsCb);
napi_env env_ = nullptr;
std::mutex mutex_;
std::map<std::string, sptr<CallBackPair>> callbackMap_;
std::map<std::string, std::shared_ptr<AutoRef>> callbackMap_;
};
} // namespace DrmStandard
} // namespace OHOS
interfaces/kits/js/drm_napi/include/key_session_napi.h
+21 -1
View File
@@ -22,10 +22,27 @@
#include "drm_error_code.h"
#include "key_session_callback_napi.h"
#include "key_session_impl.h"
#include "napi_param_utils.h"
#include "drm_error_code.h"
#include "napi_async_work.h"
namespace OHOS {
namespace DrmStandard {
static const char KEY_SESSION_NAPI_CLASS_NAME[] = "MediaKeySession";
struct MediaKeySessionAsyncContext : public ContextBase {
int32_t intValue;
std::vector<uint8_t> response;
std::vector<uint8_t> licenseId;
std::vector<uint8_t> releaseRequest;
std::vector<uint8_t> releaseLicenseId;
std::vector<uint8_t> restoreLicenseId;
std::vector<uint8_t> releaseResponse;
std::vector<uint8_t> releaseResponseLicenseId;
IMediaKeySessionService::MediaKeyRequestInfo mediaKeyRequestInfo;
IMediaKeySessionService::MediaKeyRequest mediaKeyRequest;
};
class MediaKeySessionNapi {
public:
MediaKeySessionNapi();
@@ -48,9 +65,12 @@ public:
static napi_value UnsetEventCallback(napi_env env, napi_callback_info info);
static bool SetMediaKeySessionNativeProperty(napi_env env, napi_value obj, const std::string &name,
sptr<MediaKeySessionImpl> keySessionImpl);
void SetEventCallbackReference(const std::string eventType, sptr<CallBackPair> callbackPair);
void SetEventCallbackReference(const std::string eventType, std::shared_ptr<AutoRef> callbackPair);
void ClearEventCallbackReference(const std::string eventType);
static napi_value Destroy(napi_env env, napi_callback_info info);
static bool CheckMediaKeySessionStatus(MediaKeySessionNapi *napi,
std::shared_ptr<MediaKeySessionAsyncContext> context);
static bool CheckContextStatus(std::shared_ptr<MediaKeySessionAsyncContext> context);
private:
static napi_value MediaKeySessionNapiConstructor(napi_env env, napi_callback_info info);
interfaces/kits/js/drm_napi/include/media_key_system_callback_napi.h
+17 -4
View File
@@ -19,20 +19,33 @@
#include "napi/native_node_api.h"
#include "common_napi.h"
#include "media_key_system_impl.h"
#include "napi_param_utils.h"
#include "napi_async_work.h"
namespace OHOS {
namespace DrmStandard {
class MediaKeySystemCallbackNapi : public MediaKeySystemImplCallback {
public:
explicit MediaKeySystemCallbackNapi();
explicit MediaKeySystemCallbackNapi(napi_env env);
virtual ~MediaKeySystemCallbackNapi();
void SetCallbackReference(const std::string eventType, sptr<CallBackPair> callbackPair);
void SetCallbackReference(const std::string eventType, std::shared_ptr<AutoRef> callbackPair);
void ClearCallbackReference(const std::string eventType);
void SendEvent(const std::string event, int32_t extra, const std::vector<uint8_t> data) override;
void SendEvent(const std::string &event, int32_t extra, const std::vector<uint8_t> &data) override;
private:
struct MediaKeySystemJsCallback {
std::shared_ptr<AutoRef> callback = nullptr;
std::string callbackName = "unknown";
DrmEventParame eventParame;
};
static void WorkCallbackStateChangeDone(uv_work_t *work, int status);
static void WorkCallbackInterruptDone(uv_work_t *work, int status);
void OnJsCallbackInterrupt(std::unique_ptr<MediaKeySystemJsCallback> &jsCb);
void OnJsCallbackStateChange(std::unique_ptr<MediaKeySystemJsCallback> &jsCb);
napi_env env_ = nullptr;
std::mutex mutex_;
std::map<std::string, sptr<CallBackPair>> callbackMap_;
std::map<std::string, std::shared_ptr<AutoRef>> callbackMap_;
};
} // namespace DrmStandard
} // namespace OHOS
interfaces/kits/js/drm_napi/include/media_key_system_napi.h
+13 -1
View File
@@ -33,11 +33,20 @@
#include "media_key_system_impl.h"
#include "media_key_system_factory_impl.h"
#include "media_key_system_callback_napi.h"
#include "napi_param_utils.h"
#include "drm_error_code.h"
#include "napi_async_work.h"
namespace OHOS {
namespace DrmStandard {
static const char MEDIA_KEY_SYSTEM_NAPI_CLASS_NAME[] = "MediaKeySystem";
struct MediaKeySystemAsyncContext : public ContextBase {
int32_t intValue;
NapiProvisionRequest provisionRequest;
std::vector<uint8_t> response;
};
class MediaKeySystemNapi {
public:
static napi_value Init(napi_env env, napi_value exports);
@@ -64,8 +73,11 @@ public:
static napi_value SetEventCallback(napi_env env, napi_callback_info info);
static napi_value UnsetEventCallback(napi_env env, napi_callback_info info);
void SaveEventCallbackReferrence(const std::string eventType, sptr<CallBackPair> callbackPair);
void SaveEventCallbackReferrence(const std::string eventType, std::shared_ptr<AutoRef> callbackPair);
void ClearEventCallbackReferrence(const std::string eventType);
static bool CheckMediaKeySystemStatus(MediaKeySystemNapi *napi,
std::shared_ptr<MediaKeySystemAsyncContext> context);
static bool CheckContextStatus(std::shared_ptr<MediaKeySystemAsyncContext> context);
private:
static napi_value MediaKeySystemNapiConstructor(napi_env env, napi_callback_info info);
services/drm_service/BUILD.gn
+2
View File
@@ -42,6 +42,8 @@ ohos_shared_library("drm_service") {
external_deps = [
"ability_base:want",
"ability_runtime:abilitykit_native",
"ability_runtime:napi_base_context",
"access_token:libaccesstoken_sdk",
"access_token:libprivacy_sdk",
"bundle_framework:appexecfwk_base",
services/drm_service/ipc/i_mediakeysystem_service.h
+4 -4
View File
@@ -48,10 +48,10 @@ public:
enum CertificateStatus {
CERT_STATUS_PROVISIONED = 0,
CERT_STATUS_NOT_PROVISIONED = 1,
CERT_STATUS_EXPIRED = 3,
CERT_STATUS_INVALID = 4,
CERT_STATUS_UNAVAILABLE = 5,
CERT_STATUS_NOT_PROVISIONED,
CERT_STATUS_EXPIRED,
CERT_STATUS_INVALID,
CERT_STATUS_UNAVAILABLE,
};
struct MetircKeyValue {
services/drm_service/server/src/drm_host_manager.cpp
+1 -1
View File
@@ -22,7 +22,7 @@
#include "servmgr_hdi.h"
#include "drm_log.h"
#include "drm_error_code.h"
#include "drm_napi_utils.h"
#include "napi_param_utils.h"
#include "drm_host_manager.h"
namespace OHOS {
services/drm_service/server/src/key_session_service_callback_stub.cpp
+1 -1
View File
@@ -22,7 +22,7 @@ namespace DrmStandard {
int32_t MediaKeySessionServiceCallbackStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply,
MessageOption &option)
{
int32_t errCode = -1;
int32_t errCode = DRM_ERROR;
if (data.ReadInterfaceToken() != GetDescriptor()) {
return errCode;
}
services/drm_service/server/src/key_session_service_stub.cpp
+1 -1
View File
@@ -366,7 +366,7 @@ int32_t MediaKeySessionServiceStub::OnRemoteRequest(uint32_t code, MessageParcel
MessageOption &option)
{
DRM_INFO_LOG("MediaKeySessionServiceStub::OnRemoteRequest enter.");
int32_t errCode = -1;
int32_t errCode = DRM_ERROR;
DRM_DEBUG_LOG("OnRemoteRequest, cmd = %{public}u", code);
DRM_DEBUG_LOG("0x%{public}06" PRIXPTR " is keySessionServiceStub", FAKE_POINTER(this));
services/drm_service/server/src/mediakeysystem_service_callback_stub.cpp
+1 -1
View File
@@ -23,7 +23,7 @@ namespace DrmStandard {
int32_t MeidaKeySystemServiceCallbackStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply,
MessageOption &option)
{
int32_t errCode = -1;
int32_t errCode = DRM_ERROR;
if (data.ReadInterfaceToken() != GetDescriptor()) {
return errCode;
services/utils/include/drm_error_code.h
+29 -19
View File
@@ -15,29 +15,39 @@
#ifndef DRM_ERROR_CODE_H
#define DRM_ERROR_CODE_H
#include "napi/native_api.h"
#include "napi/native_common.h"
#include "napi/native_node_api.h"
namespace OHOS {
namespace DrmStandard {
/**
* @brief drm remote request code for IPC.
*
* @since 1.0
* @version 1.0
*/
enum DrmErrorCode {
DRM_ERROR = -1,
DRM_OK = 0,
DRM_ALLOC_ERROR,
DRM_INVALID_ARG,
DRM_UNSUPPORTED,
DRM_INVALID_SESSION_CFG,
DRM_INVALID_STATE,
DRM_UNKNOWN_ERROR,
DRM_OPERATION_NOT_ALLOWED,
DRM_HOST_ERROR,
DRM_SERVICE_ERROR,
DRM_MEMORY_ERROR,
class NapiDrmError {
public:
static napi_status ThrowError(napi_env env, const char *napiMessage, int32_t napiCode);
static void ThrowError(napi_env env, int32_t code);
static std::string GetMessageByCode(int32_t &code);
};
const int32_t DRM_ERROR = -1;
const int32_t DRM_OK = 0;
const int32_t DRM_ALLOC_ERROR = 1;
const int32_t DRM_INVALID_ARG = 2;
const int32_t DRM_INVALID_STATE = 3;
const int32_t DRM_OPERATION_NOT_ALLOWED = 5;
const int32_t DRM_HOST_ERROR = 6;
const int32_t DRM_SERVICE_ERROR = 7;
const int32_t DRM_MEMORY_ERROR = 8;
const int32_t DRM_UNKNOWN_ERROR = 24700101;
const int32_t DRM_MAX_SYSTEM_NUM_REACHED = 24700103;
const int32_t DRM_MAX_SESSION_NUM_REACHED = 24700104;
const int32_t DRM_SERVICE_FATAL_ERROR = 24700201;
const int32_t DRM_INVALID_PARAM = 401;
const std::string DRM_INVALID_PARAM_INFO = "input parameter value error";
const std::string DRM_SERVICE_FATAL_ERRO_INFO = "service error";
const std::string DRM_UNKNOWN_ERROR_INFO = "unknow error";
const std::string DRM_MAX_SYSTEM_NUM_REACHED_INFO = "mediaKeySystem number limited";
const std::string DRM_MAX_SESSION_NUM_REACHED_INFO = "mediaKeySession number limited";
} // namespace DrmStandard
} // namespace OHOS
#endif // DRM_ERROR_CODE_H
services/utils/include/drm_napi_utils.h
-139
View File
@@ -1,139 +0,0 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef DRM_NAPI_UTILS_H
#define DRM_NAPI_UTILS_H
#include <vector>
#include "drm_error_code.h"
#include "drm_log.h"
#include "napi/native_api.h"
#include "napi/native_node_api.h"
#define DRM_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar) \
do { \
void *data; \
napi_get_cb_info(env, info, &(argc), argv, &(thisVar), &data); \
} while (0)
#define DRM_NAPI_GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar) \
do { \
void *data; \
status = napi_get_cb_info(env, info, nullptr, nullptr, &(thisVar), &data); \
} while (0)
#define DRM_NAPI_GET_JS_ASYNC_CB_REF(env, arg, count, cbRef) \
do { \
napi_valuetype valueType = napi_undefined; \
napi_typeof(env, arg, &valueType); \
if (valueType == napi_function) { \
napi_create_reference(env, arg, count, &(cbRef)); \
} else { \
NAPI_ASSERT(env, false, "type mismatch"); \
} \
} while (0)
#define DRM_NAPI_ASSERT_NULLPTR_CHECK(env, result) \
do { \
if ((result) == nullptr) { \
napi_get_undefined(env, &(result)); \
return result; \
} \
} while (0)
#define DRM_NAPI_CREATE_PROMISE(env, callbackRef, deferred, result) \
do { \
if ((callbackRef) == nullptr) { \
napi_create_promise(env, &(deferred), &(result)); \
} \
} while (0)
#define DRM_NAPI_CREATE_RESOURCE_NAME(env, resource, resourceName) \
do { \
napi_create_string_utf8(env, resourceName, NAPI_AUTO_LENGTH, &(resource)); \
} while (0)
#define DRM_NAPI_CHECK_NULL_PTR_RETURN_UNDEFINED(env, ptr, ret, message) \
do { \
if ((ptr) == nullptr) { \
HiLog::Error(LABEL, message); \
napi_get_undefined(env, &(ret)); \
return ret; \
} \
} while (0)
#define DRM_NAPI_CHECK_NULL_PTR_RETURN_VOID(ptr, message) \
do { \
if ((ptr) == nullptr) { \
HiLog::Error(LABEL, message); \
return; \
} \
} while (0)
#define DRM_NAPI_ASSERT_EQUAL(condition, errMsg) \
do { \
if (!(condition)) { \
HiLog::Error(LABEL, errMsg); \
return; \
} \
} while (0)
#define DRM_NAPI_CHECK_AND_BREAK_LOG(cond, fmt, ...) \
do { \
if (!(cond)) { \
DRM_ERR_LOG(fmt, ##__VA_ARGS__); \
break; \
} \
} while (0)
#define DRM_NAPI_CHECK_AND_RETURN_LOG(cond, fmt, ...) \
do { \
if (!(cond)) { \
DRM_ERR_LOG(fmt, ##__VA_ARGS__); \
return; \
} \
} while (0)
namespace OHOS {
namespace DrmStandard {
/* Constants for array index */
const int32_t PARAM0 = 0;
const int32_t PARAM1 = 1;
const int32_t PARAM2 = 2;
const int32_t PARAM3 = 3;
/* Constants for array size */
const int32_t ARGS_ZERO = 0;
const int32_t ARGS_ONE = 1;
const int32_t ARGS_TWO = 2;
const int32_t ARGS_THREE = 3;
const int32_t ARGS_FOUR = 4;
struct AsyncContext {
napi_env env;
napi_async_work work;
napi_deferred deferred;
napi_ref callbackRef;
bool status;
int32_t taskId;
int32_t errorCode;
std::string errorMsg;
std::string funcName;
bool isInvalidArgument;
};
} // namespace DrmStandard
} // namespace OHOS
#endif /* DRM_NAPI_UTILS_H_ */
services/utils/include/napi_async_work.h
+136
View File
@@ -0,0 +1,136 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef NAPI_ASYNC_WORK_H
#define NAPI_ASYNC_WORK_H
#include <functional>
#include <memory>
#include <string>
#include <uv.h>
#include "napi/native_api.h"
#include "napi/native_common.h"
#include "napi/native_node_api.h"
#include "drm_error_code.h"
#include "napi_param_utils.h"
namespace OHOS {
namespace DrmStandard {
using NapiCbInfoParser = std::function<void(size_t argc, napi_value *argv)>;
using NapiAsyncExecute = std::function<void(void)>;
using NapiAsyncComplete = std::function<void(napi_value&)>;
struct ContextBase {
virtual ~ContextBase();
void GetCbInfo(napi_env env, napi_callback_info info, NapiCbInfoParser parse = NapiCbInfoParser(),
bool sync = false);
void SignError(int32_t code);
napi_env env = nullptr;
napi_value output = nullptr;
napi_status status = napi_invalid_arg;
std::string errMessage;
int32_t errCode;
napi_value self = nullptr;
void* native = nullptr;
std::string taskName;
private:
napi_deferred deferred = nullptr;
napi_async_work work = nullptr;
napi_ref callbackRef = nullptr;
napi_ref selfRef = nullptr;
NapiAsyncExecute execute = nullptr;
NapiAsyncComplete complete = nullptr;
std::shared_ptr<ContextBase> hold; /* cross thread data */
static constexpr size_t ARGC_MAX = 6;
friend class NapiAsyncWork;
};
struct NapiWorkData {
napi_env env_;
napi_ref cb_;
};
struct AutoRef {
AutoRef(napi_env env, napi_ref cb)
: env_(env), cb_(cb)
{
}
~AutoRef()
{
uv_loop_s *loop = nullptr;
napi_get_uv_event_loop(env_, &loop);
if (loop == nullptr) {
return;
}
NapiWorkData *workData = new (std::nothrow) NapiWorkData();
if (workData == nullptr) {
return;
}
workData->env_ = env_;
workData->cb_ = cb_;
uv_work_t *work = new(std::nothrow) uv_work_t;
if (work == nullptr) {
delete workData;
workData = nullptr;
return;
}
work->data = (void *)workData;
int ret = uv_queue_work_with_qos(loop, work, [] (uv_work_t *work) {}, [] (uv_work_t *work, int status) {
// Js thread
NapiWorkData *workData = reinterpret_cast<NapiWorkData *>(work->data);
napi_env env = workData->env_;
napi_ref cb = workData->cb_;
if (env != nullptr && cb != nullptr) {
(void)napi_delete_reference(env, cb);
}
delete workData;
delete work;
}, uv_qos_default);
if (ret != 0) {
delete work;
work = nullptr;
delete workData;
workData = nullptr;
}
}
napi_env env_;
napi_ref cb_;
};
class NapiAsyncWork {
public:
static napi_value Enqueue(napi_env env, std::shared_ptr<ContextBase> ctxt, const std::string &name,
NapiAsyncExecute execute = NapiAsyncExecute(),
NapiAsyncComplete complete = NapiAsyncComplete());
private:
enum {
/* AsyncCallback / Promise output result index */
RESULT_ERROR = 0,
RESULT_DATA = 1,
RESULT_ALL = 2
};
static void CommonCallbackRoutine(ContextBase *ctxt);
};
} // namespace DrmStandard
} // namespace OHOS
#endif // NAPI_ASYNC_WORK_H
services/utils/include/napi_param_utils.h
+249
View File
@@ -0,0 +1,249 @@
/*
* Copyright (c) 2023 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef NAPI_PARAM_UTILS_H
#define NAPI_PARAM_UTILS_H
#include <cstdint>
#include <map>
#include <list>
#include <string>
#include <mutex>
#include <vector>
#include "napi/native_api.h"
#include "napi/native_common.h"
#include "napi/native_node_api.h"
#include "napi_base_context.h"
#include "drm_log.h"
#include "drm_error_code.h"
#include "i_keysession_service.h"
namespace OHOS {
namespace DrmStandard {
/* Constants for array index */
const int32_t PARAM0 = 0;
const int32_t PARAM1 = 1;
const int32_t PARAM2 = 2;
const int32_t PARAM3 = 3;
/* Constants for array size */
const int32_t ARGS_ZERO = 0;
const int32_t ARGS_ONE = 1;
const int32_t ARGS_TWO = 2;
const int32_t ARGS_THREE = 3;
const int32_t ARGS_FOUR = 4;
const int32_t KEY_SYSTEM_MAX_NUMBER = 64;
const int32_t KEY_SESSION_MAX_NUMBER = 64;
enum NapiMediaKeyRequestType {
MEDIA_KEY_REQUEST_TYPE_UNKNOWN = 0,
MEDIA_KEY_REQUEST_TYPE_INITIAL,
MEDIA_KEY_REQUEST_TYPE_RENEWAL,
MEDIA_KEY_REQUEST_TYPE_RELEASE,
MEDIA_KEY_REQUEST_TYPE_NONE,
MEDIA_KEY_REQUEST_TYPE_UPDATE,
};
struct NapiProvisionRequest {
std::vector<uint8_t> data;
std::string defaultURL;
};
struct DrmEventParame {
int32_t extra;
std::vector<uint8_t> data;
};
struct DrmKeysChangeEventParame {
std::map<std::vector<uint8_t>, MediaKeySessionKeyStatus> statusTable;
bool hasNewGoodLicense;
};
template<typename T>
class ObjectRefMap {
public:
static std::mutex allObjLock;
static std::map<T*, uint32_t> refMap;
static void Insert(T *obj);
static void Erase(T *obj);
static T *IncreaseRef(T *obj);
static void DecreaseRef(T *obj);
ObjectRefMap(T *obj);
~ObjectRefMap();
T *GetPtr();
private:
T *obj_ = nullptr;
};
template <typename T>
std::mutex ObjectRefMap<T>::allObjLock;
template <typename T>
std::map<T *, uint32_t> ObjectRefMap<T>::refMap;
template <typename T>
void ObjectRefMap<T>::Insert(T *obj)
{
std::lock_guard<std::mutex> lock(allObjLock);
refMap[obj] = 1;
}
template <typename T>
void ObjectRefMap<T>::Erase(T *obj)
{
std::lock_guard<std::mutex> lock(allObjLock);
auto it = refMap.find(obj);
if (it != refMap.end()) {
refMap.erase(it);
}
}
template <typename T>
T *ObjectRefMap<T>::IncreaseRef(T *obj)
{
std::lock_guard<std::mutex> lock(allObjLock);
if (refMap.count(obj)) {
refMap[obj]++;
return obj;
} else {
return nullptr;
}
}
template <typename T>
void ObjectRefMap<T>::DecreaseRef(T *obj)
{
std::lock_guard<std::mutex> lock(allObjLock);
if (refMap.count(obj) && --refMap[obj] == 0) {
refMap.erase(obj);
delete obj;
obj = nullptr;
}
}
template <typename T>
ObjectRefMap<T>::ObjectRefMap(T *obj)
{
if (obj != nullptr) {
obj_ = ObjectRefMap::IncreaseRef(obj);
}
}
template <typename T>
ObjectRefMap<T>::~ObjectRefMap()
{
if (obj_ != nullptr) {
ObjectRefMap::DecreaseRef(obj_);
}
}
template <typename T>
T *ObjectRefMap<T>::GetPtr()
{
return obj_;
}
#define DRM_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar) \
do { \
void *data; \
napi_get_cb_info(env, info, &(argc), argv, &(thisVar), &data); \
} while (0)
#define DRM_NAPI_GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar) \
do { \
void *data; \
status = napi_get_cb_info(env, info, nullptr, nullptr, &(thisVar), &data); \
} while (0)
#define DRM_NAPI_CHECK_AND_RETURN_VOID_LOG(cond, fmt, ...) \
do { \
if (!(cond)) { \
DRM_ERR_LOG(fmt, ##__VA_ARGS__); \
return; \
} \
} while (0)
#define DRM_NAPI_CHECK_AND_RETURN_LOG(cond, status, fmt, ...) \
do { \
if (!(cond)) { \
DRM_ERR_LOG(fmt, ##__VA_ARGS__); \
return status; \
} \
} while (0)
/* check condition related to argc/argv, return and logging. */
#define NAPI_CHECK_ARGS_RETURN_VOID(context, condition, message, code) \
do { \
if (!(condition)) { \
(context)->status = napi_invalid_arg; \
(context)->errMessage = std::string(message); \
(context)->errCode = code; \
DRM_ERR_LOG("test (" #condition ") failed: " message); \
return; \
} \
} while (0)
#define NAPI_CHECK_STATUS_RETURN_VOID(context, message, code) \
do { \
if ((context)->status != napi_ok) { \
(context)->errMessage = std::string(message); \
(context)->errCode = code; \
DRM_ERR_LOG("test (context->status == napi_ok) failed: " message); \
return; \
} \
} while (0)
class NapiParamUtils {
public:
static napi_status GetValueInt32(const napi_env &env, int32_t &value, napi_value in);
static napi_status SetValueInt32(const napi_env &env, const int32_t &value, napi_value &result);
static napi_status GetValueInt32(const napi_env &env, const std::string &fieldStr, int32_t &value, napi_value in);
static napi_status SetValueInt32(const napi_env &env, const std::string &fieldStr,
const int32_t value, napi_value &result);
static std::string GetStringArgument(napi_env env, napi_value value);
static napi_status SetValueString(const napi_env &env, const std::string &stringValue, napi_value &result);
static napi_status SetValueString(const napi_env &env, const std::string &fieldStr, const std::string &stringValue,
napi_value &result);
static napi_value GetUndefinedValue(napi_env env);
static napi_status SetValueUint8Array(const napi_env &env, const std::vector<uint8_t> &value,
napi_value &result);
static napi_status SetValueUint8Array(const napi_env &env, const std::string &fieldStr,
const std::vector<uint8_t> &value, napi_value &result);
static napi_status GetValueUint8Array(const napi_env &env, std::vector<uint8_t> &value,
napi_value in);
static napi_status SetValueBoolean(const napi_env &env, const bool boolValue, napi_value &result);
static napi_status SetValueMap(const napi_env &env,
std::map<std::vector<uint8_t>, MediaKeySessionKeyStatus> statusTable, napi_value &result);
static napi_status GetValueOptionsData(const napi_env &env, std::map<std::string, std::string> &valueMap,
napi_value in);
static napi_status SetProvisionRequest(const napi_env &env, const NapiProvisionRequest &provisionRequest,
napi_value &result);
static napi_status SetMediaKeyRequest(const napi_env &env,
const IMediaKeySessionService::MediaKeyRequest &mediaKeyRequest, napi_value &result);
static napi_status SetDrmEventInfo(const napi_env &env, DrmEventParame &eventParame,
napi_value &result);
static napi_status SetDrmKeysChangeEventInfo(const napi_env &env, DrmKeysChangeEventParame &eventParame,
napi_value &statusTable, napi_value &hasNewGoodLicense);
};
} // namespace DrmStandard
} // namespace OHOS
#endif // NAPI_PARAM_UTILS_H