Feature: drm event callback with object params.

Signed-off-by: jiangchunli <jiangchunli1@huawei.com>

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<MediaKeySessionObject *>(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.");

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<MediaKeySystemObject *>(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<MediaKeySystemObject *>(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)
 {

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<char *>(rawData);
     DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN;

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);
 

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;

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<std::mutex> lock(mutex_);
+        system_ = system;
+        systemCallback_ = systemCallback;
+    }
+
     void ClearCallbackReference()
     {
         DRM_INFO_LOG("MediaKeySystemCallbackCapi ClearCallbackReference.");
         std::lock_guard<std::mutex> lock(mutex_);
+        system_ = nullptr;
         callback_ = nullptr;
+        systemCallback_ = nullptr;
     }
 
     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_);
-        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<std::string, DRM_EventType> 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<std::mutex> lock(mutex_);
+        session_ = session;
+        sessionCallback_ = sessionCallback;
+    }
+
     void ClearCallbackReference()
     {
         DRM_INFO_LOG("MediaKeySessionCallbackCapi ClearCallbackReference.");
         std::lock_guard<std::mutex> lock(mutex_);
+        session_ = nullptr;
         callback_ = {};
+        sessionCallback_ = {};
     }
 
     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_);
-        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<std::mutex> 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<MediaKeySessionKeyStatus, std::string> 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<std::mutex> 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<std::string, DRM_EventType> eventMap_;
 };

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.

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.