From f88fd173f4a79cc9752bf63f844735d8051a611b Mon Sep 17 00:00:00 2001 From: jiangchunli Date: Fri, 10 May 2024 11:43:08 +0800 Subject: [PATCH] Feature: drm event callback with object params. Signed-off-by: jiangchunli --- .../c/drm_capi/native_mediakeysession.cpp | 12 ++ .../c/drm_capi/native_mediakeysystem.cpp | 15 ++- .../mediakeysessionndk_fuzzer.cpp | 52 +++++++- .../mediakeysystemndk_fuzzer.cpp | 22 ++++ .../unittest/src/drm_framework_unittest.cpp | 115 ++++++++++++++++++ .../c/drm_capi/common/native_drm_object.h | 66 ++++++++-- .../drm_capi/include/native_mediakeysession.h | 53 ++++++++ .../drm_capi/include/native_mediakeysystem.h | 24 ++++ 8 files changed, 344 insertions(+), 15 deletions(-) diff --git a/frameworks/c/drm_capi/native_mediakeysession.cpp b/frameworks/c/drm_capi/native_mediakeysession.cpp index 92a8689..91d68af 100644 --- a/frameworks/c/drm_capi/native_mediakeysession.cpp +++ b/frameworks/c/drm_capi/native_mediakeysession.cpp @@ -291,6 +291,18 @@ Drm_ErrCode OH_MediaKeySession_SetMediaKeySessionCallback(MediaKeySession *media return DRM_ERR_OK; } +Drm_ErrCode OH_MediaKeySession_SetCallback(MediaKeySession *mediaKeySessoin, + OH_MediaKeySession_Callback *callback) +{ + DRM_INFO_LOG("OH_MediaKeySession_SetCallback enter."); + DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySessoin != nullptr) && (callback != nullptr)), DRM_ERR_INVALID_VAL, + "mediaKeySessoin is nullptr!"); + MediaKeySessionObject *sessionObject = reinterpret_cast(mediaKeySessoin); + sessionObject->sessionCallback_->SetCallbackReference(mediaKeySessoin, *callback); + DRM_INFO_LOG("OH_MediaKeySession_SetCallback exit."); + return DRM_ERR_OK; +} + Drm_ErrCode OH_MediaKeySession_Destroy(MediaKeySession *keySession) { DRM_INFO_LOG("OH_MediaKeySession_Destroy enter."); diff --git a/frameworks/c/drm_capi/native_mediakeysystem.cpp b/frameworks/c/drm_capi/native_mediakeysystem.cpp index 04af129..9d3bc43 100644 --- a/frameworks/c/drm_capi/native_mediakeysystem.cpp +++ b/frameworks/c/drm_capi/native_mediakeysystem.cpp @@ -437,12 +437,25 @@ Drm_ErrCode OH_MediaKeySystem_SetMediaKeySystemCallback(MediaKeySystem *mediaKey "parameter is error!"); MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, - "OH_SetConfigurationString mediaKeySystemImpl::SetCallbackReference faild!"); + "SetCallbackReference faild!"); systemObject->systemCallback_->SetCallbackReference(callback); DRM_INFO_LOG("OH_MediaKeySystem_SetMediaKeySystemCallback exit."); return DRM_ERR_OK; } +Drm_ErrCode OH_MediaKeySystem_SetCallback(MediaKeySystem *mediaKeySystem, OH_MediaKeySystem_Callback callback) +{ + DRM_INFO_LOG("OH_MediaKeySystem_SetCallback enter."); + DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySystem != nullptr) && (callback != nullptr)), DRM_ERR_INVALID_VAL, + "parameter is error!"); + MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); + DRM_CHECK_AND_RETURN_RET_LOG(systemObject->systemImpl_ != nullptr, DRM_ERR_INVALID_VAL, + "SetCallbackReference faild!"); + systemObject->systemCallback_->SetCallbackReference(mediaKeySystem, callback); + DRM_INFO_LOG("OH_MediaKeySystem_SetCallback exit."); + return DRM_ERR_OK; +} + Drm_ErrCode OH_MediaKeySystem_CreateMediaKeySession(MediaKeySystem *mediaKeySystem, DRM_ContentProtectionLevel *level, MediaKeySession **mediaKeySession) { diff --git a/frameworks/native/test/fuzztest/mediakeysessionndk_fuzzer/mediakeysessionndk_fuzzer.cpp b/frameworks/native/test/fuzztest/mediakeysessionndk_fuzzer/mediakeysessionndk_fuzzer.cpp index deb5670..cbfe034 100644 --- a/frameworks/native/test/fuzztest/mediakeysessionndk_fuzzer/mediakeysessionndk_fuzzer.cpp +++ b/frameworks/native/test/fuzztest/mediakeysessionndk_fuzzer/mediakeysessionndk_fuzzer.cpp @@ -52,13 +52,15 @@ using namespace DrmStandard; const int32_t MEMMAXSIZE = 128; const int32_t OFFRESPONSELEN = 50; const int32_t DATAMAXSIZE = 12288; + +namespace { +const int32_t STEP_ONE = 1; +const int32_t STEP_TWO = 2; +const int32_t STEP_THREE = 3; +const int32_t STEP_FOUR = 4; +} namespace OHOS { namespace DrmStandard { -Drm_ErrCode TestsessionEventCallBack(DRM_EventType eventType, unsigned char *info, int32_t infoLen, char *extra) -{ - DRM_INFO_LOG("TestsessionEventCallBack ok"); - return DRM_ERR_OK; -} Drm_ErrCode TestSessoinEventCallBack(DRM_EventType eventType, unsigned char *info, int32_t infoLen, char *extra) { @@ -72,6 +74,41 @@ Drm_ErrCode TestSessoinKeyChangeCallBack(DRM_KeysInfo *keysInfo, bool hasNewGood return DRM_ERR_OK; } +Drm_ErrCode TestSessoinEventCallBackWithObj(MediaKeySession *mediaKeySessoin, DRM_EventType eventType, + uint8_t *info, int32_t infoLen, char *extra) +{ + DRM_INFO_LOG("TestSessoinEventCallBackWithObj ok"); + DRM_INFO_LOG("Event: the mediaKeySession object is: %x", FAKE_POINTER(mediaKeySessoin)); + DRM_INFO_LOG("Event: the event type: %d", eventType); + DRM_INFO_LOG("Event: the info body is: "); + if (info != nullptr) { + for (int32_t i = 0; i < infoLen; i++) { + DRM_INFO_LOG("%x", info[i]); + } + } + if (extra != nullptr) { + DRM_INFO_LOG("Event: the extra is: %s", extra); + } + return DRM_ERR_OK; +} + +Drm_ErrCode TestSessoinKeyChangeCallBackWithObj(MediaKeySession *mediaKeySessoin, DRM_KeysInfo *keysInfo, + bool hasNewGoodKeys) +{ + DRM_INFO_LOG("TestSessoinKeyChangeCallBackWithObj ok"); + DRM_INFO_LOG("KeyChangedEvent: the mediaKeySession object is: %x", FAKE_POINTER(mediaKeySessoin)); + for (uint32_t i = 0; i < keysInfo->keysInfoCount; i++) { + for (uint32_t j = 0; j < MAX_KEY_ID_LEN; j += STEP_FOUR) { + DRM_INFO_LOG("KeyChangedEvent: keyid is: "); + DRM_INFO_LOG("%x %x %x %x", + keysInfo->keyId[i][j], keysInfo->keyId[i][j + STEP_ONE], + keysInfo->keyId[i][j + STEP_TWO], keysInfo->keyId[i][j + STEP_THREE]); + } + DRM_INFO_LOG("KeyChangedEvent: statusValue %s", keysInfo->statusValue[i]); + } + return DRM_ERR_OK; +} + MediaKeysessionNdkFuzzer::MediaKeysessionNdkFuzzer() {} MediaKeysessionNdkFuzzer::~MediaKeysessionNdkFuzzer() {} @@ -278,6 +315,11 @@ bool MediaKeysessionNdkFuzzer::FuzzTestMediaKeySessionsSetUpLicenseNdk(uint8_t * OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &ContentProtectionLevel, &mediaKeySession); MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack }; OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, &sessionCallback); + + OH_MediaKeySession_Callback sessionCallbackObj = { &TestSessoinEventCallBackWithObj, + &TestSessoinKeyChangeCallBackWithObj }; + OH_MediaKeySession_SetCallback(mediaKeySession, &sessionCallbackObj); + GenerateLicense(); char *mimeType = reinterpret_cast(rawData); DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; diff --git a/frameworks/native/test/fuzztest/mediakeysystemndk_fuzzer/mediakeysystemndk_fuzzer.cpp b/frameworks/native/test/fuzztest/mediakeysystemndk_fuzzer/mediakeysystemndk_fuzzer.cpp index 310f6b2..316cc73 100644 --- a/frameworks/native/test/fuzztest/mediakeysystemndk_fuzzer/mediakeysystemndk_fuzzer.cpp +++ b/frameworks/native/test/fuzztest/mediakeysystemndk_fuzzer/mediakeysystemndk_fuzzer.cpp @@ -59,6 +59,24 @@ Drm_ErrCode TestSystemEventCallBack(DRM_EventType eventType, unsigned char *info return DRM_ERR_OK; } +Drm_ErrCode TestSystemEventCallBackWithObj(MediaKeySystem *mediaKeySystem, DRM_EventType eventType, + uint8_t *info, int32_t infoLen, char *extra) +{ + DRM_INFO_LOG("TestSystemEventCallBackWithObj ok"); + DRM_INFO_LOG("Event: the mediaKeySystem object is: %x", FAKE_POINTER(mediaKeySystem)); + DRM_INFO_LOG("Event: event type: %d", eventType); + DRM_INFO_LOG("Event: the info body is: "); + if (info != nullptr) { + for (int32_t i = 0; i < infoLen; i++) { + DRM_INFO_LOG("%x", info[i]); + } + } + if (extra != nullptr) { + DRM_INFO_LOG("Event: the extra is: %s", extra); + } + return DRM_ERR_OK; +} + MediaKeySystemNdkFuzzer::MediaKeySystemNdkFuzzer() {} MediaKeySystemNdkFuzzer::~MediaKeySystemNdkFuzzer() {} @@ -255,6 +273,10 @@ bool MediaKeySystemNdkFuzzer::FuzzTestMediaKeySystemCertificateOperationNdk(uint OH_MediaKeySystem_SetMediaKeySystemCallback(tmpSystem, &TestSystemEventCallBack); OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); + + OH_MediaKeySystem_SetCallback(tmpSystem, &TestSystemEventCallBackWithObj); + OH_MediaKeySystem_SetCallback(mediaKeySystem, &TestSystemEventCallBackWithObj); + MediaKeySession *session = nullptr; OH_MediaKeySystem_CreateMediaKeySession(tmpSystem, contentProtectionLevel, &session); diff --git a/frameworks/native/test/unittest/src/drm_framework_unittest.cpp b/frameworks/native/test/unittest/src/drm_framework_unittest.cpp index 89500b6..0af6d92 100644 --- a/frameworks/native/test/unittest/src/drm_framework_unittest.cpp +++ b/frameworks/native/test/unittest/src/drm_framework_unittest.cpp @@ -123,6 +123,13 @@ using namespace testing::ext; using namespace std; +namespace { +const int32_t STEP_ONE = 1; +const int32_t STEP_TWO = 2; +const int32_t STEP_THREE = 3; +const int32_t STEP_FOUR = 4; +} + namespace OHOS { namespace DrmStandard { @@ -182,6 +189,59 @@ Drm_ErrCode TestSessoinKeyChangeCallBack(DRM_KeysInfo *keysInfo, bool hasNewGood return DRM_ERR_OK; } +Drm_ErrCode TestSystemEventCallBackWithObj(MediaKeySystem *mediaKeySystem, DRM_EventType eventType, + uint8_t *info, int32_t infoLen, char *extra) +{ + DRM_SAMPLE_INFO_LOG("TestSystemEventCallBackWithObj ok"); + DRM_SAMPLE_INFO_LOG("Event: the mediaKeySystem object is: %x", FAKE_POINTER(mediaKeySystem)); + DRM_SAMPLE_INFO_LOG("Event: event type: %d", eventType); + DRM_SAMPLE_INFO_LOG("Event: the info body is: "); + if (info != nullptr) { + for (int32_t i = 0; i < infoLen; i++) { + DRM_SAMPLE_INFO_LOG("%x", info[i]); + } + } + if (extra != nullptr) { + DRM_SAMPLE_INFO_LOG("Event: the extra is: %s", extra); + } + return DRM_ERR_OK; +} + +Drm_ErrCode TestSessoinEventCallBackWithObj(MediaKeySession *mediaKeySessoin, DRM_EventType eventType, + uint8_t *info, int32_t infoLen, char *extra) +{ + DRM_SAMPLE_INFO_LOG("TestSessoinEventCallBackWithObj ok"); + DRM_SAMPLE_INFO_LOG("Event: the mediaKeySession object is: %x", FAKE_POINTER(mediaKeySessoin)); + DRM_SAMPLE_INFO_LOG("Event: the event type: %d", eventType); + DRM_SAMPLE_INFO_LOG("Event: the info body is: "); + if (info != nullptr) { + for (int32_t i = 0; i < infoLen; i++) { + DRM_SAMPLE_INFO_LOG("%x", info[i]); + } + } + if (extra != nullptr) { + DRM_SAMPLE_INFO_LOG("Event: the extra is: %s", extra); + } + return DRM_ERR_OK; +} + +Drm_ErrCode TestSessoinKeyChangeCallBackWithObj(MediaKeySession *mediaKeySessoin, DRM_KeysInfo *keysInfo, + bool hasNewGoodKeys) +{ + DRM_SAMPLE_INFO_LOG("TestSessoinKeyChangeCallBackWithObj ok"); + DRM_SAMPLE_INFO_LOG("KeyChangedEvent: the mediaKeySession object is: %x", FAKE_POINTER(mediaKeySessoin)); + for (uint32_t i = 0; i < keysInfo->keysInfoCount; i++) { + for (uint32_t j = 0; j < MAX_KEY_ID_LEN; j += STEP_FOUR) { + DRM_SAMPLE_INFO_LOG("KeyChangedEvent: keyid is: "); + DRM_SAMPLE_INFO_LOG("%x %x %x %x", + keysInfo->keyId[i][j], keysInfo->keyId[i][j + STEP_ONE], + keysInfo->keyId[i][j + STEP_TWO], keysInfo->keyId[i][j + STEP_THREE]); + } + DRM_SAMPLE_INFO_LOG("KeyChangedEvent: statusValue %s", keysInfo->statusValue[i]); + } + return DRM_ERR_OK; +} + /* * Feature: Framework * Function: Test to determine if the creation of this DRM instance is supported @@ -4544,6 +4604,61 @@ static void killclearplay2(MediaKeySystem *mediaKeySystem, MediaKeySession *medi EXPECT_NE(errNo, DRM_ERR_OK); } +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetCallbackWithObject_084, TestSize.Level0) +{ + Drm_ErrCode errNo = DRM_ERR_UNKNOWN; + MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; + errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + EXPECT_NE(mediaKeySystem, nullptr); + errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_SetCallback(mediaKeySystem, &TestSystemEventCallBackWithObj); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char request[8192] = { 0 }; // 8192:request len + int32_t requestLen = 8192; // 8192:request len + char defaultUrl[2048] = { 0 }; // 2048:url len + int32_t defaultUrlLen = 2048; // 2048:url len + errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, request, &requestLen, defaultUrl, + defaultUrlLen); + unsigned char KeySystemResponse[12288] = OFFRESPONSE; + int32_t KeySystemResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(PROVISION_URL, request, requestLen, KeySystemResponse, &KeySystemResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + KeySystemResponseLen = 50; + } + errNo = OH_MediaKeySystem_ProcessKeySystemResponse(mediaKeySystem, KeySystemResponse, KeySystemResponseLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + MediaKeySession_Callback callback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack }; + errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, &callback); + EXPECT_EQ(errNo, DRM_ERR_OK); + OH_MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBackWithObj, + &TestSessoinKeyChangeCallBackWithObj }; + errNo = OH_MediaKeySession_SetCallback(mediaKeySession, &sessionCallback); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + filldata(&info); + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[64] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[2] = {0x07, 0x22}; + int32_t onlineMediaKeyIdLen = 64; // 64:OFFLINE_MEDIA_KEY_ID_LEN + errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)(sizeof(testKeySessionResponse)), onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + EXPECT_EQ(errNo, DRM_ERR_OK); +} + HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_KillClearPlayHostAbNormal1, TestSize.Level0) { Drm_ErrCode errNo = DRM_ERR_UNKNOWN; diff --git a/interfaces/kits/c/drm_capi/common/native_drm_object.h b/interfaces/kits/c/drm_capi/common/native_drm_object.h index 9a501e2..e2827e0 100644 --- a/interfaces/kits/c/drm_capi/common/native_drm_object.h +++ b/interfaces/kits/c/drm_capi/common/native_drm_object.h @@ -52,7 +52,7 @@ struct MediaKeySessionObject : public MediaKeySession { class MediaKeySystemCallbackCapi : public MediaKeySystemImplCallback { public: - MediaKeySystemCallbackCapi() + MediaKeySystemCallbackCapi() : system_(nullptr), callback_(nullptr), systemCallback_(nullptr) { DRM_INFO_LOG("MediaKeySystemCallbackCapi."); InitEventMap(); @@ -76,18 +76,30 @@ public: callback_ = callback; } + void SetCallbackReference(MediaKeySystem *system, OH_MediaKeySystem_Callback systemCallback) + { + DRM_INFO_LOG("MediaKeySystemCallbackCapi SetCallbackReference."); + std::lock_guard lock(mutex_); + system_ = system; + systemCallback_ = systemCallback; + } + void ClearCallbackReference() { DRM_INFO_LOG("MediaKeySystemCallbackCapi ClearCallbackReference."); std::lock_guard lock(mutex_); + system_ = nullptr; callback_ = nullptr; + systemCallback_ = nullptr; } void SendEvent(const std::string &event, int32_t extra, const std::vector &data) override { DRM_INFO_LOG("MediaKeySystemCallbackCapi SendEvent."); std::lock_guard lock(mutex_); - DRM_CHECK_AND_RETURN_LOG(callback_ != nullptr, "hasn't register the callback of this event"); + DRM_CHECK_AND_RETURN_LOG((callback_ != nullptr) || (systemCallback_ != nullptr), + "hasn't register any callback of %{public}s event", event.c_str()); + if (eventMap_.find(event) == eventMap_.end()) { DRM_ERR_LOG("MediaKeySystemCallbackCapi SendEvent failed, not find this event type."); return; @@ -101,7 +113,13 @@ public: DRM_CHECK_AND_RETURN_LOG(ret == EOK, "memcpy_s faild!"); } - callback_(eventMap_[event], dataInfo, data.size(), std::to_string(extra).data()); + if (callback_ != nullptr) { + callback_(eventMap_[event], dataInfo, data.size(), std::to_string(extra).data()); + } + if (systemCallback_ != nullptr) { + systemCallback_(system_, eventMap_[event], dataInfo, data.size(), std::to_string(extra).data()); + } + if (dataInfo != nullptr) { free(dataInfo); dataInfo = nullptr; @@ -109,14 +127,16 @@ public: } private: + MediaKeySystem *system_ = nullptr; MediaKeySystem_Callback callback_ = nullptr; + OH_MediaKeySystem_Callback systemCallback_ = nullptr; std::mutex mutex_; std::unordered_map eventMap_; }; class MediaKeySessionCallbackCapi : public MediaKeySessionImplCallback { public: - MediaKeySessionCallbackCapi() + MediaKeySessionCallbackCapi() : session_(nullptr), callback_({}), sessionCallback_({}) { DRM_INFO_LOG("MediaKeySessionCallbackCapi."); InitEventMap(); @@ -146,18 +166,29 @@ public: callback_ = callback; } + void SetCallbackReference(MediaKeySession *session, OH_MediaKeySession_Callback sessionCallback) + { + DRM_INFO_LOG("MediaKeySessionCallbackCapi SetCallbackReference."); + std::lock_guard lock(mutex_); + session_ = session; + sessionCallback_ = sessionCallback; + } + void ClearCallbackReference() { DRM_INFO_LOG("MediaKeySessionCallbackCapi ClearCallbackReference."); std::lock_guard lock(mutex_); + session_ = nullptr; callback_ = {}; + sessionCallback_ = {}; } void SendEvent(const std::string &event, int32_t extra, const std::vector &data) override { DRM_INFO_LOG("MediaKeySessionCallbackCapi SendEvent."); std::lock_guard lock(mutex_); - DRM_CHECK_AND_RETURN_LOG(callback_.eventCallback != nullptr, "hasn't register the callback of this event"); + DRM_CHECK_AND_RETURN_LOG((callback_.eventCallback != nullptr) || (sessionCallback_.eventCallback != nullptr), + "hasn't register any callback of %{public}s event", event.c_str()); if (eventMap_.find(event) == eventMap_.end()) { DRM_ERR_LOG("MediaKeySystemCallbackCapi SendEvent failed, not find this event type."); return; @@ -171,7 +202,14 @@ public: DRM_CHECK_AND_RETURN_LOG(ret == EOK, "memcpy_s faild!"); } - callback_.eventCallback(eventMap_[event], dataInfo, data.size(), std::to_string(extra).data()); + if (callback_.eventCallback != nullptr) { + callback_.eventCallback(eventMap_[event], dataInfo, data.size(), std::to_string(extra).data()); + } + if (sessionCallback_.eventCallback != nullptr) { + sessionCallback_.eventCallback( + session_, eventMap_[event], dataInfo, data.size(), std::to_string(extra).data()); + } + if (dataInfo != nullptr) { free(dataInfo); dataInfo = nullptr; @@ -182,6 +220,10 @@ public: bool hasNewGoodLicense) override { DRM_INFO_LOG("MediaKeySessionCallbackCapi SendEventKeyChanged."); + std::lock_guard lock(mutex_); + DRM_CHECK_AND_RETURN_LOG((callback_.keyChangeCallback != nullptr) || + (sessionCallback_.keyChangeCallback != nullptr), "hasn't register any callback of KeyChanged event!"); + static std::unordered_map KeyStatusStringMap { {MediaKeySessionKeyStatus::MEDIA_KEY_SESSION_KEY_STATUS_USABLE, "USABLE"}, {MediaKeySessionKeyStatus::MEDIA_KEY_SESSION_KEY_STATUS_EXPIRED, "EXPIRED"}, @@ -216,12 +258,18 @@ public: index++; } - std::lock_guard lock(mutex_); - DRM_CHECK_AND_RETURN_LOG(callback_.keyChangeCallback != nullptr, "keyChangeCallback is nullptr"); - callback_.keyChangeCallback(&info, hasNewGoodLicense); + if (callback_.keyChangeCallback != nullptr) { + callback_.keyChangeCallback(&info, hasNewGoodLicense); + } + if (sessionCallback_.keyChangeCallback != nullptr) { + sessionCallback_.keyChangeCallback(session_, &info, hasNewGoodLicense); + } } + private: + struct MediaKeySession *session_ = nullptr; struct MediaKeySession_Callback callback_ = {}; + struct OH_MediaKeySession_Callback sessionCallback_ = {}; std::mutex mutex_; std::unordered_map eventMap_; }; diff --git a/interfaces/kits/c/drm_capi/include/native_mediakeysession.h b/interfaces/kits/c/drm_capi/include/native_mediakeysession.h index 999aa04..8394da5 100644 --- a/interfaces/kits/c/drm_capi/include/native_mediakeysession.h +++ b/interfaces/kits/c/drm_capi/include/native_mediakeysession.h @@ -86,6 +86,48 @@ typedef struct MediaKeySession_Callback { MediaKeySession_KeyChangeCallback keyChangeCallback; } MediaKeySession_Callback; +/** + * @brief Call back will be invoked when event triggers. + * @param mediaKeySessoin MediaKeySession instance. + * @param eventType Event type. + * @param info Event info gotten from media key session. + * @param infoLen Event info len. + * @param extra Extra info gotten from media key session. + * @return Drm_ErrCode. + * @since 12 + * @version 1.0 + */ +typedef Drm_ErrCode (*OH_MediaKeySession_EventCallback)(MediaKeySession *mediaKeySessoin, DRM_EventType eventType, + uint8_t *info, int32_t infoLen, char *extra); + +/** + * @brief Call back will be invoked when key changes. + * @param mediaKeySessoin MediaKeySession instance. + * @param keysInfo Key info gotten from media key system. + * @param newKeysAvailable Whether new keys available. + * @return DRM_ERR_INVALID_VAL when the params checked failure, return DRM_ERR_OK when function called successfully. + * @since 12 + * @version 1.0 + */ +typedef Drm_ErrCode (*OH_MediaKeySession_KeyChangeCallback)(MediaKeySession *mediaKeySessoin, DRM_KeysInfo *keysInfo, + bool newKeysAvailable); + +/** + * @brief MediaKeySession_Callback struct, used to listen event like key expired and key change etc.. + * @since 12 + * @version 1.0 + */ +typedef struct OH_MediaKeySession_Callback { + /** + * Normal event callback like key expired etc.. + */ + OH_MediaKeySession_EventCallback eventCallback; + /** + * Key change callback for keys change event. + */ + OH_MediaKeySession_KeyChangeCallback keyChangeCallback; +} OH_MediaKeySession_Callback; + /** * @brief Generate media key request. * @param mediaKeySession Media key session instance. @@ -208,6 +250,17 @@ Drm_ErrCode OH_MediaKeySession_RequireSecureDecoderModule(MediaKeySession *media Drm_ErrCode OH_MediaKeySession_SetMediaKeySessionCallback(MediaKeySession *mediaKeySessoin, MediaKeySession_Callback *callback); +/** + * @brief Set media key session event callback. + * @param mediaKeySession Media key session instance. + * @param callback Callback to be set to the media key session. + * @return DRM_ERR_INVALID_VAL when the params checked failure, return DRM_ERR_OK when function called successfully. + * @since 12 + * @version 1.0 + */ +Drm_ErrCode OH_MediaKeySession_SetCallback(MediaKeySession *mediaKeySessoin, + OH_MediaKeySession_Callback *callback); + /** * @brief Release the resource before the session gonna be unused. * @param mediaKeySession Media key session instance. diff --git a/interfaces/kits/c/drm_capi/include/native_mediakeysystem.h b/interfaces/kits/c/drm_capi/include/native_mediakeysystem.h index 3f61e2a..1147ab9 100644 --- a/interfaces/kits/c/drm_capi/include/native_mediakeysystem.h +++ b/interfaces/kits/c/drm_capi/include/native_mediakeysystem.h @@ -62,6 +62,30 @@ extern "C" { typedef Drm_ErrCode (*MediaKeySystem_Callback)(DRM_EventType eventType, uint8_t *info, int32_t infoLen, char *extra); +/** + * @brief Call back will be invoked when event triggers. + * @param mediaKeySystem MediaKeySystem instance. + * @param eventType Event type. + * @param info Event info gotten from media key system. + * @param infoLen Event info len. + * @param extra Extra info gotten from media key system. + * @return DRM_ERR_INVALID_VAL when the params checked failure, return DRM_ERR_OK when function called successfully. + * @since 12 + * @version 1.0 + */ +typedef Drm_ErrCode (*OH_MediaKeySystem_Callback)(MediaKeySystem *mediaKeySystem, DRM_EventType eventType, + uint8_t *info, int32_t infoLen, char *extra); + +/** + * @brief Set media key system event callback. + * @param mediaKeySystem Media key system instance. + * @param callback Callback to be set to the media key system. + * @return DRM_ERR_INVALID_VAL when the params checked failure, return DRM_ERR_OK when function called successfully. + * @since 12 + * @version 1.0 + */ +Drm_ErrCode OH_MediaKeySystem_SetCallback(MediaKeySystem *mediaKeySystem, OH_MediaKeySystem_Callback callback); + /** * @brief Query if media key system is supported. * @param name Used to point a Digital Right Management solution. -- Gitee