DrmManagerClientImpl.cpp revision f355f18aa2cc1706761e373fe19298a9ccc9c75a 
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//#define LOG_NDEBUG 0
18#define LOG_TAG "DrmManagerClientImpl(Native)"
19#include <utils/Log.h>
20
21#include <utils/String8.h>
22#include <utils/Vector.h>
23#include <binder/IServiceManager.h>
24
25#include "DrmManagerClientImpl.h"
26
27using namespace android;
28
29#define INVALID_VALUE -1
30
31Mutex DrmManagerClientImpl::sMutex;
32sp<IDrmManagerService> DrmManagerClientImpl::sDrmManagerService;
33sp<DrmManagerClientImpl::DeathNotifier> DrmManagerClientImpl::sDeathNotifier;
34const String8 DrmManagerClientImpl::EMPTY_STRING("");
35
36DrmManagerClientImpl* DrmManagerClientImpl::create(
37        int* pUniqueId, bool isNative) {
38    *pUniqueId = getDrmManagerService()->addUniqueId(isNative);
39
40    return new DrmManagerClientImpl();
41}
42
43void DrmManagerClientImpl::remove(int uniqueId) {
44    getDrmManagerService()->removeUniqueId(uniqueId);
45}
46
47const sp<IDrmManagerService>& DrmManagerClientImpl::getDrmManagerService() {
48    Mutex::Autolock lock(sMutex);
49    if (NULL == sDrmManagerService.get()) {
50        sp<IServiceManager> sm = defaultServiceManager();
51        sp<IBinder> binder;
52        do {
53            binder = sm->getService(String16("drm.drmManager"));
54            if (binder != 0) {
55                break;
56            }
57            ALOGW("DrmManagerService not published, waiting...");
58            struct timespec reqt;
59            reqt.tv_sec  = 0;
60            reqt.tv_nsec = 500000000; //0.5 sec
61            nanosleep(&reqt, NULL);
62        } while (true);
63        if (NULL == sDeathNotifier.get()) {
64            sDeathNotifier = new DeathNotifier();
65        }
66        binder->linkToDeath(sDeathNotifier);
67        sDrmManagerService = interface_cast<IDrmManagerService>(binder);
68    }
69    return sDrmManagerService;
70}
71
72void DrmManagerClientImpl::addClient(int uniqueId) {
73    getDrmManagerService()->addClient(uniqueId);
74}
75
76void DrmManagerClientImpl::removeClient(int uniqueId) {
77    getDrmManagerService()->removeClient(uniqueId);
78}
79
80status_t DrmManagerClientImpl::setOnInfoListener(
81            int uniqueId,
82            const sp<DrmManagerClient::OnInfoListener>& infoListener) {
83    Mutex::Autolock _l(mLock);
84    mOnInfoListener = infoListener;
85    return getDrmManagerService()->setDrmServiceListener(uniqueId,
86            (NULL != infoListener.get()) ? this : NULL);
87}
88
89DrmConstraints* DrmManagerClientImpl::getConstraints(
90        int uniqueId, const String8* path, const int action) {
91    DrmConstraints *drmConstraints = NULL;
92    if ((NULL != path) && (EMPTY_STRING != *path)) {
93        drmConstraints =
94            getDrmManagerService()->getConstraints(uniqueId, path, action);
95    }
96    return drmConstraints;
97}
98
99DrmMetadata* DrmManagerClientImpl::getMetadata(int uniqueId, const String8* path) {
100    DrmMetadata *drmMetadata = NULL;
101    if ((NULL != path) && (EMPTY_STRING != *path)) {
102        drmMetadata = getDrmManagerService()->getMetadata(uniqueId, path);
103    }
104    return drmMetadata;
105}
106
107bool DrmManagerClientImpl::canHandle(
108        int uniqueId, const String8& path, const String8& mimeType) {
109    bool retCode = false;
110    if ((EMPTY_STRING != path) || (EMPTY_STRING != mimeType)) {
111        retCode = getDrmManagerService()->canHandle(uniqueId, path, mimeType);
112    }
113    return retCode;
114}
115
116DrmInfoStatus* DrmManagerClientImpl::processDrmInfo(
117        int uniqueId, const DrmInfo* drmInfo) {
118    DrmInfoStatus *drmInfoStatus = NULL;
119    if (NULL != drmInfo) {
120        drmInfoStatus = getDrmManagerService()->processDrmInfo(uniqueId, drmInfo);
121    }
122    return drmInfoStatus;
123}
124
125DrmInfo* DrmManagerClientImpl::acquireDrmInfo(
126        int uniqueId, const DrmInfoRequest* drmInfoRequest) {
127    DrmInfo* drmInfo = NULL;
128    if (NULL != drmInfoRequest) {
129        drmInfo = getDrmManagerService()->acquireDrmInfo(uniqueId, drmInfoRequest);
130    }
131    return drmInfo;
132}
133
134status_t DrmManagerClientImpl::saveRights(int uniqueId, const DrmRights& drmRights,
135            const String8& rightsPath, const String8& contentPath) {
136    return getDrmManagerService()->saveRights(
137                uniqueId, drmRights, rightsPath, contentPath);
138}
139
140String8 DrmManagerClientImpl::getOriginalMimeType(
141        int uniqueId, const String8& path, int fd) {
142    String8 mimeType = EMPTY_STRING;
143    if (EMPTY_STRING != path) {
144        mimeType = getDrmManagerService()->getOriginalMimeType(uniqueId, path, fd);
145    }
146    return mimeType;
147}
148
149int DrmManagerClientImpl::getDrmObjectType(
150            int uniqueId, const String8& path, const String8& mimeType) {
151    int drmOjectType = DrmObjectType::UNKNOWN;
152    if ((EMPTY_STRING != path) || (EMPTY_STRING != mimeType)) {
153         drmOjectType =
154             getDrmManagerService()->getDrmObjectType(uniqueId, path, mimeType);
155    }
156    return drmOjectType;
157}
158
159int DrmManagerClientImpl::checkRightsStatus(
160            int uniqueId, const String8& path, int action) {
161    int rightsStatus = RightsStatus::RIGHTS_INVALID;
162    if (EMPTY_STRING != path) {
163        rightsStatus =
164            getDrmManagerService()->checkRightsStatus(uniqueId, path, action);
165    }
166    return rightsStatus;
167}
168
169status_t DrmManagerClientImpl::consumeRights(
170            int uniqueId, sp<DecryptHandle> &decryptHandle,
171            int action, bool reserve) {
172    status_t status = DRM_ERROR_UNKNOWN;
173    if (NULL != decryptHandle.get()) {
174        status = getDrmManagerService()->consumeRights(
175                uniqueId, decryptHandle.get(), action, reserve);
176    }
177    return status;
178}
179
180status_t DrmManagerClientImpl::setPlaybackStatus(
181            int uniqueId, sp<DecryptHandle> &decryptHandle,
182            int playbackStatus, int64_t position) {
183    status_t status = DRM_ERROR_UNKNOWN;
184    if (NULL != decryptHandle.get()) {
185        status = getDrmManagerService()->setPlaybackStatus(
186                uniqueId, decryptHandle.get(), playbackStatus, position);
187    }
188    return status;
189}
190
191bool DrmManagerClientImpl::validateAction(
192            int uniqueId, const String8& path,
193            int action, const ActionDescription& description) {
194    bool retCode = false;
195    if (EMPTY_STRING != path) {
196        retCode = getDrmManagerService()->validateAction(
197                uniqueId, path, action, description);
198    }
199    return retCode;
200}
201
202status_t DrmManagerClientImpl::removeRights(int uniqueId, const String8& path) {
203    status_t status = DRM_ERROR_UNKNOWN;
204    if (EMPTY_STRING != path) {
205        status = getDrmManagerService()->removeRights(uniqueId, path);
206    }
207    return status;
208}
209
210status_t DrmManagerClientImpl::removeAllRights(int uniqueId) {
211    return getDrmManagerService()->removeAllRights(uniqueId);
212}
213
214int DrmManagerClientImpl::openConvertSession(
215        int uniqueId, const String8& mimeType) {
216    int retCode = INVALID_VALUE;
217    if (EMPTY_STRING != mimeType) {
218        retCode = getDrmManagerService()->openConvertSession(uniqueId, mimeType);
219    }
220    return retCode;
221}
222
223DrmConvertedStatus* DrmManagerClientImpl::convertData(
224            int uniqueId, int convertId, const DrmBuffer* inputData) {
225    DrmConvertedStatus* drmConvertedStatus = NULL;
226    if (NULL != inputData) {
227         drmConvertedStatus =
228             getDrmManagerService()->convertData(uniqueId, convertId, inputData);
229    }
230    return drmConvertedStatus;
231}
232
233DrmConvertedStatus* DrmManagerClientImpl::closeConvertSession(
234        int uniqueId, int convertId) {
235    return getDrmManagerService()->closeConvertSession(uniqueId, convertId);
236}
237
238status_t DrmManagerClientImpl::getAllSupportInfo(
239            int uniqueId, int* length, DrmSupportInfo** drmSupportInfoArray) {
240    status_t status = DRM_ERROR_UNKNOWN;
241    if ((NULL != drmSupportInfoArray) && (NULL != length)) {
242        status = getDrmManagerService()->getAllSupportInfo(
243                uniqueId, length, drmSupportInfoArray);
244    }
245    return status;
246}
247
248sp<DecryptHandle> DrmManagerClientImpl::openDecryptSession(
249            int uniqueId, int fd, off64_t offset,
250            off64_t length, const char* mime) {
251
252    return getDrmManagerService()->openDecryptSession(
253                uniqueId, fd, offset, length, mime);
254}
255
256sp<DecryptHandle> DrmManagerClientImpl::openDecryptSession(
257        int uniqueId, const char* uri, const char* mime) {
258
259    DecryptHandle* handle = NULL;
260    if (NULL != uri) {
261        handle = getDrmManagerService()->openDecryptSession(uniqueId, uri, mime);
262    }
263    return handle;
264}
265
266sp<DecryptHandle> DrmManagerClientImpl::openDecryptSession(
267            int uniqueId, const DrmBuffer& buf, const String8& mimeType) {
268    return getDrmManagerService()->openDecryptSession(uniqueId, buf, mimeType);
269}
270
271status_t DrmManagerClientImpl::closeDecryptSession(
272        int uniqueId, sp<DecryptHandle> &decryptHandle) {
273    status_t status = DRM_ERROR_UNKNOWN;
274    if (NULL != decryptHandle.get()) {
275        status = getDrmManagerService()->closeDecryptSession(
276                uniqueId, decryptHandle.get());
277    }
278    return status;
279}
280
281status_t DrmManagerClientImpl::initializeDecryptUnit(
282        int uniqueId, sp<DecryptHandle> &decryptHandle,
283        int decryptUnitId, const DrmBuffer* headerInfo) {
284    status_t status = DRM_ERROR_UNKNOWN;
285    if ((NULL != decryptHandle.get()) && (NULL != headerInfo)) {
286        status = getDrmManagerService()->initializeDecryptUnit(
287                uniqueId, decryptHandle.get(), decryptUnitId, headerInfo);
288    }
289    return status;
290}
291
292status_t DrmManagerClientImpl::decrypt(
293        int uniqueId, sp<DecryptHandle> &decryptHandle,
294        int decryptUnitId, const DrmBuffer* encBuffer,
295        DrmBuffer** decBuffer, DrmBuffer* IV) {
296    status_t status = DRM_ERROR_UNKNOWN;
297    if ((NULL != decryptHandle.get()) && (NULL != encBuffer)
298        && (NULL != decBuffer) && (NULL != *decBuffer)) {
299        status = getDrmManagerService()->decrypt(
300                uniqueId, decryptHandle.get(), decryptUnitId,
301                encBuffer, decBuffer, IV);
302    }
303    return status;
304}
305
306status_t DrmManagerClientImpl::finalizeDecryptUnit(
307            int uniqueId, sp<DecryptHandle> &decryptHandle, int decryptUnitId) {
308    status_t status = DRM_ERROR_UNKNOWN;
309    if (NULL != decryptHandle.get()) {
310        status = getDrmManagerService()->finalizeDecryptUnit(
311                    uniqueId, decryptHandle.get(), decryptUnitId);
312    }
313    return status;
314}
315
316ssize_t DrmManagerClientImpl::pread(int uniqueId, sp<DecryptHandle> &decryptHandle,
317            void* buffer, ssize_t numBytes, off64_t offset) {
318    ssize_t retCode = INVALID_VALUE;
319    if ((NULL != decryptHandle.get()) && (NULL != buffer) && (0 < numBytes)) {
320        retCode = getDrmManagerService()->pread(
321                uniqueId, decryptHandle.get(), buffer, numBytes, offset);
322    }
323    return retCode;
324}
325
326status_t DrmManagerClientImpl::notify(const DrmInfoEvent& event) {
327    if (NULL != mOnInfoListener.get()) {
328        Mutex::Autolock _l(mLock);
329        sp<DrmManagerClient::OnInfoListener> listener = mOnInfoListener;
330        listener->onInfo(event);
331    }
332    return DRM_NO_ERROR;
333}
334
335DrmManagerClientImpl::DeathNotifier::~DeathNotifier() {
336    Mutex::Autolock lock(sMutex);
337    if (NULL != sDrmManagerService.get()) {
338        sDrmManagerService->asBinder()->unlinkToDeath(this);
339    }
340}
341
342void DrmManagerClientImpl::DeathNotifier::binderDied(const wp<IBinder>& who) {
343    Mutex::Autolock lock(sMutex);
344    DrmManagerClientImpl::sDrmManagerService.clear();
345    ALOGW("DrmManager server died!");
346}
347
348