• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1# DRM System Management (C/C++)
2
3Using the **MediaKeySystem** class of the DRM module, you can manage **MediaKeySystem** instances, generate media key system requests, process responses to these requests, create media key sessions, manage offline media keys, and obtain DRM statistics and device configuration information.
4
5## How to Develop
6
7Read [DRM](../reference/apis-drm-kit/_drm.md) for the API reference.
8
91. Import the NDK.
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_MediaKeySystem_IsSupported** in the **MediaKeySystem** class to check whether the device supports the media key system with a given name, MIME type, and content protection level.
25
26   ```c++
27    const char *uuid = "com.wiseplay.drm";
28    const char *mimeType = "video/mp4";
29    DRM_ContentProtectionLevel level = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
30    ret = OH_MediaKeySystem_IsSupported(uuid);
31    if (ret != true) {
32        OH_LOG_ERROR(LOG_APP, "The device does not support the DRM scheme.");
33    }
34    ret = OH_MediaKeySystem_IsSupported2(uuid, mimeType);
35    if (ret != true) {
36        OH_LOG_ERROR(LOG_APP, "The device does not support the DRM scheme.");
37    }
38    ret = OH_MediaKeySystem_IsSupported3(uuid, mimeType, level);
39    if (ret != true) {
40        OH_LOG_ERROR(LOG_APP, "The device does not support the DRM scheme.");
41    }
42   ```
43
444. Call **OH_MediaKeySystem_Create** in the **MediaKeySystem** class to create a **MediaKeySystem** instance.
45
46   ```c++
47    MediaKeySystem *keySystem = NULL;
48    const char *name = "com.wiseplay.drm";
49    ret = OH_MediaKeySystem_Create(name, &keySystem);
50    if (ret != DRM_OK) {
51        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Create failed.");
52    }
53    ret = OH_MediaKeySystem_Destroy(keySystem);
54    if (ret != DRM_OK) {
55     OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Destroy failed.");
56     return ret;
57    }
58   ```
59
605. Call **OH_MediaKeySystem_SetConfigurationString** and **OH_MediaKeySystem_GetConfigurationString** in the **MediaKeySystem** class to set and obtain the device configuration information, respectively. The configuration information varies according to the DRM scheme and generally contains the following types: device attributes, session attributes, and output protection status attributes.
61
62   The attribute names include "vendor", "version", "description", "algorithms", "maxSessionNum", "maxHDCPLevel", "currentHDCPLevel", "maxADCPLevel", and "currentADCPLevel".
63
64   ```c++
65    // Create a MediaKeySystem instance.
66    MediaKeySystem *keySystem = NULL;
67    const char *name = "com.wiseplay.drm";
68    ret = OH_MediaKeySystem_Create(name, &keySystem);
69    if (ret != DRM_OK) {
70        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Create failed.");
71    }
72    // Set a configuration item in the form of a string.
73    ret = OH_MediaKeySystem_SetConfigurationString(keySystem, "version", "2.0");
74    if (ret == DRM_OK) {
75        OH_LOG_INFO(LOG_APP, "MediaKeySystem_SetConfigurationString success ");
76    } else {
77        OH_LOG_ERROR(LOG_APP, "MediaKeySystem_SetConfigurationString failed. %d ", ret);
78    }
79    char value[32];
80    int32_t valueLen = 32;
81     // Obtain the value of a configuration item in the form of a string.
82    ret = OH_MediaKeySystem_GetConfigurationString(keySystem, "version", value, valueLen);
83    if (ret == DRM_OK) {
84        OH_LOG_INFO(LOG_APP, "OH_MediaKeySystem_GetConfigurationString success ");
85    } else {
86        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_GetConfigurationString failed. %d ", ret);
87    }
88    // Set a configuration item in the form of a byte array.
89    char description[5] = {1, 2, 3, 4, 5};
90    ret = OH_MediaKeySystem_SetConfigurationByteArray(keySystem, "description", description, 5);
91    if (ret == DRM_OK) {
92        OH_LOG_INFO(LOG_APP, "OH_MediaKeySystem_SetConfigurationByteArray success ");
93    } else {
94        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_SetConfigurationByteArray failed. %d ", ret);
95    }
96     // Obtain the value of a configuration item in the form of a byte array.
97    unsigned char descriptionValue[32];
98    uint32_t descriptionValueLen = 32;
99    ret = OH_MediaKeySystem_GetConfigurationByteArray(keySystem, "description", descriptionValue, &descriptionValueLen);
100    if (ret == DRM_OK) {
101        OH_LOG_INFO(LOG_APP, "OH_MediaKeySystem_GetConfigurationByteArray success ");
102    } else {
103        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_GetConfigurationByteArray failed. %d ", ret);
104    }
105    ret = OH_MediaKeySystem_Destroy(keySystem);
106    if (ret != DRM_OK) {
107     OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Destroy failed.");
108     return ret;
109    }
110   ```
111
1126. Call **OH_MediaKeySystem_GetMaxContentProtectionLevel** in the **MediaKeySystem** class to obtain the maximum content protection level.
113
114   ```c++
115    MediaKeySystem *keySystem = NULL;
116    const char *name = "com.wiseplay.drm";
117    ret = OH_MediaKeySystem_Create(name, &keySystem);
118    if (ret != DRM_OK) {
119        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Create failed.");
120    }
121    DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN;
122    ret = OH_MediaKeySystem_GetMaxContentProtectionLevel(keySystem, &contentProtectionLevel);
123    if (ret != DRM_OK) {
124        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_GetMaxContentProtectionLevel failed.");
125    }
126    ret = OH_MediaKeySystem_Destroy(keySystem);
127    if (ret != DRM_OK) {
128     OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Destroy failed.");
129     return ret;
130    }
131   ```
132
1337. Call **OH_MediaKeySystem_SetMediaKeySystemCallback** in the **MediaKeySystem** class to set a callback to listen for the media key system status.
134
135   ```c++
136    DRM_ErrCode TestSystemCallBack(DRM_EventType eventType, uint8_t *info,
137        int32_t infoLen, char *extra)
138    {
139        OH_LOG_INFO(LOG_APP, "TestSystemCallBack");
140    }
141    DRM_ErrCode MediaKeySystem_SetMediaKeySystemCallback()
142    {
143    MediaKeySystem *keySystem = NULL;
144    const char *name = "com.wiseplay.drm";
145    ret = OH_MediaKeySystem_Create(name, &keySystem);
146    if (ret != DRM_OK) {
147        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Create failed.");
148    }
149    ret = OH_MediaKeySystem_SetMediaKeySystemCallback(keySystem,
150        TestSystemCallBack);
151    if (ret != DRM_OK) {
152        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_SetMediaKeySystemCallback failed.");
153    }
154    ret = OH_MediaKeySystem_Destroy(keySystem);
155    if (ret != DRM_OK) {
156     OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Destroy failed.");
157     return ret;
158    }
159    return ret;
160   }
161   ```
162
1638. Call **OH_MediaKeySystem_CreateMediaKeySession** in the **MediaKeySystem** class to create a **MediaKeySession** instance.
164
165   ```c++
166    MediaKeySystem *keySystem = NULL;
167    const char *name = "com.wiseplay.drm";
168    ret = OH_MediaKeySystem_Create(name, &keySystem);
169    if (ret != DRM_OK) {
170        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Create failed.");
171    }
172    DRM_ContentProtectionLevel level = CONTENT_PROTECTION_LEVEL_HW_CRYPTO;
173    MediaKeySession *keySession = NULL;
174    ret = OH_MediaKeySystem_CreateMediaKeySession(keySystem, &level, &keySession);
175    if (ret != DRM_OK) {
176        OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_CreateMediaKeySession failed.");
177    }
178    ret = OH_MediaKeySession_Destroy(keySession);
179    if (ret != DRM_OK) {
180      OH_LOG_ERROR(LOG_APP, "OH_MediaKeySession_Destroy failed.");
181      return ret;
182    }
183    ret = OH_MediaKeySystem_Destroy(keySystem);
184    if (ret != DRM_OK) {
185     OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Destroy failed.");
186     return ret;
187    }
188   ```
189
1909. Call **OH_MediaKeySystem_GenerateKeySystemRequest** in the **MediaKeySystem** class to generate a media key system request, and call **OH_MediaKeySystem_ProcessKeySystemResponse** in the **MediaKeySystem** class to process a response to the request.
191
192    ```c++
193    DRM_ErrCode MediaKeySystem_SetAndProcessMediaKeySystem()
194    {
195     unsigned char *request = NULL;
196     int32_t requestLen;
197     char defaultUrl[MAX_DEFAULT_URL_LEN];
198     MediaKeySystem *keySystem = NULL;
199     const char *name = "com.wiseplay.drm";
200     ret = OH_MediaKeySystem_Create(name, &keySystem);
201     if (ret != DRM_OK) {
202       OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Create failed.");
203       return ret;
204     }
205
206     ret = OH_MediaKeySystem_GenerateKeySystemRequest(keySystem, &request,
207      &requestLen, &defaultUrl, MAX_DEFAULT_URL_LEN);
208     if (ret != DRM_OK) {
209       OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_GenerateKeySystemRequest failed.");
210       return ret;
211     }
212     unsigned char keySystemResponse[50] = {0};
213     size_t keySystemResponseLen = sizeof(keySystemResponse);
214     ret = OH_MediaKeySystem_ProcessKeySystemResponse(keySystem, keySystemResponse, keySystemResponseLen);
215     if (ret != DRM_OK) {
216       OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_GenerateKeySystemRequest failed.");
217       return ret;
218     }
219     ret = OH_MediaKeySystem_Destroy(keySystem);
220     if (ret != DRM_OK) {
221       OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Destroy failed.");
222       return ret;
223     }
224     return ret;
225    }
226    ```
227
22810. Call **OH_MediaKeySystem_GetOfflineMediaKeyIds** in the **MediaKeySystem** class to obtain the IDs of offline media keys.
229
230    ```c++
231    MediaKeySystem *keySystem = NULL;
232    const char *name = "com.wiseplay.drm";
233    ret = OH_MediaKeySystem_Create(name, &keySystem);
234    if (ret != DRM_OK) {
235      OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Create failed.");
236      return ret;
237    }
238    DRM_OfflineMediakeyIdArray offlineMediaKeyIds;
239    ret = OH_MediaKeySystem_GetOfflineMediaKeyIds(keySystem, &offlineMediaKeyIds);
240    ret = OH_MediaKeySystem_Destroy(keySystem);
241    if (ret != DRM_OK) {
242      OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Destroy failed.");
243      return ret;
244    }
245    ```
246
24711. Call **OH_MediaKeySystem_GetOfflineMediaKeyStatus** in the **MediaKeySystem** class to obtain the status of the offline media keys.
248
249    ```c++
250    MediaKeySystem *keySystem = NULL;
251    const char *name = "com.wiseplay.drm";
252    ret = OH_MediaKeySystem_Create(name, &keySystem);
253    if (ret != DRM_OK) {
254      OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Create failed.");
255      return ret;
256    }
257    DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN;
258    uint8_t offlineMediaKeyId[16] = "mediaKeyIdTest01";
259    ret = OH_MediaKeySystem_GetOfflineMediaKeyStatus(keySystem, offlineMediaKeyId, sizeof(offlineMediaKeyId)/sizeof(uint8_t), &OfflineMediaKeyStatus);
260    if (ret != DRM_OK) {
261      OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_GetOfflineMediaKeyStatus failed.");
262      return ret;
263    }
264    ret = OH_MediaKeySystem_Destroy(keySystem);
265    if (ret != DRM_OK) {
266      OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Destroy failed.");
267      return ret;
268    }
269    ```
270
27112. Call **OH_MediaKeySystem_ClearOfflineMediaKeys** in the **MediaKeySystem** class to clear the offline media keys.
272
273    ```c++
274    MediaKeySystem *keySystem = NULL;
275    const char *name = "com.wiseplay.drm";
276    ret = OH_MediaKeySystem_Create(name, &keySystem);
277    if (ret != DRM_OK) {
278      OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Create failed.");
279      return ret;
280    }
281    uint8_t meidaKeyId[8] = {1, 2, 3, 4, 5, 6, 7, 8};
282    ret = OH_MediaKeySystem_ClearOfflineMediaKeys(keySystem,
283        meidaKeyId, sizeof(meidaKeyId)/sizeof(uint8_t));
284    if (ret != DRM_OK) {
285      OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_ClearOfflineMediaKeys failed.");
286      return ret;
287    }
288    ret = OH_MediaKeySystem_Destroy(keySystem);
289    if (ret != DRM_OK) {
290      OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Destroy failed.");
291      return ret;
292    }
293    ```
294
29513. Call **OH_MediaKeySystem_GetCertificateStatus** in the **MediaKeySystem** class to obtain the device certificate status.
296
297    ```c++
298    MediaKeySystem *keySystem = NULL;
299    const char *name = "com.wiseplay.drm";
300    ret = OH_MediaKeySystem_Create(name, &keySystem);
301    if (ret != DRM_OK) {
302      OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Create failed.");
303      return ret;
304    }
305    DRM_CertificateStatus certStatus = CERT_STATUS_INVALID;
306    ret = OH_MediaKeySystem_GetCertificateStatus(mediaKeySystem,
307        &certStatus);
308    if (ret != DRM_OK) {
309      OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_GetCertificateStatus failed.");
310      return ret;
311    }
312    ret = OH_MediaKeySystem_Destroy(keySystem);
313    if (ret != DRM_OK) {
314      OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Destroy failed.");
315      return ret;
316    }
317    ```
318
31914. Call **OH_MediaKeySystem_Destroy** in the **MediaKeySystem** class to destroy this **MediaKeySystem** instance.
320
321    ```c++
322    MediaKeySystem *keySystem = NULL;
323    const char *name = "com.wiseplay.drm";
324    ret = OH_MediaKeySystem_Create(name, &keySystem);
325    if (ret != DRM_OK) {
326      OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Create failed.");
327      return ret;
328    }
329    ret = OH_MediaKeySystem_Destroy(keySystem);
330    if (ret != DRM_OK) {
331      OH_LOG_ERROR(LOG_APP, "OH_MediaKeySystem_Destroy failed.");
332      return ret;
333    }
334    ```
335