DrmManagerClientImpl.h revision 07d0220bcc9036bcbe36819912559267d9c1c538
1/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef __DRM_MANAGER_CLIENT_IMPL_H__
18#define __DRM_MANAGER_CLIENT_IMPL_H__
19
20#include <binder/IMemory.h>
21#include <utils/threads.h>
22#include <drm/DrmManagerClient.h>
23
24#include "IDrmManagerService.h"
25
26namespace android {
27
28class DrmInfoEvent;
29/**
30 * This is implementation class for DrmManagerClient class.
31 *
32 * Only the JNI layer creates an instance of this class to delegate
33 * functionality to Native later.
34 *
35 */
36class DrmManagerClientImpl : public BnDrmServiceListener {
37private:
38    DrmManagerClientImpl() { }
39
40public:
41    static DrmManagerClientImpl* create(int* pUniqueId);
42
43    static void remove(int uniqueId);
44
45    virtual ~DrmManagerClientImpl() { }
46
47public:
48    /**
49     * Adds the client respective to given unique id.
50     *
51     * @param[in] uniqueId Unique identifier for a session
52     */
53    void addClient(int uniqueId);
54
55    /**
56     * Removes the client respective to given unique id.
57     *
58     * @param[in] uniqueId Unique identifier for a session
59     */
60    void removeClient(int uniqueId);
61
62    /**
63     * Register a callback to be invoked when the caller required to
64     * receive necessary information
65     *
66     * @param[in] uniqueId Unique identifier for a session
67     * @param[in] infoListener Listener
68     * @return status_t
69     *            Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
70     */
71    status_t setOnInfoListener(
72            int uniqueId, const sp<DrmManagerClient::OnInfoListener>& infoListener);
73
74    /**
75     * Get constraint information associated with input content
76     *
77     * @param[in] uniqueId Unique identifier for a session
78     * @param[in] path Path of the protected content
79     * @param[in] action Actions defined such as,
80     *     Action::DEFAULT, Action::PLAY, etc
81     * @return DrmConstraints
82     *     key-value pairs of constraint are embedded in it
83     * @note
84     *     In case of error, return NULL
85     */
86    DrmConstraints* getConstraints(int uniqueId, const String8* path, const int action);
87
88    /**
89     * Get metadata information associated with input content.
90     *
91     * @param[in] uniqueId Unique identifier for a session
92     * @param[in] path Path of the protected content
93     * @return DrmMetadata
94     *         key-value pairs of metadata are embedded in it
95     * @note
96     *    In case of error, return NULL
97     */
98    DrmMetadata* getMetadata(int uniqueId, const String8* path);
99
100    /**
101     * Check whether the given mimetype or path can be handled
102     *
103     * @param[in] uniqueId Unique identifier for a session
104     * @param[in] path Path of the content needs to be handled
105     * @param[in] mimetype Mimetype of the content needs to be handled
106     * @return
107     *     True if DrmManager can handle given path or mime type.
108     */
109    bool canHandle(int uniqueId, const String8& path, const String8& mimeType);
110
111    /**
112     * Executes given drm information based on its type
113     *
114     * @param[in] uniqueId Unique identifier for a session
115     * @param[in] drmInfo Information needs to be processed
116     * @return DrmInfoStatus
117     *     instance as a result of processing given input
118     */
119    DrmInfoStatus* processDrmInfo(int uniqueId, const DrmInfo* drmInfo);
120
121    /**
122     * Retrieves necessary information for registration, unregistration or rights
123     * acquisition information.
124     *
125     * @param[in] uniqueId Unique identifier for a session
126     * @param[in] drmInfoRequest Request information to retrieve drmInfo
127     * @return DrmInfo
128     *     instance as a result of processing given input
129     */
130    DrmInfo* acquireDrmInfo(int uniqueId, const DrmInfoRequest* drmInfoRequest);
131
132    /**
133     * Save DRM rights to specified rights path
134     * and make association with content path
135     *
136     * @param[in] uniqueId Unique identifier for a session
137     * @param[in] drmRights DrmRights to be saved
138     * @param[in] rightsPath File path where rights to be saved
139     * @param[in] contentPath File path where content was saved
140     * @return status_t
141     *     Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
142     */
143    status_t saveRights(int uniqueId, const DrmRights& drmRights,
144            const String8& rightsPath, const String8& contentPath);
145
146    /**
147     * Retrieves the mime type embedded inside the original content
148     *
149     * @param[in] uniqueId Unique identifier for a session
150     * @param[in] path the path of the protected content
151     * @return String8
152     *     Returns mime-type of the original content, such as "video/mpeg"
153     */
154    String8 getOriginalMimeType(int uniqueId, const String8& path);
155
156    /**
157     * Retrieves the type of the protected object (content, rights, etc..)
158     * using specified path or mimetype. At least one parameter should be non null
159     * to retrieve DRM object type
160     *
161     * @param[in] uniqueId Unique identifier for a session
162     * @param[in] path Path of the content or null.
163     * @param[in] mimeType Mime type of the content or null.
164     * @return type of the DRM content,
165     *     such as DrmObjectType::CONTENT, DrmObjectType::RIGHTS_OBJECT
166     */
167    int getDrmObjectType(int uniqueId, const String8& path, const String8& mimeType);
168
169    /**
170     * Check whether the given content has valid rights or not
171     *
172     * @param[in] uniqueId Unique identifier for a session
173     * @param[in] path Path of the protected content
174     * @param[in] action Action to perform (Action::DEFAULT, Action::PLAY, etc)
175     * @return the status of the rights for the protected content,
176     *     such as RightsStatus::RIGHTS_VALID, RightsStatus::RIGHTS_EXPIRED, etc.
177     */
178    int checkRightsStatus(int uniqueId, const String8& path, int action);
179
180    /**
181     * Consumes the rights for a content.
182     * If the reserve parameter is true the rights is reserved until the same
183     * application calls this api again with the reserve parameter set to false.
184     *
185     * @param[in] uniqueId Unique identifier for a session
186     * @param[in] decryptHandle Handle for the decryption session
187     * @param[in] action Action to perform. (Action::DEFAULT, Action::PLAY, etc)
188     * @param[in] reserve True if the rights should be reserved.
189     * @return status_t
190     *     Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
191     */
192    status_t consumeRights(int uniqueId, DecryptHandle* decryptHandle, int action, bool reserve);
193
194    /**
195     * Informs the DRM engine about the playback actions performed on the DRM files.
196     *
197     * @param[in] uniqueId Unique identifier for a session
198     * @param[in] decryptHandle Handle for the decryption session
199     * @param[in] playbackStatus Playback action (Playback::START, Playback::STOP, Playback::PAUSE)
200     * @param[in] position Position in the file (in milliseconds) where the start occurs.
201     *     Only valid together with Playback::START.
202     * @return status_t
203     *     Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
204     */
205    status_t setPlaybackStatus(
206            int uniqueId, DecryptHandle* decryptHandle, int playbackStatus, int64_t position);
207
208    /**
209     * Validates whether an action on the DRM content is allowed or not.
210     *
211     * @param[in] uniqueId Unique identifier for a session
212     * @param[in] path Path of the protected content
213     * @param[in] action Action to validate (Action::PLAY, Action::TRANSFER, etc)
214     * @param[in] description Detailed description of the action
215     * @return true if the action is allowed.
216     */
217    bool validateAction(
218        int uniqueId, const String8& path, int action, const ActionDescription& description);
219
220    /**
221     * Removes the rights associated with the given protected content
222     *
223     * @param[in] uniqueId Unique identifier for a session
224     * @param[in] path Path of the protected content
225     * @return status_t
226     *     Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
227     */
228    status_t removeRights(int uniqueId, const String8& path);
229
230    /**
231     * Removes all the rights information of each plug-in associated with
232     * DRM framework. Will be used in master reset
233     *
234     * @param[in] uniqueId Unique identifier for a session
235     * @return status_t
236     *     Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
237     */
238    status_t removeAllRights(int uniqueId);
239
240    /**
241     * This API is for Forward Lock based DRM scheme.
242     * Each time the application tries to download a new DRM file
243     * which needs to be converted, then the application has to
244     * begin with calling this API.
245     *
246     * @param[in] uniqueId Unique identifier for a session
247     * @param[in] mimeType Description/MIME type of the input data packet
248     * @return Return handle for the convert session
249     */
250    int openConvertSession(int uniqueId, const String8& mimeType);
251
252    /**
253     * Accepts and converts the input data which is part of DRM file.
254     * The resultant converted data and the status is returned in the DrmConvertedInfo
255     * object. This method will be called each time there are new block
256     * of data received by the application.
257     *
258     * @param[in] uniqueId Unique identifier for a session
259     * @param[in] convertId Handle for the convert session
260     * @param[in] inputData Input Data which need to be converted
261     * @return Return object contains the status of the data conversion,
262     *     the output converted data and offset. In this case the
263     *     application will ignore the offset information.
264     */
265    DrmConvertedStatus* convertData(int uniqueId, int convertId, const DrmBuffer* inputData);
266
267    /**
268     * Informs the Drm Agent when there is no more data which need to be converted
269     * or when an error occurs. Upon successful conversion of the complete data,
270     * the agent will inform that where the header and body signature
271     * should be added. This signature appending is needed to integrity
272     * protect the converted file.
273     *
274     * @param[in] uniqueId Unique identifier for a session
275     * @param[in] convertId Handle for the convert session
276     * @return Return object contains the status of the data conversion,
277     *     the header and body signature data. It also informs
278     *     the application on which offset these signature data
279     *     should be appended.
280     */
281    DrmConvertedStatus* closeConvertSession(int uniqueId, int convertId);
282
283    /**
284     * Retrieves all DrmSupportInfo instance that native DRM framework can handle.
285     * This interface is meant to be used by JNI layer
286     *
287     * @param[in] uniqueId Unique identifier for a session
288     * @param[out] length Number of elements in drmSupportInfoArray
289     * @param[out] drmSupportInfoArray Array contains all DrmSupportInfo
290     *             that native DRM framework can handle
291     * @return status_t
292     *     Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
293     */
294    status_t getAllSupportInfo(int uniqueId, int* length, DrmSupportInfo** drmSupportInfoArray);
295
296    /**
297     * Open the decrypt session to decrypt the given protected content
298     *
299     * @param[in] uniqueId Unique identifier for a session
300     * @param[in] fd File descriptor of the protected content to be decrypted
301     * @param[in] offset Start position of the content
302     * @param[in] length The length of the protected content
303     * @return
304     *     Handle for the decryption session
305     */
306    DecryptHandle* openDecryptSession(int uniqueId, int fd, off64_t offset, off64_t length);
307
308    /**
309     * Open the decrypt session to decrypt the given protected content
310     *
311     * @param[in] uniqueId Unique identifier for a session
312     * @param[in] uri Path of the protected content to be decrypted
313     * @return
314     *     Handle for the decryption session
315     */
316    DecryptHandle* openDecryptSession(int uniqueId, const char* uri);
317
318    /**
319     * Close the decrypt session for the given handle
320     *
321     * @param[in] uniqueId Unique identifier for a session
322     * @param[in] decryptHandle Handle for the decryption session
323     * @return status_t
324     *     Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
325     */
326    status_t closeDecryptSession(int uniqueId, DecryptHandle* decryptHandle);
327
328    /**
329     * Initialize decryption for the given unit of the protected content
330     *
331     * @param[in] uniqueId Unique identifier for a session
332     * @param[in] decryptHandle Handle for the decryption session
333     * @param[in] decryptUnitId ID which specifies decryption unit, such as track ID
334     * @param[in] headerInfo Information for initializing decryption of this decrypUnit
335     * @return status_t
336     *     Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
337     */
338    status_t initializeDecryptUnit(int uniqueId, DecryptHandle* decryptHandle,
339            int decryptUnitId, const DrmBuffer* headerInfo);
340
341    /**
342     * Decrypt the protected content buffers for the given unit
343     * This method will be called any number of times, based on number of
344     * encrypted streams received from application.
345     *
346     * @param[in] uniqueId Unique identifier for a session
347     * @param[in] decryptHandle Handle for the decryption session
348     * @param[in] decryptUnitId ID which specifies decryption unit, such as track ID
349     * @param[in] encBuffer Encrypted data block
350     * @param[out] decBuffer Decrypted data block
351     * @param[in] IV Optional buffer
352     * @return status_t
353     *     Returns the error code for this API
354     *     DRM_NO_ERROR for success, and one of DRM_ERROR_UNKNOWN, DRM_ERROR_LICENSE_EXPIRED
355     *     DRM_ERROR_SESSION_NOT_OPENED, DRM_ERROR_DECRYPT_UNIT_NOT_INITIALIZED,
356     *     DRM_ERROR_DECRYPT for failure.
357     */
358    status_t decrypt(int uniqueId, DecryptHandle* decryptHandle, int decryptUnitId,
359            const DrmBuffer* encBuffer, DrmBuffer** decBuffer, DrmBuffer* IV);
360
361    /**
362     * Finalize decryption for the given unit of the protected content
363     *
364     * @param[in] uniqueId Unique identifier for a session
365     * @param[in] decryptHandle Handle for the decryption session
366     * @param[in] decryptUnitId ID which specifies decryption unit, such as track ID
367     * @return status_t
368     *     Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
369     */
370    status_t finalizeDecryptUnit(int uniqueId, DecryptHandle* decryptHandle, int decryptUnitId);
371
372    /**
373     * Reads the specified number of bytes from an open DRM file.
374     *
375     * @param[in] uniqueId Unique identifier for a session
376     * @param[in] decryptHandle Handle for the decryption session
377     * @param[out] buffer Reference to the buffer that should receive the read data.
378     * @param[in] numBytes Number of bytes to read.
379     * @param[in] offset Offset with which to update the file position.
380     *
381     * @return Number of bytes read. Returns -1 for Failure.
382     */
383    ssize_t pread(int uniqueId, DecryptHandle* decryptHandle,
384            void* buffer, ssize_t numBytes, off64_t offset);
385
386    /**
387     * Notify the event to the registered listener
388     *
389     * @param[in] event The event to be notified
390     * @return status_t
391     *     Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
392     */
393    status_t notify(const DrmInfoEvent& event);
394
395private:
396    /**
397     * Install new DRM Engine Plug-in at the runtime
398     *
399     * @param[in] uniqueId Unique identifier for a session
400     * @param[in] drmEngine Shared Object(so) File in which DRM Engine defined
401     * @return status_t
402     *     Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
403     */
404    status_t installDrmEngine(int uniqueId, const String8& drmEngineFile);
405
406private:
407    Mutex mLock;
408    sp<DrmManagerClient::OnInfoListener> mOnInfoListener;
409
410    class DeathNotifier: public IBinder::DeathRecipient {
411        public:
412            DeathNotifier() {}
413            virtual ~DeathNotifier();
414            virtual void binderDied(const wp<IBinder>& who);
415    };
416
417private:
418    static Mutex sMutex;
419    static sp<DeathNotifier> sDeathNotifier;
420    static sp<IDrmManagerService> sDrmManagerService;
421    static const sp<IDrmManagerService>& getDrmManagerService();
422    static const String8 EMPTY_STRING;
423};
424
425};
426
427#endif /* __DRM_MANAGER_CLIENT_IMPL_H__ */
428
429