IDrmManagerService.cpp revision bf5b3b29e31b293313788d7464cfb258ac0da803 
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 "IDrmManagerService(Native)"
19#include <utils/Log.h>
20
21#include <stdint.h>
22#include <sys/types.h>
23#include <binder/IPCThreadState.h>
24
25#include <drm/DrmInfo.h>
26#include <drm/DrmConstraints.h>
27#include <drm/DrmMetadata.h>
28#include <drm/DrmRights.h>
29#include <drm/DrmInfoStatus.h>
30#include <drm/DrmConvertedStatus.h>
31#include <drm/DrmInfoRequest.h>
32#include <drm/DrmSupportInfo.h>
33
34#include "IDrmManagerService.h"
35
36#define INVALID_BUFFER_LENGTH -1
37
38using namespace android;
39
40static void writeDecryptHandleToParcelData(
41        const DecryptHandle* handle, Parcel* data) {
42    data->writeInt32(handle->decryptId);
43    data->writeString8(handle->mimeType);
44    data->writeInt32(handle->decryptApiType);
45    data->writeInt32(handle->status);
46
47    int size = handle->copyControlVector.size();
48    data->writeInt32(size);
49    for (int i = 0; i < size; i++) {
50        data->writeInt32(handle->copyControlVector.keyAt(i));
51        data->writeInt32(handle->copyControlVector.valueAt(i));
52    }
53
54    size = handle->extendedData.size();
55    data->writeInt32(size);
56    for (int i = 0; i < size; i++) {
57        data->writeString8(handle->extendedData.keyAt(i));
58        data->writeString8(handle->extendedData.valueAt(i));
59    }
60
61    if (NULL != handle->decryptInfo) {
62        data->writeInt32(handle->decryptInfo->decryptBufferLength);
63    } else {
64        data->writeInt32(INVALID_BUFFER_LENGTH);
65    }
66}
67
68static void readDecryptHandleFromParcelData(
69        DecryptHandle* handle, const Parcel& data) {
70    if (0 == data.dataAvail()) {
71        return;
72    }
73
74    handle->decryptId = data.readInt32();
75    handle->mimeType = data.readString8();
76    handle->decryptApiType = data.readInt32();
77    handle->status = data.readInt32();
78
79    int size = data.readInt32();
80    for (int i = 0; i < size; i++) {
81        DrmCopyControl key = (DrmCopyControl)data.readInt32();
82        int value = data.readInt32();
83        handle->copyControlVector.add(key, value);
84    }
85
86    size = data.readInt32();
87    for (int i = 0; i < size; i++) {
88        String8 key = data.readString8();
89        String8 value = data.readString8();
90        handle->extendedData.add(key, value);
91    }
92
93    handle->decryptInfo = NULL;
94    const int bufferLen = data.readInt32();
95    if (INVALID_BUFFER_LENGTH != bufferLen) {
96        handle->decryptInfo = new DecryptInfo();
97        handle->decryptInfo->decryptBufferLength = bufferLen;
98    }
99}
100
101static void clearDecryptHandle(DecryptHandle* handle) {
102    if (handle == NULL) {
103        return;
104    }
105    if (handle->decryptInfo) {
106        delete handle->decryptInfo;
107        handle->decryptInfo = NULL;
108    }
109    handle->copyControlVector.clear();
110    handle->extendedData.clear();
111}
112
113int BpDrmManagerService::addUniqueId(bool isNative) {
114    ALOGV("add uniqueid");
115    Parcel data, reply;
116    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
117    data.writeInt32(isNative);
118    remote()->transact(ADD_UNIQUEID, data, &reply);
119    return reply.readInt32();
120}
121
122void BpDrmManagerService::removeUniqueId(int uniqueId) {
123    ALOGV("remove uniqueid");
124    Parcel data, reply;
125    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
126    data.writeInt32(uniqueId);
127    remote()->transact(REMOVE_UNIQUEID, data, &reply);
128}
129
130void BpDrmManagerService::addClient(int uniqueId) {
131    Parcel data, reply;
132    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
133    data.writeInt32(uniqueId);
134    remote()->transact(ADD_CLIENT, data, &reply);
135}
136
137void BpDrmManagerService::removeClient(int uniqueId) {
138    Parcel data, reply;
139    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
140    data.writeInt32(uniqueId);
141    remote()->transact(REMOVE_CLIENT, data, &reply);
142}
143
144status_t BpDrmManagerService::setDrmServiceListener(
145            int uniqueId, const sp<IDrmServiceListener>& drmServiceListener) {
146    ALOGV("setDrmServiceListener");
147    Parcel data, reply;
148
149    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
150    data.writeInt32(uniqueId);
151    data.writeStrongBinder(drmServiceListener->asBinder());
152    remote()->transact(SET_DRM_SERVICE_LISTENER, data, &reply);
153    return reply.readInt32();
154}
155
156status_t BpDrmManagerService::installDrmEngine(int uniqueId, const String8& drmEngineFile) {
157    ALOGV("Install DRM Engine");
158    Parcel data, reply;
159
160    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
161    data.writeInt32(uniqueId);
162    data.writeString8(drmEngineFile);
163
164    remote()->transact(INSTALL_DRM_ENGINE, data, &reply);
165    return reply.readInt32();
166}
167
168DrmConstraints* BpDrmManagerService::getConstraints(
169            int uniqueId, const String8* path, const int action) {
170    ALOGV("Get Constraints");
171    Parcel data, reply;
172
173    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
174    data.writeInt32(uniqueId);
175    data.writeString8(*path);
176    data.writeInt32(action);
177
178    remote()->transact(GET_CONSTRAINTS_FROM_CONTENT, data, &reply);
179
180    DrmConstraints* drmConstraints = NULL;
181    if (0 != reply.dataAvail()) {
182        //Filling Drm Constraints
183        drmConstraints = new DrmConstraints();
184
185        const int size = reply.readInt32();
186        for (int index = 0; index < size; ++index) {
187            const String8 key(reply.readString8());
188            const int bufferSize = reply.readInt32();
189            char* data = NULL;
190            if (0 < bufferSize) {
191                data = new char[bufferSize];
192                reply.read(data, bufferSize);
193            }
194            drmConstraints->put(&key, data);
195        }
196    }
197    return drmConstraints;
198}
199
200DrmMetadata* BpDrmManagerService::getMetadata(int uniqueId, const String8* path) {
201    ALOGV("Get Metadata");
202    Parcel data, reply;
203    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
204    data.writeInt32(uniqueId);
205
206    DrmMetadata* drmMetadata = NULL;
207    data.writeString8(*path);
208    remote()->transact(GET_METADATA_FROM_CONTENT, data, &reply);
209
210    if (0 != reply.dataAvail()) {
211        //Filling Drm Metadata
212        drmMetadata = new DrmMetadata();
213
214        const int size = reply.readInt32();
215        for (int index = 0; index < size; ++index) {
216            const String8 key(reply.readString8());
217            const int bufferSize = reply.readInt32();
218            char* data = NULL;
219            if (0 < bufferSize) {
220                data = new char[bufferSize];
221                reply.read(data, bufferSize);
222            }
223            drmMetadata->put(&key, data);
224        }
225    }
226    return drmMetadata;
227}
228
229bool BpDrmManagerService::canHandle(int uniqueId, const String8& path, const String8& mimeType) {
230    ALOGV("Can Handle");
231    Parcel data, reply;
232
233    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
234    data.writeInt32(uniqueId);
235
236    data.writeString8(path);
237    data.writeString8(mimeType);
238
239    remote()->transact(CAN_HANDLE, data, &reply);
240
241    return static_cast<bool>(reply.readInt32());
242}
243
244DrmInfoStatus* BpDrmManagerService::processDrmInfo(int uniqueId, const DrmInfo* drmInfo) {
245    ALOGV("Process DRM Info");
246    Parcel data, reply;
247
248    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
249    data.writeInt32(uniqueId);
250
251    //Filling DRM info
252    data.writeInt32(drmInfo->getInfoType());
253    const DrmBuffer dataBuffer = drmInfo->getData();
254    const int dataBufferSize = dataBuffer.length;
255    data.writeInt32(dataBufferSize);
256    if (0 < dataBufferSize) {
257        data.write(dataBuffer.data, dataBufferSize);
258    }
259    data.writeString8(drmInfo->getMimeType());
260
261    data.writeInt32(drmInfo->getCount());
262    DrmInfo::KeyIterator keyIt = drmInfo->keyIterator();
263
264    while (keyIt.hasNext()) {
265        const String8 key = keyIt.next();
266        data.writeString8(key);
267        const String8 value = drmInfo->get(key);
268        data.writeString8((value == String8("")) ? String8("NULL") : value);
269    }
270
271    remote()->transact(PROCESS_DRM_INFO, data, &reply);
272
273    DrmInfoStatus* drmInfoStatus = NULL;
274    if (0 != reply.dataAvail()) {
275        //Filling DRM Info Status
276        const int statusCode = reply.readInt32();
277        const int infoType = reply.readInt32();
278        const String8 mimeType = reply.readString8();
279
280        DrmBuffer* drmBuffer = NULL;
281        if (0 != reply.dataAvail()) {
282            const int bufferSize = reply.readInt32();
283            char* data = NULL;
284            if (0 < bufferSize) {
285                data = new char[bufferSize];
286                reply.read(data, bufferSize);
287            }
288            drmBuffer = new DrmBuffer(data, bufferSize);
289        }
290        drmInfoStatus = new DrmInfoStatus(statusCode, infoType, drmBuffer, mimeType);
291    }
292    return drmInfoStatus;
293}
294
295DrmInfo* BpDrmManagerService::acquireDrmInfo(int uniqueId, const DrmInfoRequest* drmInforequest) {
296    ALOGV("Acquire DRM Info");
297    Parcel data, reply;
298
299    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
300    data.writeInt32(uniqueId);
301
302    //Filling DRM Info Request
303    data.writeInt32(drmInforequest->getInfoType());
304    data.writeString8(drmInforequest->getMimeType());
305
306    data.writeInt32(drmInforequest->getCount());
307    DrmInfoRequest::KeyIterator keyIt = drmInforequest->keyIterator();
308
309    while (keyIt.hasNext()) {
310        const String8 key = keyIt.next();
311        data.writeString8(key);
312        const String8 value = drmInforequest->get(key);
313        data.writeString8((value == String8("")) ? String8("NULL") : value);
314    }
315
316    remote()->transact(ACQUIRE_DRM_INFO, data, &reply);
317
318    DrmInfo* drmInfo = NULL;
319    if (0 != reply.dataAvail()) {
320        //Filling DRM Info
321        const int infoType = reply.readInt32();
322        const int bufferSize = reply.readInt32();
323        char* data = NULL;
324
325        if (0 < bufferSize) {
326            data = new char[bufferSize];
327            reply.read(data, bufferSize);
328        }
329        drmInfo = new DrmInfo(infoType, DrmBuffer(data, bufferSize), reply.readString8());
330
331        const int size = reply.readInt32();
332        for (int index = 0; index < size; ++index) {
333            const String8 key(reply.readString8());
334            const String8 value(reply.readString8());
335            drmInfo->put(key, (value == String8("NULL")) ? String8("") : value);
336        }
337    }
338    return drmInfo;
339}
340
341status_t BpDrmManagerService::saveRights(
342            int uniqueId, const DrmRights& drmRights,
343            const String8& rightsPath, const String8& contentPath) {
344    ALOGV("Save Rights");
345    Parcel data, reply;
346
347    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
348    data.writeInt32(uniqueId);
349
350    //Filling Drm Rights
351    const DrmBuffer dataBuffer = drmRights.getData();
352    data.writeInt32(dataBuffer.length);
353    data.write(dataBuffer.data, dataBuffer.length);
354
355    const String8 mimeType = drmRights.getMimeType();
356    data.writeString8((mimeType == String8("")) ? String8("NULL") : mimeType);
357
358    const String8 accountId = drmRights.getAccountId();
359    data.writeString8((accountId == String8("")) ? String8("NULL") : accountId);
360
361    const String8 subscriptionId = drmRights.getSubscriptionId();
362    data.writeString8((subscriptionId == String8("")) ? String8("NULL") : subscriptionId);
363
364    data.writeString8((rightsPath == String8("")) ? String8("NULL") : rightsPath);
365    data.writeString8((contentPath == String8("")) ? String8("NULL") : contentPath);
366
367    remote()->transact(SAVE_RIGHTS, data, &reply);
368    return reply.readInt32();
369}
370
371String8 BpDrmManagerService::getOriginalMimeType(int uniqueId, const String8& path, int fd) {
372    ALOGV("Get Original MimeType");
373    Parcel data, reply;
374
375    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
376    data.writeInt32(uniqueId);
377    data.writeString8(path);
378    int32_t isFdValid = (fd >= 0);
379    data.writeInt32(isFdValid);
380    if (isFdValid) {
381        data.writeFileDescriptor(fd);
382    }
383
384    remote()->transact(GET_ORIGINAL_MIMETYPE, data, &reply);
385    return reply.readString8();
386}
387
388int BpDrmManagerService::getDrmObjectType(
389            int uniqueId, const String8& path, const String8& mimeType) {
390    ALOGV("Get Drm object type");
391    Parcel data, reply;
392
393    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
394    data.writeInt32(uniqueId);
395    data.writeString8(path);
396    data.writeString8(mimeType);
397
398    remote()->transact(GET_DRM_OBJECT_TYPE, data, &reply);
399
400    return reply.readInt32();
401}
402
403int BpDrmManagerService::checkRightsStatus(int uniqueId, const String8& path, int action) {
404    ALOGV("checkRightsStatus");
405    Parcel data, reply;
406
407    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
408    data.writeInt32(uniqueId);
409    data.writeString8(path);
410    data.writeInt32(action);
411
412    remote()->transact(CHECK_RIGHTS_STATUS, data, &reply);
413
414    return reply.readInt32();
415}
416
417status_t BpDrmManagerService::consumeRights(
418            int uniqueId, DecryptHandle* decryptHandle, int action, bool reserve) {
419    ALOGV("consumeRights");
420    Parcel data, reply;
421
422    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
423    data.writeInt32(uniqueId);
424
425    writeDecryptHandleToParcelData(decryptHandle, &data);
426
427    data.writeInt32(action);
428    data.writeInt32(static_cast< int>(reserve));
429
430    remote()->transact(CONSUME_RIGHTS, data, &reply);
431    return reply.readInt32();
432}
433
434status_t BpDrmManagerService::setPlaybackStatus(
435            int uniqueId, DecryptHandle* decryptHandle, int playbackStatus, int64_t position) {
436    ALOGV("setPlaybackStatus");
437    Parcel data, reply;
438
439    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
440    data.writeInt32(uniqueId);
441
442    writeDecryptHandleToParcelData(decryptHandle, &data);
443
444    data.writeInt32(playbackStatus);
445    data.writeInt64(position);
446
447    remote()->transact(SET_PLAYBACK_STATUS, data, &reply);
448    return reply.readInt32();
449}
450
451bool BpDrmManagerService::validateAction(
452            int uniqueId, const String8& path,
453            int action, const ActionDescription& description) {
454    ALOGV("validateAction");
455    Parcel data, reply;
456
457    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
458    data.writeInt32(uniqueId);
459    data.writeString8(path);
460    data.writeInt32(action);
461    data.writeInt32(description.outputType);
462    data.writeInt32(description.configuration);
463
464    remote()->transact(VALIDATE_ACTION, data, &reply);
465
466    return static_cast<bool>(reply.readInt32());
467}
468
469status_t BpDrmManagerService::removeRights(int uniqueId, const String8& path) {
470    ALOGV("removeRights");
471    Parcel data, reply;
472
473    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
474    data.writeInt32(uniqueId);
475    data.writeString8(path);
476
477    remote()->transact(REMOVE_RIGHTS, data, &reply);
478    return reply.readInt32();
479}
480
481status_t BpDrmManagerService::removeAllRights(int uniqueId) {
482    ALOGV("removeAllRights");
483    Parcel data, reply;
484
485    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
486    data.writeInt32(uniqueId);
487
488    remote()->transact(REMOVE_ALL_RIGHTS, data, &reply);
489    return reply.readInt32();
490}
491
492int BpDrmManagerService::openConvertSession(int uniqueId, const String8& mimeType) {
493    ALOGV("openConvertSession");
494    Parcel data, reply;
495
496    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
497    data.writeInt32(uniqueId);
498    data.writeString8(mimeType);
499
500    remote()->transact(OPEN_CONVERT_SESSION, data, &reply);
501    return reply.readInt32();
502}
503
504DrmConvertedStatus* BpDrmManagerService::convertData(
505            int uniqueId, int convertId, const DrmBuffer* inputData) {
506    ALOGV("convertData");
507    Parcel data, reply;
508
509    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
510    data.writeInt32(uniqueId);
511    data.writeInt32(convertId);
512    data.writeInt32(inputData->length);
513    data.write(inputData->data, inputData->length);
514
515    remote()->transact(CONVERT_DATA, data, &reply);
516
517    DrmConvertedStatus* drmConvertedStatus = NULL;
518
519    if (0 != reply.dataAvail()) {
520        //Filling DRM Converted Status
521        const int statusCode = reply.readInt32();
522        const off64_t offset = reply.readInt64();
523
524        DrmBuffer* convertedData = NULL;
525        if (0 != reply.dataAvail()) {
526            const int bufferSize = reply.readInt32();
527            char* data = NULL;
528            if (0 < bufferSize) {
529                data = new char[bufferSize];
530                reply.read(data, bufferSize);
531            }
532            convertedData = new DrmBuffer(data, bufferSize);
533        }
534        drmConvertedStatus = new DrmConvertedStatus(statusCode, convertedData, offset);
535    }
536    return drmConvertedStatus;
537}
538
539DrmConvertedStatus* BpDrmManagerService::closeConvertSession(int uniqueId, int convertId) {
540    ALOGV("closeConvertSession");
541    Parcel data, reply;
542
543    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
544    data.writeInt32(uniqueId);
545    data.writeInt32(convertId);
546
547    remote()->transact(CLOSE_CONVERT_SESSION, data, &reply);
548
549    DrmConvertedStatus* drmConvertedStatus = NULL;
550
551    if (0 != reply.dataAvail()) {
552        //Filling DRM Converted Status
553        const int statusCode = reply.readInt32();
554        const off64_t offset = reply.readInt64();
555
556        DrmBuffer* convertedData = NULL;
557        if (0 != reply.dataAvail()) {
558            const int bufferSize = reply.readInt32();
559            char* data = NULL;
560            if (0 < bufferSize) {
561                data = new char[bufferSize];
562                reply.read(data, bufferSize);
563            }
564            convertedData = new DrmBuffer(data, bufferSize);
565        }
566        drmConvertedStatus = new DrmConvertedStatus(statusCode, convertedData, offset);
567    }
568    return drmConvertedStatus;
569}
570
571status_t BpDrmManagerService::getAllSupportInfo(
572            int uniqueId, int* length, DrmSupportInfo** drmSupportInfoArray) {
573    ALOGV("Get All Support Info");
574    Parcel data, reply;
575
576    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
577    data.writeInt32(uniqueId);
578
579    remote()->transact(GET_ALL_SUPPORT_INFO, data, &reply);
580
581    //Filling DRM Support Info
582    const int arraySize = reply.readInt32();
583    if (0 < arraySize) {
584        *drmSupportInfoArray = new DrmSupportInfo[arraySize];
585
586        for (int index = 0; index < arraySize; ++index) {
587            DrmSupportInfo drmSupportInfo;
588
589            const int fileSuffixVectorSize = reply.readInt32();
590            for (int i = 0; i < fileSuffixVectorSize; ++i) {
591                drmSupportInfo.addFileSuffix(reply.readString8());
592            }
593
594            const int mimeTypeVectorSize = reply.readInt32();
595            for (int i = 0; i < mimeTypeVectorSize; ++i) {
596                drmSupportInfo.addMimeType(reply.readString8());
597            }
598
599            drmSupportInfo.setDescription(reply.readString8());
600            (*drmSupportInfoArray)[index] = drmSupportInfo;
601        }
602    }
603    *length = arraySize;
604    return reply.readInt32();
605}
606
607DecryptHandle* BpDrmManagerService::openDecryptSession(
608            int uniqueId, int fd, off64_t offset, off64_t length, const char* mime) {
609    ALOGV("Entering BpDrmManagerService::openDecryptSession");
610    Parcel data, reply;
611
612    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
613    data.writeInt32(uniqueId);
614    data.writeFileDescriptor(fd);
615    data.writeInt64(offset);
616    data.writeInt64(length);
617    String8 mimeType;
618    if (mime) {
619        mimeType = mime;
620    }
621    data.writeString8(mimeType);
622
623    remote()->transact(OPEN_DECRYPT_SESSION, data, &reply);
624
625    DecryptHandle* handle = NULL;
626    if (0 != reply.dataAvail()) {
627        handle = new DecryptHandle();
628        readDecryptHandleFromParcelData(handle, reply);
629    }
630    return handle;
631}
632
633DecryptHandle* BpDrmManagerService::openDecryptSession(
634        int uniqueId, const char* uri, const char* mime) {
635
636    ALOGV("Entering BpDrmManagerService::openDecryptSession: mime=%s", mime? mime: "NULL");
637    Parcel data, reply;
638
639    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
640    data.writeInt32(uniqueId);
641    data.writeString8(String8(uri));
642    String8 mimeType;
643    if (mime) {
644        mimeType = mime;
645    }
646    data.writeString8(mimeType);
647
648    remote()->transact(OPEN_DECRYPT_SESSION_FROM_URI, data, &reply);
649
650    DecryptHandle* handle = NULL;
651    if (0 != reply.dataAvail()) {
652        handle = new DecryptHandle();
653        readDecryptHandleFromParcelData(handle, reply);
654    } else {
655        ALOGV("no decryptHandle is generated in service side");
656    }
657    return handle;
658}
659
660DecryptHandle* BpDrmManagerService::openDecryptSession(
661            int uniqueId, const DrmBuffer& buf, const String8& mimeType) {
662    ALOGV("Entering BpDrmManagerService::openDecryptSession");
663    Parcel data, reply;
664
665    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
666    data.writeInt32(uniqueId);
667    if (buf.data != NULL && buf.length > 0) {
668        data.writeInt32(buf.length);
669        data.write(buf.data, buf.length);
670    } else {
671        data.writeInt32(0);
672    }
673    data.writeString8(mimeType);
674
675    remote()->transact(OPEN_DECRYPT_SESSION_FOR_STREAMING, data, &reply);
676
677    DecryptHandle* handle = NULL;
678    if (0 != reply.dataAvail()) {
679        handle = new DecryptHandle();
680        readDecryptHandleFromParcelData(handle, reply);
681    } else {
682        ALOGV("no decryptHandle is generated in service side");
683    }
684    return handle;
685}
686
687status_t BpDrmManagerService::closeDecryptSession(int uniqueId, DecryptHandle* decryptHandle) {
688    ALOGV("closeDecryptSession");
689    Parcel data, reply;
690
691    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
692    data.writeInt32(uniqueId);
693
694    writeDecryptHandleToParcelData(decryptHandle, &data);
695
696    remote()->transact(CLOSE_DECRYPT_SESSION, data, &reply);
697
698    return reply.readInt32();
699}
700
701status_t BpDrmManagerService::initializeDecryptUnit(
702            int uniqueId, DecryptHandle* decryptHandle,
703            int decryptUnitId, const DrmBuffer* headerInfo) {
704    ALOGV("initializeDecryptUnit");
705    Parcel data, reply;
706
707    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
708    data.writeInt32(uniqueId);
709
710    writeDecryptHandleToParcelData(decryptHandle, &data);
711
712    data.writeInt32(decryptUnitId);
713
714    data.writeInt32(headerInfo->length);
715    data.write(headerInfo->data, headerInfo->length);
716
717    remote()->transact(INITIALIZE_DECRYPT_UNIT, data, &reply);
718    return reply.readInt32();
719}
720
721status_t BpDrmManagerService::decrypt(
722            int uniqueId, DecryptHandle* decryptHandle, int decryptUnitId,
723            const DrmBuffer* encBuffer, DrmBuffer** decBuffer, DrmBuffer* IV) {
724    ALOGV("decrypt");
725    Parcel data, reply;
726
727    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
728    data.writeInt32(uniqueId);
729
730    writeDecryptHandleToParcelData(decryptHandle, &data);
731
732    data.writeInt32(decryptUnitId);
733    data.writeInt32((*decBuffer)->length);
734
735    data.writeInt32(encBuffer->length);
736    data.write(encBuffer->data, encBuffer->length);
737
738    if (NULL != IV) {
739        data.writeInt32(IV->length);
740        data.write(IV->data, IV->length);
741    }
742
743    remote()->transact(DECRYPT, data, &reply);
744
745    const status_t status = reply.readInt32();
746    ALOGV("Return value of decrypt() is %d", status);
747
748    const int size = reply.readInt32();
749    (*decBuffer)->length = size;
750    reply.read((void *)(*decBuffer)->data, size);
751
752    return status;
753}
754
755status_t BpDrmManagerService::finalizeDecryptUnit(
756            int uniqueId, DecryptHandle* decryptHandle, int decryptUnitId) {
757    ALOGV("finalizeDecryptUnit");
758    Parcel data, reply;
759
760    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
761    data.writeInt32(uniqueId);
762
763    writeDecryptHandleToParcelData(decryptHandle, &data);
764
765    data.writeInt32(decryptUnitId);
766
767    remote()->transact(FINALIZE_DECRYPT_UNIT, data, &reply);
768    return reply.readInt32();
769}
770
771ssize_t BpDrmManagerService::pread(
772            int uniqueId, DecryptHandle* decryptHandle, void* buffer,
773            ssize_t numBytes, off64_t offset) {
774    ALOGV("read");
775    Parcel data, reply;
776    int result;
777
778    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
779    data.writeInt32(uniqueId);
780
781    writeDecryptHandleToParcelData(decryptHandle, &data);
782
783    data.writeInt32(numBytes);
784    data.writeInt64(offset);
785
786    remote()->transact(PREAD, data, &reply);
787    result = reply.readInt32();
788    if (0 < result) {
789        reply.read(buffer, result);
790    }
791    return result;
792}
793
794IMPLEMENT_META_INTERFACE(DrmManagerService, "drm.IDrmManagerService");
795
796status_t BnDrmManagerService::onTransact(
797            uint32_t code, const Parcel& data,
798            Parcel* reply, uint32_t flags) {
799    ALOGV("Entering BnDrmManagerService::onTransact with code %d", code);
800
801    switch (code) {
802    case ADD_UNIQUEID:
803    {
804        ALOGV("BnDrmManagerService::onTransact :ADD_UNIQUEID");
805        CHECK_INTERFACE(IDrmManagerService, data, reply);
806        int uniqueId = addUniqueId(data.readInt32());
807        reply->writeInt32(uniqueId);
808        return DRM_NO_ERROR;
809    }
810
811    case REMOVE_UNIQUEID:
812    {
813        ALOGV("BnDrmManagerService::onTransact :REMOVE_UNIQUEID");
814        CHECK_INTERFACE(IDrmManagerService, data, reply);
815        removeUniqueId(data.readInt32());
816        return DRM_NO_ERROR;
817    }
818
819    case ADD_CLIENT:
820    {
821        ALOGV("BnDrmManagerService::onTransact :ADD_CLIENT");
822        CHECK_INTERFACE(IDrmManagerService, data, reply);
823        addClient(data.readInt32());
824        return DRM_NO_ERROR;
825    }
826
827    case REMOVE_CLIENT:
828    {
829        ALOGV("BnDrmManagerService::onTransact :REMOVE_CLIENT");
830        CHECK_INTERFACE(IDrmManagerService, data, reply);
831        removeClient(data.readInt32());
832        return DRM_NO_ERROR;
833    }
834
835    case SET_DRM_SERVICE_LISTENER:
836    {
837        ALOGV("BnDrmManagerService::onTransact :SET_DRM_SERVICE_LISTENER");
838        CHECK_INTERFACE(IDrmManagerService, data, reply);
839
840        const int uniqueId = data.readInt32();
841        const sp<IDrmServiceListener> drmServiceListener
842            = interface_cast<IDrmServiceListener> (data.readStrongBinder());
843
844        status_t status = setDrmServiceListener(uniqueId, drmServiceListener);
845
846        reply->writeInt32(status);
847        return DRM_NO_ERROR;
848    }
849
850    case INSTALL_DRM_ENGINE:
851    {
852        ALOGV("BnDrmManagerService::onTransact :INSTALL_DRM_ENGINE");
853        CHECK_INTERFACE(IDrmManagerService, data, reply);
854
855        const int uniqueId = data.readInt32();
856        const String8 engineFile = data.readString8();
857        status_t status = installDrmEngine(uniqueId, engineFile);
858
859        reply->writeInt32(status);
860        return DRM_NO_ERROR;
861    }
862
863    case GET_CONSTRAINTS_FROM_CONTENT:
864    {
865        ALOGV("BnDrmManagerService::onTransact :GET_CONSTRAINTS_FROM_CONTENT");
866        CHECK_INTERFACE(IDrmManagerService, data, reply);
867
868        const int uniqueId = data.readInt32();
869        const String8 path = data.readString8();
870
871        DrmConstraints* drmConstraints
872            = getConstraints(uniqueId, &path, data.readInt32());
873
874        if (NULL != drmConstraints) {
875            //Filling DRM Constraints contents
876            reply->writeInt32(drmConstraints->getCount());
877
878            DrmConstraints::KeyIterator keyIt = drmConstraints->keyIterator();
879            while (keyIt.hasNext()) {
880                const String8 key = keyIt.next();
881                reply->writeString8(key);
882                const char* value = drmConstraints->getAsByteArray(&key);
883                int bufferSize = 0;
884                if (NULL != value) {
885                    bufferSize = strlen(value);
886                }
887                reply->writeInt32(bufferSize + 1);
888                reply->write(value, bufferSize + 1);
889            }
890        }
891        delete drmConstraints; drmConstraints = NULL;
892        return DRM_NO_ERROR;
893    }
894
895    case GET_METADATA_FROM_CONTENT:
896    {
897        ALOGV("BnDrmManagerService::onTransact :GET_METADATA_FROM_CONTENT");
898        CHECK_INTERFACE(IDrmManagerService, data, reply);
899
900        const int uniqueId = data.readInt32();
901        const String8 path = data.readString8();
902
903        DrmMetadata* drmMetadata = getMetadata(uniqueId, &path);
904        if (NULL != drmMetadata) {
905            //Filling DRM Metadata contents
906            reply->writeInt32(drmMetadata->getCount());
907
908            DrmMetadata::KeyIterator keyIt = drmMetadata->keyIterator();
909            while (keyIt.hasNext()) {
910                const String8 key = keyIt.next();
911                reply->writeString8(key);
912                const char* value = drmMetadata->getAsByteArray(&key);
913                int bufferSize = 0;
914                if (NULL != value) {
915                    bufferSize = strlen(value);
916                    reply->writeInt32(bufferSize + 1);
917                    reply->write(value, bufferSize + 1);
918                } else {
919                    reply->writeInt32(0);
920                }
921            }
922        }
923        delete drmMetadata; drmMetadata = NULL;
924        return NO_ERROR;
925    }
926
927    case CAN_HANDLE:
928    {
929        ALOGV("BnDrmManagerService::onTransact :CAN_HANDLE");
930        CHECK_INTERFACE(IDrmManagerService, data, reply);
931
932        const int uniqueId = data.readInt32();
933        const String8 path = data.readString8();
934        const String8 mimeType = data.readString8();
935
936        bool result = canHandle(uniqueId, path, mimeType);
937
938        reply->writeInt32(result);
939        return DRM_NO_ERROR;
940    }
941
942    case PROCESS_DRM_INFO:
943    {
944        ALOGV("BnDrmManagerService::onTransact :PROCESS_DRM_INFO");
945        CHECK_INTERFACE(IDrmManagerService, data, reply);
946
947        const int uniqueId = data.readInt32();
948
949        //Filling DRM info
950        const int infoType = data.readInt32();
951        const int bufferSize = data.readInt32();
952        char* buffer = NULL;
953        if (0 < bufferSize) {
954            buffer = (char *)data.readInplace(bufferSize);
955        }
956        const DrmBuffer drmBuffer(buffer, bufferSize);
957        DrmInfo* drmInfo = new DrmInfo(infoType, drmBuffer, data.readString8());
958
959        const int size = data.readInt32();
960        for (int index = 0; index < size; ++index) {
961            const String8 key(data.readString8());
962            const String8 value(data.readString8());
963            drmInfo->put(key, (value == String8("NULL")) ? String8("") : value);
964        }
965
966        DrmInfoStatus* drmInfoStatus = processDrmInfo(uniqueId, drmInfo);
967
968        if (NULL != drmInfoStatus) {
969            //Filling DRM Info Status contents
970            reply->writeInt32(drmInfoStatus->statusCode);
971            reply->writeInt32(drmInfoStatus->infoType);
972            reply->writeString8(drmInfoStatus->mimeType);
973
974            if (NULL != drmInfoStatus->drmBuffer) {
975                const DrmBuffer* drmBuffer = drmInfoStatus->drmBuffer;
976                const int bufferSize = drmBuffer->length;
977                reply->writeInt32(bufferSize);
978                if (0 < bufferSize) {
979                    reply->write(drmBuffer->data, bufferSize);
980                }
981                delete [] drmBuffer->data;
982                delete drmBuffer; drmBuffer = NULL;
983            }
984        }
985        delete drmInfo; drmInfo = NULL;
986        delete drmInfoStatus; drmInfoStatus = NULL;
987        return DRM_NO_ERROR;
988    }
989
990    case ACQUIRE_DRM_INFO:
991    {
992        ALOGV("BnDrmManagerService::onTransact :ACQUIRE_DRM_INFO");
993        CHECK_INTERFACE(IDrmManagerService, data, reply);
994
995        const int uniqueId = data.readInt32();
996
997        //Filling DRM info Request
998        const int infoType = data.readInt32();
999        const String8 mimeType = data.readString8();
1000        DrmInfoRequest* drmInfoRequest = new DrmInfoRequest(infoType, mimeType);
1001
1002        const int size = data.readInt32();
1003        for (int index = 0; index < size; ++index) {
1004            const String8 key(data.readString8());
1005            const String8 value(data.readString8());
1006            drmInfoRequest->put(key, (value == String8("NULL")) ? String8("") : value);
1007        }
1008
1009        DrmInfo* drmInfo = acquireDrmInfo(uniqueId, drmInfoRequest);
1010
1011        if (NULL != drmInfo) {
1012            //Filling DRM Info
1013            const DrmBuffer drmBuffer = drmInfo->getData();
1014            reply->writeInt32(drmInfo->getInfoType());
1015
1016            const int bufferSize = drmBuffer.length;
1017            reply->writeInt32(bufferSize);
1018            if (0 < bufferSize) {
1019                reply->write(drmBuffer.data, bufferSize);
1020            }
1021            reply->writeString8(drmInfo->getMimeType());
1022            reply->writeInt32(drmInfo->getCount());
1023
1024            DrmInfo::KeyIterator keyIt = drmInfo->keyIterator();
1025            while (keyIt.hasNext()) {
1026                const String8 key = keyIt.next();
1027                reply->writeString8(key);
1028                const String8 value = drmInfo->get(key);
1029                reply->writeString8((value == String8("")) ? String8("NULL") : value);
1030            }
1031            delete [] drmBuffer.data;
1032        }
1033        delete drmInfoRequest; drmInfoRequest = NULL;
1034        delete drmInfo; drmInfo = NULL;
1035        return DRM_NO_ERROR;
1036    }
1037
1038    case SAVE_RIGHTS:
1039    {
1040        ALOGV("BnDrmManagerService::onTransact :SAVE_RIGHTS");
1041        CHECK_INTERFACE(IDrmManagerService, data, reply);
1042
1043        const int uniqueId = data.readInt32();
1044
1045        //Filling DRM Rights
1046        const int bufferSize = data.readInt32();
1047        const DrmBuffer drmBuffer((char *)data.readInplace(bufferSize), bufferSize);
1048
1049        const String8 mimeType(data.readString8());
1050        const String8 accountId(data.readString8());
1051        const String8 subscriptionId(data.readString8());
1052        const String8 rightsPath(data.readString8());
1053        const String8 contentPath(data.readString8());
1054
1055        DrmRights drmRights(drmBuffer,
1056                            ((mimeType == String8("NULL")) ? String8("") : mimeType),
1057                            ((accountId == String8("NULL")) ? String8("") : accountId),
1058                            ((subscriptionId == String8("NULL")) ? String8("") : subscriptionId));
1059
1060        const status_t status = saveRights(uniqueId, drmRights,
1061                            ((rightsPath == String8("NULL")) ? String8("") : rightsPath),
1062                            ((contentPath == String8("NULL")) ? String8("") : contentPath));
1063
1064        reply->writeInt32(status);
1065        return DRM_NO_ERROR;
1066    }
1067
1068    case GET_ORIGINAL_MIMETYPE:
1069    {
1070        ALOGV("BnDrmManagerService::onTransact :GET_ORIGINAL_MIMETYPE");
1071        CHECK_INTERFACE(IDrmManagerService, data, reply);
1072
1073        const int uniqueId = data.readInt32();
1074        const String8 path = data.readString8();
1075        const int32_t isFdValid = data.readInt32();
1076        int fd = -1;
1077        if (isFdValid) {
1078            fd = data.readFileDescriptor();
1079        }
1080        const String8 originalMimeType = getOriginalMimeType(uniqueId, path, fd);
1081
1082        reply->writeString8(originalMimeType);
1083        return DRM_NO_ERROR;
1084    }
1085
1086    case GET_DRM_OBJECT_TYPE:
1087    {
1088        ALOGV("BnDrmManagerService::onTransact :GET_DRM_OBJECT_TYPE");
1089        CHECK_INTERFACE(IDrmManagerService, data, reply);
1090
1091        const int uniqueId = data.readInt32();
1092        const String8 path = data.readString8();
1093        const String8 mimeType = data.readString8();
1094        const int drmObjectType = getDrmObjectType(uniqueId, path, mimeType);
1095
1096        reply->writeInt32(drmObjectType);
1097        return DRM_NO_ERROR;
1098    }
1099
1100    case CHECK_RIGHTS_STATUS:
1101    {
1102        ALOGV("BnDrmManagerService::onTransact :CHECK_RIGHTS_STATUS");
1103        CHECK_INTERFACE(IDrmManagerService, data, reply);
1104
1105        const int uniqueId = data.readInt32();
1106        const String8 path = data.readString8();
1107        const int action = data.readInt32();
1108        const int result = checkRightsStatus(uniqueId, path, action);
1109
1110        reply->writeInt32(result);
1111        return DRM_NO_ERROR;
1112    }
1113
1114    case CONSUME_RIGHTS:
1115    {
1116        ALOGV("BnDrmManagerService::onTransact :CONSUME_RIGHTS");
1117        CHECK_INTERFACE(IDrmManagerService, data, reply);
1118
1119        const int uniqueId = data.readInt32();
1120
1121        DecryptHandle handle;
1122        readDecryptHandleFromParcelData(&handle, data);
1123
1124        const int action = data.readInt32();
1125        const bool reserve = static_cast<bool>(data.readInt32());
1126        const status_t status
1127            = consumeRights(uniqueId, &handle, action, reserve);
1128        reply->writeInt32(status);
1129
1130        clearDecryptHandle(&handle);
1131        return DRM_NO_ERROR;
1132    }
1133
1134    case SET_PLAYBACK_STATUS:
1135    {
1136        ALOGV("BnDrmManagerService::onTransact :SET_PLAYBACK_STATUS");
1137        CHECK_INTERFACE(IDrmManagerService, data, reply);
1138
1139        const int uniqueId = data.readInt32();
1140
1141        DecryptHandle handle;
1142        readDecryptHandleFromParcelData(&handle, data);
1143
1144        const int playbackStatus = data.readInt32();
1145        const int64_t position = data.readInt64();
1146        const status_t status
1147            = setPlaybackStatus(uniqueId, &handle, playbackStatus, position);
1148        reply->writeInt32(status);
1149
1150        clearDecryptHandle(&handle);
1151        return DRM_NO_ERROR;
1152    }
1153
1154    case VALIDATE_ACTION:
1155    {
1156        ALOGV("BnDrmManagerService::onTransact :VALIDATE_ACTION");
1157        CHECK_INTERFACE(IDrmManagerService, data, reply);
1158
1159        const int uniqueId = data.readInt32();
1160        const String8 path = data.readString8();
1161        const int action = data.readInt32();
1162        const int outputType = data.readInt32();
1163        const int configuration = data.readInt32();
1164        bool result = validateAction(uniqueId, path, action,
1165                ActionDescription(outputType, configuration));
1166
1167        reply->writeInt32(result);
1168        return DRM_NO_ERROR;
1169    }
1170
1171    case REMOVE_RIGHTS:
1172    {
1173        ALOGV("BnDrmManagerService::onTransact :REMOVE_RIGHTS");
1174        CHECK_INTERFACE(IDrmManagerService, data, reply);
1175
1176        int uniqueId = data.readInt32();
1177        String8 path = data.readString8();
1178        const status_t status = removeRights(uniqueId, path);
1179        reply->writeInt32(status);
1180
1181        return DRM_NO_ERROR;
1182    }
1183
1184    case REMOVE_ALL_RIGHTS:
1185    {
1186        ALOGV("BnDrmManagerService::onTransact :REMOVE_ALL_RIGHTS");
1187        CHECK_INTERFACE(IDrmManagerService, data, reply);
1188
1189        const status_t status = removeAllRights(data.readInt32());
1190        reply->writeInt32(status);
1191
1192        return DRM_NO_ERROR;
1193    }
1194
1195    case OPEN_CONVERT_SESSION:
1196    {
1197        ALOGV("BnDrmManagerService::onTransact :OPEN_CONVERT_SESSION");
1198        CHECK_INTERFACE(IDrmManagerService, data, reply);
1199
1200        const int uniqueId = data.readInt32();
1201        const String8 mimeType = data.readString8();
1202        const int convertId = openConvertSession(uniqueId, mimeType);
1203
1204        reply->writeInt32(convertId);
1205        return DRM_NO_ERROR;
1206    }
1207
1208    case CONVERT_DATA:
1209    {
1210        ALOGV("BnDrmManagerService::onTransact :CONVERT_DATA");
1211        CHECK_INTERFACE(IDrmManagerService, data, reply);
1212
1213        const int uniqueId = data.readInt32();
1214        const int convertId = data.readInt32();
1215
1216        //Filling input data
1217        const int bufferSize = data.readInt32();
1218        DrmBuffer* inputData = new DrmBuffer((char *)data.readInplace(bufferSize), bufferSize);
1219
1220        DrmConvertedStatus*    drmConvertedStatus = convertData(uniqueId, convertId, inputData);
1221
1222        if (NULL != drmConvertedStatus) {
1223            //Filling Drm Converted Ststus
1224            reply->writeInt32(drmConvertedStatus->statusCode);
1225            reply->writeInt64(drmConvertedStatus->offset);
1226
1227            if (NULL != drmConvertedStatus->convertedData) {
1228                const DrmBuffer* convertedData = drmConvertedStatus->convertedData;
1229                const int bufferSize = convertedData->length;
1230                reply->writeInt32(bufferSize);
1231                if (0 < bufferSize) {
1232                    reply->write(convertedData->data, bufferSize);
1233                }
1234                delete [] convertedData->data;
1235                delete convertedData; convertedData = NULL;
1236            }
1237        }
1238        delete inputData; inputData = NULL;
1239        delete drmConvertedStatus; drmConvertedStatus = NULL;
1240        return DRM_NO_ERROR;
1241    }
1242
1243    case CLOSE_CONVERT_SESSION:
1244    {
1245        ALOGV("BnDrmManagerService::onTransact :CLOSE_CONVERT_SESSION");
1246        CHECK_INTERFACE(IDrmManagerService, data, reply);
1247
1248        const int uniqueId = data.readInt32();
1249        const int convertId = data.readInt32();
1250        DrmConvertedStatus* drmConvertedStatus
1251            = closeConvertSession(uniqueId, convertId);
1252
1253        if (NULL != drmConvertedStatus) {
1254            //Filling Drm Converted Ststus
1255            reply->writeInt32(drmConvertedStatus->statusCode);
1256            reply->writeInt64(drmConvertedStatus->offset);
1257
1258            if (NULL != drmConvertedStatus->convertedData) {
1259                const DrmBuffer* convertedData = drmConvertedStatus->convertedData;
1260                const int bufferSize = convertedData->length;
1261                reply->writeInt32(bufferSize);
1262                if (0 < bufferSize) {
1263                    reply->write(convertedData->data, bufferSize);
1264                }
1265                delete [] convertedData->data;
1266                delete convertedData; convertedData = NULL;
1267            }
1268        }
1269        delete drmConvertedStatus; drmConvertedStatus = NULL;
1270        return DRM_NO_ERROR;
1271    }
1272
1273    case GET_ALL_SUPPORT_INFO:
1274    {
1275        ALOGV("BnDrmManagerService::onTransact :GET_ALL_SUPPORT_INFO");
1276        CHECK_INTERFACE(IDrmManagerService, data, reply);
1277
1278        const int uniqueId = data.readInt32();
1279        int length = 0;
1280        DrmSupportInfo* drmSupportInfoArray = NULL;
1281
1282        status_t status = getAllSupportInfo(uniqueId, &length, &drmSupportInfoArray);
1283
1284        reply->writeInt32(length);
1285        for (int i = 0; i < length; ++i) {
1286            DrmSupportInfo drmSupportInfo = drmSupportInfoArray[i];
1287
1288            reply->writeInt32(drmSupportInfo.getFileSuffixCount());
1289            DrmSupportInfo::FileSuffixIterator fileSuffixIt
1290                = drmSupportInfo.getFileSuffixIterator();
1291            while (fileSuffixIt.hasNext()) {
1292                reply->writeString8(fileSuffixIt.next());
1293            }
1294
1295            reply->writeInt32(drmSupportInfo.getMimeTypeCount());
1296            DrmSupportInfo::MimeTypeIterator mimeTypeIt = drmSupportInfo.getMimeTypeIterator();
1297            while (mimeTypeIt.hasNext()) {
1298                reply->writeString8(mimeTypeIt.next());
1299            }
1300            reply->writeString8(drmSupportInfo.getDescription());
1301        }
1302        delete [] drmSupportInfoArray; drmSupportInfoArray = NULL;
1303        reply->writeInt32(status);
1304        return DRM_NO_ERROR;
1305    }
1306
1307    case OPEN_DECRYPT_SESSION:
1308    {
1309        ALOGV("BnDrmManagerService::onTransact :OPEN_DECRYPT_SESSION");
1310        CHECK_INTERFACE(IDrmManagerService, data, reply);
1311
1312        const int uniqueId = data.readInt32();
1313        const int fd = data.readFileDescriptor();
1314
1315        const off64_t offset = data.readInt64();
1316        const off64_t length = data.readInt64();
1317        const String8 mime = data.readString8();
1318
1319        DecryptHandle* handle
1320            = openDecryptSession(uniqueId, fd, offset, length, mime.string());
1321
1322        if (NULL != handle) {
1323            writeDecryptHandleToParcelData(handle, reply);
1324            clearDecryptHandle(handle);
1325            delete handle; handle = NULL;
1326        }
1327        return DRM_NO_ERROR;
1328    }
1329
1330    case OPEN_DECRYPT_SESSION_FROM_URI:
1331    {
1332        ALOGV("BnDrmManagerService::onTransact :OPEN_DECRYPT_SESSION_FROM_URI");
1333        CHECK_INTERFACE(IDrmManagerService, data, reply);
1334
1335        const int uniqueId = data.readInt32();
1336        const String8 uri = data.readString8();
1337        const String8 mime = data.readString8();
1338
1339        DecryptHandle* handle = openDecryptSession(uniqueId, uri.string(), mime.string());
1340
1341        if (NULL != handle) {
1342            writeDecryptHandleToParcelData(handle, reply);
1343
1344            clearDecryptHandle(handle);
1345            delete handle; handle = NULL;
1346        } else {
1347            ALOGV("NULL decryptHandle is returned");
1348        }
1349        return DRM_NO_ERROR;
1350    }
1351
1352    case OPEN_DECRYPT_SESSION_FOR_STREAMING:
1353    {
1354        ALOGV("BnDrmManagerService::onTransact :OPEN_DECRYPT_SESSION_FOR_STREAMING");
1355        CHECK_INTERFACE(IDrmManagerService, data, reply);
1356
1357        const int uniqueId = data.readInt32();
1358        const int bufferSize = data.readInt32();
1359        DrmBuffer buf((bufferSize > 0) ? (char *)data.readInplace(bufferSize) : NULL,
1360                bufferSize);
1361        const String8 mimeType(data.readString8());
1362
1363        DecryptHandle* handle = openDecryptSession(uniqueId, buf, mimeType);
1364
1365        if (handle != NULL) {
1366            writeDecryptHandleToParcelData(handle, reply);
1367            clearDecryptHandle(handle);
1368            delete handle;
1369            handle = NULL;
1370        } else {
1371            ALOGV("NULL decryptHandle is returned");
1372        }
1373        return DRM_NO_ERROR;
1374    }
1375
1376    case CLOSE_DECRYPT_SESSION:
1377    {
1378        ALOGV("BnDrmManagerService::onTransact :CLOSE_DECRYPT_SESSION");
1379        CHECK_INTERFACE(IDrmManagerService, data, reply);
1380
1381        const int uniqueId = data.readInt32();
1382
1383        DecryptHandle* handle = new DecryptHandle();
1384        readDecryptHandleFromParcelData(handle, data);
1385
1386        const status_t status = closeDecryptSession(uniqueId, handle);
1387        reply->writeInt32(status);
1388        return DRM_NO_ERROR;
1389    }
1390
1391    case INITIALIZE_DECRYPT_UNIT:
1392    {
1393        ALOGV("BnDrmManagerService::onTransact :INITIALIZE_DECRYPT_UNIT");
1394        CHECK_INTERFACE(IDrmManagerService, data, reply);
1395
1396        const int uniqueId = data.readInt32();
1397
1398        DecryptHandle handle;
1399        readDecryptHandleFromParcelData(&handle, data);
1400
1401        const int decryptUnitId = data.readInt32();
1402
1403        //Filling Header info
1404        const int bufferSize = data.readInt32();
1405        DrmBuffer* headerInfo = NULL;
1406        headerInfo = new DrmBuffer((char *)data.readInplace(bufferSize), bufferSize);
1407
1408        const status_t status
1409            = initializeDecryptUnit(uniqueId, &handle, decryptUnitId, headerInfo);
1410        reply->writeInt32(status);
1411
1412        clearDecryptHandle(&handle);
1413        delete headerInfo; headerInfo = NULL;
1414        return DRM_NO_ERROR;
1415    }
1416
1417    case DECRYPT:
1418    {
1419        ALOGV("BnDrmManagerService::onTransact :DECRYPT");
1420        CHECK_INTERFACE(IDrmManagerService, data, reply);
1421
1422        const int uniqueId = data.readInt32();
1423
1424        DecryptHandle handle;
1425        readDecryptHandleFromParcelData(&handle, data);
1426
1427        const int decryptUnitId = data.readInt32();
1428        const int decBufferSize = data.readInt32();
1429
1430        const int encBufferSize = data.readInt32();
1431        DrmBuffer* encBuffer
1432            = new DrmBuffer((char *)data.readInplace(encBufferSize), encBufferSize);
1433
1434        char* buffer = NULL;
1435        buffer = new char[decBufferSize];
1436        DrmBuffer* decBuffer = new DrmBuffer(buffer, decBufferSize);
1437
1438        DrmBuffer* IV = NULL;
1439        if (0 != data.dataAvail()) {
1440            const int ivBufferlength = data.readInt32();
1441            IV = new DrmBuffer((char *)data.readInplace(ivBufferlength), ivBufferlength);
1442        }
1443
1444        const status_t status
1445            = decrypt(uniqueId, &handle, decryptUnitId, encBuffer, &decBuffer, IV);
1446
1447        reply->writeInt32(status);
1448
1449        const int size = decBuffer->length;
1450        reply->writeInt32(size);
1451        reply->write(decBuffer->data, size);
1452
1453        clearDecryptHandle(&handle);
1454        delete encBuffer; encBuffer = NULL;
1455        delete decBuffer; decBuffer = NULL;
1456        delete [] buffer; buffer = NULL;
1457        delete IV; IV = NULL;
1458        return DRM_NO_ERROR;
1459    }
1460
1461    case FINALIZE_DECRYPT_UNIT:
1462    {
1463        ALOGV("BnDrmManagerService::onTransact :FINALIZE_DECRYPT_UNIT");
1464        CHECK_INTERFACE(IDrmManagerService, data, reply);
1465
1466        const int uniqueId = data.readInt32();
1467
1468        DecryptHandle handle;
1469        readDecryptHandleFromParcelData(&handle, data);
1470
1471        const status_t status = finalizeDecryptUnit(uniqueId, &handle, data.readInt32());
1472        reply->writeInt32(status);
1473
1474        clearDecryptHandle(&handle);
1475        return DRM_NO_ERROR;
1476    }
1477
1478    case PREAD:
1479    {
1480        ALOGV("BnDrmManagerService::onTransact :READ");
1481        CHECK_INTERFACE(IDrmManagerService, data, reply);
1482
1483        const int uniqueId = data.readInt32();
1484
1485        DecryptHandle handle;
1486        readDecryptHandleFromParcelData(&handle, data);
1487
1488        const int numBytes = data.readInt32();
1489        char* buffer = new char[numBytes];
1490
1491        const off64_t offset = data.readInt64();
1492
1493        ssize_t result = pread(uniqueId, &handle, buffer, numBytes, offset);
1494        reply->writeInt32(result);
1495        if (0 < result) {
1496            reply->write(buffer, result);
1497        }
1498
1499        clearDecryptHandle(&handle);
1500        delete [] buffer, buffer = NULL;
1501        return DRM_NO_ERROR;
1502    }
1503
1504    default:
1505        return BBinder::onTransact(code, data, reply, flags);
1506    }
1507}
1508
1509