• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1# DRM Session Management (C/C++)
2
3Using the **MediaKeySession** class of the DRM module, you can manage **MediaKeySession** instances, generate media key requests, and process responses to these requests.
4
5## How to Develop
6
7Read [DRM](../reference/apis-drm-kit/_drm.md) for the API reference.
8
91. Import the NDK, which provides DRM-related attributes and methods.
10
11   ```c++
12    #include "multimedia/drm_framework/interfaces/kits/c/drm_capi/common/native_drm_common.h"
13    #include "multimedia/drm_framework/interfaces/kits/c/drm_capi/common/native_drm_err.h"
14    #include "multimedia/drm_framework/interfaces/kits/c/drm_capi/include/native_mediakeysession.h"
15    #include "multimedia/drm_framework/interfaces/kits/c/drm_capi/include/native_mediakeysystem.h"
16   ```
17
182. Link the DRM NDK dynamic library in the CMake script.
19
20   ```txt
21    target_link_libraries(PUBLIC libnative_drm.so)
22   ```
23
243. Call **OH_MediaKeySession_GenerateMediaKeyRequest** in the **MediaKeySession** class to generate a media key request, and call **OH_MediaKeySession_ProcessMediaKeyResponse** to process a response to the request.
25
26   ```c++
27    MediaKeySystem *keySystem = NULL;
28    const char *name = "com.clearplay.drm";
29    ret = OH_MediaKeySystem_Create(name, &keySystem);
30    if (ret != DRM_OK) {
31        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Create failed.");
32        return ret;
33    }
34    DRM_ContentProtectionLevel level = CONTENT_PROTECTION_LEVEL_HW_CRYPTO;
35    MediaKeySession *keySession = NULL;
36    ret = OH_MediaKeySystem_CreateMediaKeySession(keySystem, &level, &keySession);
37    if (ret != DRM_OK) {
38        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_CreateMediaKeySession failed.");
39        return ret;
40    }
41    DRM_MediaKeyRequest mediaKeyRequest;
42    DRM_MediaKeyRequestInfo info;
43    uint8_t testData[MAX_INIT_DATA_LEN] = {0};
44    memset(&info, 0, sizeof(DRM_MediaKeyRequestInfo));
45    info.initDataLen = MAX_INIT_DATA_LEN;
46    info.type = MEDIA_KEY_TYPE_ONLINE;
47    memcpy(info.mimeType, (char *)"video/mp4", sizeof("video/mp4"));
48    memcpy(info.initData, testData, sizeof(testData));
49    memcpy(info.optionName[0], (char *)"optionalDataName", sizeof("optionalDataName"));
50    memcpy(info.optionData[0], (char *)"optionalDataValue", sizeof("optionalDataValue"));
51    info.optionsCount = 1;
52    ret = OH_MediaKeySession_GenerateMediaKeyRequest(keySession,
53        &info, &mediaKeyRequest);
54    if (ret != DRM_OK) {
55        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySession_GenerateMediaKeyRequest failed.");
56        return ret;
57    }
58    uint8_t mediaKeyId[MAX_OFFLINE_MEDIA_KEY_ID_LEN];
59    int32_t mediaKeyIdLen = MAX_OFFLINE_MEDIA_KEY_ID_LEN;
60    uint8_t response[5] = {1, 2, 3, 4, 5};
61    ret = OH_MediaKeySession_ProcessMediaKeyResponse(keySession,
62        response, sizeof(response)/sizeof(uint8_t), mediaKeyId, &mediaKeyIdLen);
63    if (ret != DRM_OK) {
64        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySession_ProcessMediaKeyResponse failed.");
65        return ret;
66    }
67    ret = OH_MediaKeySession_Destroy(keySession);
68    if (ret != DRM_OK) {
69        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySession_Destroy failed.");
70        return ret;
71    }
72    ret = OH_MediaKeySystem_Destroy(keySystem);
73    if (ret != DRM_OK) {
74        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Destroy failed.");
75        return ret;
76    }
77   ```
78
794. Call **OH_MediaKeySession_CheckMediaKeyStatus** in the **MediaKeySession** class to check the media key status.
80
81   ```c++
82    MediaKeySystem *keySystem = NULL;
83    const char *name = "com.clearplay.drm";
84    ret = OH_MediaKeySystem_Create(name, &keySystem);
85    if (ret != DRM_OK) {
86        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Create failed.");
87        return ret;
88    }
89    DRM_ContentProtectionLevel level = CONTENT_PROTECTION_LEVEL_HW_CRYPTO;
90    MediaKeySession *keySession = NULL;
91    ret = OH_MediaKeySystem_CreateMediaKeySession(keySystem, &level, &keySession);
92    if (ret != DRM_OK) {
93        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_CreateMediaKeySession failed.");
94        return ret;
95    }
96    DRM_MediaKeyStatus mediaKeyStatus;
97    ret = OH_MediaKeySession_CheckMediaKeyStatus(keySession, &mediaKeyStatus);
98    if (ret != DRM_OK) {
99        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySession_CheckMediaKeyStatus failed.");
100        return ret;
101    }
102    ret = OH_MediaKeySession_Destroy(keySession);
103    if (ret != DRM_OK) {
104        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySession_Destroy failed.");
105        return ret;
106    }
107    ret = OH_MediaKeySystem_Destroy(keySystem);
108    if (ret != DRM_OK) {
109        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Destroy failed.");
110        return ret;
111    }
112   ```
113
1145. Call **OH_MediaKeySession_ClearMediaKeys** in the **MediaKeySession** class to clear all media keys of the current session.
115
116   ```c++
117    MediaKeySystem *keySystem = NULL;
118    const char *name = "com.clearplay.drm";
119    ret = OH_MediaKeySystem_Create(name, &keySystem);
120    if (ret != DRM_OK) {
121        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Create failed.");
122        return ret;
123    }
124    DRM_ContentProtectionLevel level = CONTENT_PROTECTION_LEVEL_HW_CRYPTO;
125    MediaKeySession *keySession = NULL;
126    ret = OH_MediaKeySystem_CreateMediaKeySession(keySystem, &level, &keySession);
127    if (ret != DRM_OK) {
128        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_CreateMediaKeySession failed.");
129        return ret;
130    }
131    ret = OH_MediaKeySession_ClearMediaKeys(keySession);
132    if (ret != DRM_OK) {
133        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySession_ClearMediaKeys failed.");
134        return ret;
135    }
136    ret = OH_MediaKeySession_Destroy(keySession);
137    if (ret != DRM_OK) {
138        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySession_Destroy failed.");
139        return ret;
140    }
141    ret = OH_MediaKeySystem_Destroy(keySystem);
142    if (ret != DRM_OK) {
143        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Destroy failed.");
144        return ret;
145    }
146   ```
147
1486. Call **OH_MediaKeySession_GenerateOfflineReleaseRequest** in the **MediaKeySession** class to generate a request to release offline media keys, and call **OH_MediaKeySession_ProcessOfflineReleaseResponse** to process a response to the request.
149
150   ```c++
151    MediaKeySystem *keySystem = NULL;
152    const char *name = "com.clearplay.drm";
153    ret = OH_MediaKeySystem_Create(name, &keySystem);
154    if (ret != DRM_OK) {
155        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Create failed.");
156        return ret;
157    }
158    DRM_ContentProtectionLevel level = CONTENT_PROTECTION_LEVEL_HW_CRYPTO;
159    MediaKeySession *keySession = NULL;
160    ret = OH_MediaKeySystem_CreateMediaKeySession(keySystem, &level, &keySession);
161    if (ret != DRM_OK) {
162        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_CreateMediaKeySession failed.");
163        return ret;
164    }
165    uint8_t releaseRequest[MAX_MEDIA_KEY_REQUEST_DATA_LEN];
166    int32_t releaseRequestLen = MAX_MEDIA_KEY_REQUEST_DATA_LEN;
167    uint8_t mediaKeyId[8] = {1, 2, 3, 4, 5, 6, 7, 8};
168    int32_t mediaKeyIdLen = sizeof(mediaKeyId)/sizeof(uint8_t);
169    ret = OH_MediaKeySession_GenerateOfflineReleaseRequest(keySession,
170        mediaKeyId, mediaKeyIdLen, releaseRequest, &releaseRequestLen);
171    if (ret != DRM_OK) {
172        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySession_GenerateOfflineReleaseRequest failed.");
173        return ret;
174    }
175    uint8_t keyReleaseResponse[128] = {0};
176    int32_t keyReleaseResponseLen = sizeof(keyReleaseResponse)/sizeof(uint8_t);
177    uint8_t offlineMediaKeyId[5] = {0};
178    int32_t offlineMediaKeyIdLen = sizeof(offlineMediaKeyId)/sizeof(uint8_t);
179    ret = OH_MediaKeySession_ProcessOfflineReleaseResponse(keySession, offlineMediaKeyId, offlineMediaKeyIdLen
180        keyReleaseResponse, keyReleaseResponseLen);
181    if (ret != DRM_OK) {
182        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySession_ProcessOfflineReleaseResponse failed.");
183        return ret;
184    }
185    ret = OH_MediaKeySession_Destroy(keySession);
186    if (ret != DRM_OK) {
187        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySession_Destroy failed.");
188        return ret;
189    }
190    ret = OH_MediaKeySystem_Destroy(keySystem);
191    if (ret != DRM_OK) {
192        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Destroy failed.");
193        return ret;
194    }
195   ```
196
1977. Call **OH_MediaKeySession_RestoreOfflineMediaKeys** in the **MediaKeySession** class to restore the offline media keys.
198
199   ```c++
200    MediaKeySystem *keySystem = NULL;
201    const char *name = "com.clearplay.drm";
202    ret = OH_MediaKeySystem_Create(name, &keySystem);
203    if (ret != DRM_OK) {
204        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Create failed.");
205        return ret;
206    }
207    DRM_ContentProtectionLevel level = CONTENT_PROTECTION_LEVEL_HW_CRYPTO;
208    MediaKeySession *keySession = NULL;
209    ret = OH_MediaKeySystem_CreateMediaKeySession(keySystem, &level, &keySession);
210    if (ret != DRM_OK) {
211        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_CreateMediaKeySession failed.");
212        return ret;
213    }
214    uint8_t mediaKeyId[8] = {1, 2, 3, 4, 5, 6, 7, 8};
215    int32_t keyIdLen = sizeof(testRestoreId)/sizeof(uint8_t);
216    ret = OH_MediaKeySession_RestoreOfflineMediaKeys(keySession, mediaKeyId, keyIdLen);
217    if (ret != DRM_OK) {
218        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySession_RestoreOfflineMediaKeys failed.");
219        return ret;
220    }
221    ret = OH_MediaKeySession_Destroy(keySession);
222    if (ret != DRM_OK) {
223        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySession_Destroy failed.");
224        return ret;
225    }
226    ret = OH_MediaKeySystem_Destroy(keySystem);
227    if (ret != DRM_OK) {
228        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Destroy failed.");
229        return ret;
230    }
231   ```
232
2338. Call **OH_MediaKeySession_GetContentProtectionLevel** in the **MediaKeySession** class to obtain the content protection level of the current session.
234
235   ```c++
236    MediaKeySystem *keySystem = NULL;
237    const char *name = "com.clearplay.drm";
238    ret = OH_MediaKeySystem_Create(name, &keySystem);
239    if (ret != DRM_OK) {
240        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Create failed.");
241        return ret;
242    }
243    DRM_ContentProtectionLevel level = CONTENT_PROTECTION_LEVEL_HW_CRYPTO;
244    MediaKeySession *keySession = NULL;
245    ret = OH_MediaKeySystem_CreateMediaKeySession(keySystem, &level, &keySession);
246    if (ret != DRM_OK) {
247        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_CreateMediaKeySession failed.");
248        return ret;
249    }
250    DRM_ContentProtectionLevel sessionContentProtectionLevel;
251    ret = OH_MediaKeySession_GetContentProtectionLevel(keySession,
252        &sessionContentProtectionLevel);
253    if (ret != DRM_OK) {
254        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySession_GetContentProtectionLevel failed.");
255        return ret;
256    }
257    ret = OH_MediaKeySession_Destroy(keySession);
258    if (ret != DRM_OK) {
259        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySession_Destroy failed.");
260        return ret;
261    }
262    ret = OH_MediaKeySystem_Destroy(keySystem);
263    if (ret != DRM_OK) {
264        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Destroy failed.");
265        return ret;
266    }
267   ```
268
2699. Call **OH_MediaKeySession_RequireSecureDecoderModule** in the **MediaKeySession** class to obtain the secure decoder status.
270
271   ```c++
272    MediaKeySystem *keySystem = NULL;
273    const char *name = "com.clearplay.drm";
274    ret = OH_MediaKeySystem_Create(name, &keySystem);
275    if (ret != DRM_OK) {
276        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Create failed.");
277        return ret;
278    }
279    DRM_ContentProtectionLevel level = CONTENT_PROTECTION_LEVEL_HW_CRYPTO;
280    MediaKeySession *keySession = NULL;
281    ret = OH_MediaKeySystem_CreateMediaKeySession(keySystem, &level, &keySession);
282    if (ret != DRM_OK) {
283        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_CreateMediaKeySession failed.");
284        return ret;
285    }
286    bool requireSecureDecoder;
287    ret = OH_MediaKeySession_RequireSecureDecoderModule(keySession,
288        "video/mp4", &requireSecureDecoder);
289    if (ret != DRM_OK) {
290        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySession_RequireSecureDecoderModule failed.");
291        return ret;
292    }
293    ret = OH_MediaKeySession_Destroy(keySession);
294    if (ret != DRM_OK) {
295        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySession_Destroy failed.");
296        return ret;
297    }
298    ret = OH_MediaKeySystem_Destroy(keySystem);
299    if (ret != DRM_OK) {
300        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Destroy failed.");
301        return ret;
302    }
303   ```
304
30510. Call **OH_MediaKeySession_SetMediaKeySessionCallback** in the **MediaKeySession** class to set a callback to listen for the media key session status.
306
307    ```c++
308    DRM_ErrCode TestSessoinEventCallBack(DRM_EventType  eventType, uint8_t *info,
309    int32_t infoLen, char *extra)
310    {
311     return DRM_ERR_OK;
312    }
313    DRM_ErrCode TestSessoinKeyChangeCallBack(DRM_KeysInfo *keysInfo, bool newKeysAvailable)
314    {
315     return DRM_ERR_OK;
316    }
317    DRM_ErrCode MediaKeySession_SetMediaKeySessionCallback()
318    {
319     MediaKeySystem *keySystem = NULL;
320     const char *name = "com.clearplay.drm";
321     ret = OH_MediaKeySystem_Create(name, &keySystem);
322     if (ret != DRM_OK) {
323         OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Create failed.");
324         return ret;
325     }
326     DRM_ContentProtectionLevel level = CONTENT_PROTECTION_LEVEL_HW_CRYPTO;
327     MediaKeySession *keySession = NULL;
328     ret = OH_MediaKeySystem_CreateMediaKeySession(keySystem, &level, &keySession);
329     if (ret != DRM_OK) {
330         OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_CreateMediaKeySession failed.");
331         return ret;
332     }
333     MediaKeySession_Callback sessionCallback = { TestSessoinEventCallBack, TestSessoinKeyChangeCallBack };
334     ret = OH_MediaKeySession_SetMediaKeySessionCallback(keySession,
335        &sessionCallback);
336     if (ret != DRM_OK) {
337         OH_LOG_ERROR(LOG_APP, "OH_MediaKeySession_SetMediaKeySessionCallback failed.");
338         return ret;
339     }
340    }
341    ```
342
34311. Call **OH_MediaKeySession_Destroy** in the **MediaKeySession** class to destroy this **MediaKeySession** instance.
344
345    ```c++
346    MediaKeySystem *keySystem = NULL;
347    const char *name = "com.clearplay.drm";
348    ret = OH_MediaKeySystem_Create(name, &keySystem);
349    if (ret != DRM_OK) {
350        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Create failed.");
351        return ret;
352    }
353    DRM_ContentProtectionLevel level = CONTENT_PROTECTION_LEVEL_HW_CRYPTO;
354    MediaKeySession *keySession = NULL;
355    ret = OH_MediaKeySystem_CreateMediaKeySession(keySystem, &level, &keySession);
356    if (ret != DRM_OK) {
357        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_CreateMediaKeySession failed.");
358        return ret;
359    }
360    ret = OH_MediaKeySession_Destroy(keySession);
361    if (ret != DRM_OK) {
362      OH_LOG_ERROR(LOG_APP, "OH_MediaKeySession_Destroy failed.");
363      return ret;
364    }
365    ret = OH_MediaKeySystem_Destroy(keySystem);
366    if (ret != DRM_OK) {
367      OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Destroy failed.");
368      return ret;
369    }
370    ```
371