IDrmManagerService.cpp revision cba7b32d8f2c47632313f54118ed3733b4b02cc8 
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) {
372    ALOGV("Get Original MimeType");
373    Parcel data, reply;
374
375    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
376    data.writeInt32(uniqueId);
377    data.writeString8(path);
378
379    remote()->transact(GET_ORIGINAL_MIMETYPE, data, &reply);
380    return reply.readString8();
381}
382
383int BpDrmManagerService::getDrmObjectType(
384            int uniqueId, const String8& path, const String8& mimeType) {
385    ALOGV("Get Drm object type");
386    Parcel data, reply;
387
388    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
389    data.writeInt32(uniqueId);
390    data.writeString8(path);
391    data.writeString8(mimeType);
392
393    remote()->transact(GET_DRM_OBJECT_TYPE, data, &reply);
394
395    return reply.readInt32();
396}
397
398int BpDrmManagerService::checkRightsStatus(int uniqueId, const String8& path, int action) {
399    ALOGV("checkRightsStatus");
400    Parcel data, reply;
401
402    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
403    data.writeInt32(uniqueId);
404    data.writeString8(path);
405    data.writeInt32(action);
406
407    remote()->transact(CHECK_RIGHTS_STATUS, data, &reply);
408
409    return reply.readInt32();
410}
411
412status_t BpDrmManagerService::consumeRights(
413            int uniqueId, DecryptHandle* decryptHandle, int action, bool reserve) {
414    ALOGV("consumeRights");
415    Parcel data, reply;
416
417    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
418    data.writeInt32(uniqueId);
419
420    writeDecryptHandleToParcelData(decryptHandle, &data);
421
422    data.writeInt32(action);
423    data.writeInt32(static_cast< int>(reserve));
424
425    remote()->transact(CONSUME_RIGHTS, data, &reply);
426    return reply.readInt32();
427}
428
429status_t BpDrmManagerService::setPlaybackStatus(
430            int uniqueId, DecryptHandle* decryptHandle, int playbackStatus, int64_t position) {
431    ALOGV("setPlaybackStatus");
432    Parcel data, reply;
433
434    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
435    data.writeInt32(uniqueId);
436
437    writeDecryptHandleToParcelData(decryptHandle, &data);
438
439    data.writeInt32(playbackStatus);
440    data.writeInt64(position);
441
442    remote()->transact(SET_PLAYBACK_STATUS, data, &reply);
443    return reply.readInt32();
444}
445
446bool BpDrmManagerService::validateAction(
447            int uniqueId, const String8& path,
448            int action, const ActionDescription& description) {
449    ALOGV("validateAction");
450    Parcel data, reply;
451
452    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
453    data.writeInt32(uniqueId);
454    data.writeString8(path);
455    data.writeInt32(action);
456    data.writeInt32(description.outputType);
457    data.writeInt32(description.configuration);
458
459    remote()->transact(VALIDATE_ACTION, data, &reply);
460
461    return static_cast<bool>(reply.readInt32());
462}
463
464status_t BpDrmManagerService::removeRights(int uniqueId, const String8& path) {
465    ALOGV("removeRights");
466    Parcel data, reply;
467
468    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
469    data.writeInt32(uniqueId);
470    data.writeString8(path);
471
472    remote()->transact(REMOVE_RIGHTS, data, &reply);
473    return reply.readInt32();
474}
475
476status_t BpDrmManagerService::removeAllRights(int uniqueId) {
477    ALOGV("removeAllRights");
478    Parcel data, reply;
479
480    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
481    data.writeInt32(uniqueId);
482
483    remote()->transact(REMOVE_ALL_RIGHTS, data, &reply);
484    return reply.readInt32();
485}
486
487int BpDrmManagerService::openConvertSession(int uniqueId, const String8& mimeType) {
488    ALOGV("openConvertSession");
489    Parcel data, reply;
490
491    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
492    data.writeInt32(uniqueId);
493    data.writeString8(mimeType);
494
495    remote()->transact(OPEN_CONVERT_SESSION, data, &reply);
496    return reply.readInt32();
497}
498
499DrmConvertedStatus* BpDrmManagerService::convertData(
500            int uniqueId, int convertId, const DrmBuffer* inputData) {
501    ALOGV("convertData");
502    Parcel data, reply;
503
504    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
505    data.writeInt32(uniqueId);
506    data.writeInt32(convertId);
507    data.writeInt32(inputData->length);
508    data.write(inputData->data, inputData->length);
509
510    remote()->transact(CONVERT_DATA, data, &reply);
511
512    DrmConvertedStatus* drmConvertedStatus = NULL;
513
514    if (0 != reply.dataAvail()) {
515        //Filling DRM Converted Status
516        const int statusCode = reply.readInt32();
517        const off64_t offset = reply.readInt64();
518
519        DrmBuffer* convertedData = NULL;
520        if (0 != reply.dataAvail()) {
521            const int bufferSize = reply.readInt32();
522            char* data = NULL;
523            if (0 < bufferSize) {
524                data = new char[bufferSize];
525                reply.read(data, bufferSize);
526            }
527            convertedData = new DrmBuffer(data, bufferSize);
528        }
529        drmConvertedStatus = new DrmConvertedStatus(statusCode, convertedData, offset);
530    }
531    return drmConvertedStatus;
532}
533
534DrmConvertedStatus* BpDrmManagerService::closeConvertSession(int uniqueId, int convertId) {
535    ALOGV("closeConvertSession");
536    Parcel data, reply;
537
538    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
539    data.writeInt32(uniqueId);
540    data.writeInt32(convertId);
541
542    remote()->transact(CLOSE_CONVERT_SESSION, data, &reply);
543
544    DrmConvertedStatus* drmConvertedStatus = NULL;
545
546    if (0 != reply.dataAvail()) {
547        //Filling DRM Converted Status
548        const int statusCode = reply.readInt32();
549        const off64_t offset = reply.readInt64();
550
551        DrmBuffer* convertedData = NULL;
552        if (0 != reply.dataAvail()) {
553            const int bufferSize = reply.readInt32();
554            char* data = NULL;
555            if (0 < bufferSize) {
556                data = new char[bufferSize];
557                reply.read(data, bufferSize);
558            }
559            convertedData = new DrmBuffer(data, bufferSize);
560        }
561        drmConvertedStatus = new DrmConvertedStatus(statusCode, convertedData, offset);
562    }
563    return drmConvertedStatus;
564}
565
566status_t BpDrmManagerService::getAllSupportInfo(
567            int uniqueId, int* length, DrmSupportInfo** drmSupportInfoArray) {
568    ALOGV("Get All Support Info");
569    Parcel data, reply;
570
571    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
572    data.writeInt32(uniqueId);
573
574    remote()->transact(GET_ALL_SUPPORT_INFO, data, &reply);
575
576    //Filling DRM Support Info
577    const int arraySize = reply.readInt32();
578    if (0 < arraySize) {
579        *drmSupportInfoArray = new DrmSupportInfo[arraySize];
580
581        for (int index = 0; index < arraySize; ++index) {
582            DrmSupportInfo drmSupportInfo;
583
584            const int fileSuffixVectorSize = reply.readInt32();
585            for (int i = 0; i < fileSuffixVectorSize; ++i) {
586                drmSupportInfo.addFileSuffix(reply.readString8());
587            }
588
589            const int mimeTypeVectorSize = reply.readInt32();
590            for (int i = 0; i < mimeTypeVectorSize; ++i) {
591                drmSupportInfo.addMimeType(reply.readString8());
592            }
593
594            drmSupportInfo.setDescription(reply.readString8());
595            (*drmSupportInfoArray)[index] = drmSupportInfo;
596        }
597    }
598    *length = arraySize;
599    return reply.readInt32();
600}
601
602DecryptHandle* BpDrmManagerService::openDecryptSession(
603            int uniqueId, int fd, off64_t offset, off64_t length, const char* mime) {
604    ALOGV("Entering BpDrmManagerService::openDecryptSession");
605    Parcel data, reply;
606
607    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
608    data.writeInt32(uniqueId);
609    data.writeFileDescriptor(fd);
610    data.writeInt64(offset);
611    data.writeInt64(length);
612    String8 mimeType;
613    if (mime) {
614        mimeType = mime;
615    }
616    data.writeString8(mimeType);
617
618    remote()->transact(OPEN_DECRYPT_SESSION, data, &reply);
619
620    DecryptHandle* handle = NULL;
621    if (0 != reply.dataAvail()) {
622        handle = new DecryptHandle();
623        readDecryptHandleFromParcelData(handle, reply);
624    }
625    return handle;
626}
627
628DecryptHandle* BpDrmManagerService::openDecryptSession(
629        int uniqueId, const char* uri, const char* mime) {
630
631    ALOGV("Entering BpDrmManagerService::openDecryptSession: mime=%s", mime? mime: "NULL");
632    Parcel data, reply;
633
634    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
635    data.writeInt32(uniqueId);
636    data.writeString8(String8(uri));
637    String8 mimeType;
638    if (mime) {
639        mimeType = mime;
640    }
641    data.writeString8(mimeType);
642
643    remote()->transact(OPEN_DECRYPT_SESSION_FROM_URI, data, &reply);
644
645    DecryptHandle* handle = NULL;
646    if (0 != reply.dataAvail()) {
647        handle = new DecryptHandle();
648        readDecryptHandleFromParcelData(handle, reply);
649    } else {
650        ALOGV("no decryptHandle is generated in service side");
651    }
652    return handle;
653}
654
655DecryptHandle* BpDrmManagerService::openDecryptSession(
656            int uniqueId, const DrmBuffer& buf, const String8& mimeType) {
657    ALOGV("Entering BpDrmManagerService::openDecryptSession");
658    Parcel data, reply;
659
660    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
661    data.writeInt32(uniqueId);
662    if (buf.data != NULL && buf.length > 0) {
663        data.writeInt32(buf.length);
664        data.write(buf.data, buf.length);
665    } else {
666        data.writeInt32(0);
667    }
668    data.writeString8(mimeType);
669
670    remote()->transact(OPEN_DECRYPT_SESSION_FOR_STREAMING, data, &reply);
671
672    DecryptHandle* handle = NULL;
673    if (0 != reply.dataAvail()) {
674        handle = new DecryptHandle();
675        readDecryptHandleFromParcelData(handle, reply);
676    } else {
677        ALOGV("no decryptHandle is generated in service side");
678    }
679    return handle;
680}
681
682status_t BpDrmManagerService::closeDecryptSession(int uniqueId, DecryptHandle* decryptHandle) {
683    ALOGV("closeDecryptSession");
684    Parcel data, reply;
685
686    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
687    data.writeInt32(uniqueId);
688
689    writeDecryptHandleToParcelData(decryptHandle, &data);
690
691    remote()->transact(CLOSE_DECRYPT_SESSION, data, &reply);
692
693    return reply.readInt32();
694}
695
696status_t BpDrmManagerService::initializeDecryptUnit(
697            int uniqueId, DecryptHandle* decryptHandle,
698            int decryptUnitId, const DrmBuffer* headerInfo) {
699    ALOGV("initializeDecryptUnit");
700    Parcel data, reply;
701
702    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
703    data.writeInt32(uniqueId);
704
705    writeDecryptHandleToParcelData(decryptHandle, &data);
706
707    data.writeInt32(decryptUnitId);
708
709    data.writeInt32(headerInfo->length);
710    data.write(headerInfo->data, headerInfo->length);
711
712    remote()->transact(INITIALIZE_DECRYPT_UNIT, data, &reply);
713    return reply.readInt32();
714}
715
716status_t BpDrmManagerService::decrypt(
717            int uniqueId, DecryptHandle* decryptHandle, int decryptUnitId,
718            const DrmBuffer* encBuffer, DrmBuffer** decBuffer, DrmBuffer* IV) {
719    ALOGV("decrypt");
720    Parcel data, reply;
721
722    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
723    data.writeInt32(uniqueId);
724
725    writeDecryptHandleToParcelData(decryptHandle, &data);
726
727    data.writeInt32(decryptUnitId);
728    data.writeInt32((*decBuffer)->length);
729
730    data.writeInt32(encBuffer->length);
731    data.write(encBuffer->data, encBuffer->length);
732
733    if (NULL != IV) {
734        data.writeInt32(IV->length);
735        data.write(IV->data, IV->length);
736    }
737
738    remote()->transact(DECRYPT, data, &reply);
739
740    const status_t status = reply.readInt32();
741    ALOGV("Return value of decrypt() is %d", status);
742
743    const int size = reply.readInt32();
744    (*decBuffer)->length = size;
745    reply.read((void *)(*decBuffer)->data, size);
746
747    return status;
748}
749
750status_t BpDrmManagerService::finalizeDecryptUnit(
751            int uniqueId, DecryptHandle* decryptHandle, int decryptUnitId) {
752    ALOGV("finalizeDecryptUnit");
753    Parcel data, reply;
754
755    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
756    data.writeInt32(uniqueId);
757
758    writeDecryptHandleToParcelData(decryptHandle, &data);
759
760    data.writeInt32(decryptUnitId);
761
762    remote()->transact(FINALIZE_DECRYPT_UNIT, data, &reply);
763    return reply.readInt32();
764}
765
766ssize_t BpDrmManagerService::pread(
767            int uniqueId, DecryptHandle* decryptHandle, void* buffer,
768            ssize_t numBytes, off64_t offset) {
769    ALOGV("read");
770    Parcel data, reply;
771    int result;
772
773    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
774    data.writeInt32(uniqueId);
775
776    writeDecryptHandleToParcelData(decryptHandle, &data);
777
778    data.writeInt32(numBytes);
779    data.writeInt64(offset);
780
781    remote()->transact(PREAD, data, &reply);
782    result = reply.readInt32();
783    if (0 < result) {
784        reply.read(buffer, result);
785    }
786    return result;
787}
788
789IMPLEMENT_META_INTERFACE(DrmManagerService, "drm.IDrmManagerService");
790
791status_t BnDrmManagerService::onTransact(
792            uint32_t code, const Parcel& data,
793            Parcel* reply, uint32_t flags) {
794    ALOGV("Entering BnDrmManagerService::onTransact with code %d", code);
795
796    switch (code) {
797    case ADD_UNIQUEID:
798    {
799        ALOGV("BnDrmManagerService::onTransact :ADD_UNIQUEID");
800        CHECK_INTERFACE(IDrmManagerService, data, reply);
801        int uniqueId = addUniqueId(data.readInt32());
802        reply->writeInt32(uniqueId);
803        return DRM_NO_ERROR;
804    }
805
806    case REMOVE_UNIQUEID:
807    {
808        ALOGV("BnDrmManagerService::onTransact :REMOVE_UNIQUEID");
809        CHECK_INTERFACE(IDrmManagerService, data, reply);
810        removeUniqueId(data.readInt32());
811        return DRM_NO_ERROR;
812    }
813
814    case ADD_CLIENT:
815    {
816        ALOGV("BnDrmManagerService::onTransact :ADD_CLIENT");
817        CHECK_INTERFACE(IDrmManagerService, data, reply);
818        addClient(data.readInt32());
819        return DRM_NO_ERROR;
820    }
821
822    case REMOVE_CLIENT:
823    {
824        ALOGV("BnDrmManagerService::onTransact :REMOVE_CLIENT");
825        CHECK_INTERFACE(IDrmManagerService, data, reply);
826        removeClient(data.readInt32());
827        return DRM_NO_ERROR;
828    }
829
830    case SET_DRM_SERVICE_LISTENER:
831    {
832        ALOGV("BnDrmManagerService::onTransact :SET_DRM_SERVICE_LISTENER");
833        CHECK_INTERFACE(IDrmManagerService, data, reply);
834
835        const int uniqueId = data.readInt32();
836        const sp<IDrmServiceListener> drmServiceListener
837            = interface_cast<IDrmServiceListener> (data.readStrongBinder());
838
839        status_t status = setDrmServiceListener(uniqueId, drmServiceListener);
840
841        reply->writeInt32(status);
842        return DRM_NO_ERROR;
843    }
844
845    case INSTALL_DRM_ENGINE:
846    {
847        ALOGV("BnDrmManagerService::onTransact :INSTALL_DRM_ENGINE");
848        CHECK_INTERFACE(IDrmManagerService, data, reply);
849
850        const int uniqueId = data.readInt32();
851        const String8 engineFile = data.readString8();
852        status_t status = installDrmEngine(uniqueId, engineFile);
853
854        reply->writeInt32(status);
855        return DRM_NO_ERROR;
856    }
857
858    case GET_CONSTRAINTS_FROM_CONTENT:
859    {
860        ALOGV("BnDrmManagerService::onTransact :GET_CONSTRAINTS_FROM_CONTENT");
861        CHECK_INTERFACE(IDrmManagerService, data, reply);
862
863        const int uniqueId = data.readInt32();
864        const String8 path = data.readString8();
865
866        DrmConstraints* drmConstraints
867            = getConstraints(uniqueId, &path, data.readInt32());
868
869        if (NULL != drmConstraints) {
870            //Filling DRM Constraints contents
871            reply->writeInt32(drmConstraints->getCount());
872
873            DrmConstraints::KeyIterator keyIt = drmConstraints->keyIterator();
874            while (keyIt.hasNext()) {
875                const String8 key = keyIt.next();
876                reply->writeString8(key);
877                const char* value = drmConstraints->getAsByteArray(&key);
878                int bufferSize = 0;
879                if (NULL != value) {
880                    bufferSize = strlen(value);
881                }
882                reply->writeInt32(bufferSize + 1);
883                reply->write(value, bufferSize + 1);
884            }
885        }
886        delete drmConstraints; drmConstraints = NULL;
887        return DRM_NO_ERROR;
888    }
889
890    case GET_METADATA_FROM_CONTENT:
891    {
892        ALOGV("BnDrmManagerService::onTransact :GET_METADATA_FROM_CONTENT");
893        CHECK_INTERFACE(IDrmManagerService, data, reply);
894
895        const int uniqueId = data.readInt32();
896        const String8 path = data.readString8();
897
898        DrmMetadata* drmMetadata = getMetadata(uniqueId, &path);
899        if (NULL != drmMetadata) {
900            //Filling DRM Metadata contents
901            reply->writeInt32(drmMetadata->getCount());
902
903            DrmMetadata::KeyIterator keyIt = drmMetadata->keyIterator();
904            while (keyIt.hasNext()) {
905                const String8 key = keyIt.next();
906                reply->writeString8(key);
907                const char* value = drmMetadata->getAsByteArray(&key);
908                int bufferSize = 0;
909                if (NULL != value) {
910                    bufferSize = strlen(value);
911                    reply->writeInt32(bufferSize + 1);
912                    reply->write(value, bufferSize + 1);
913                } else {
914                    reply->writeInt32(0);
915                }
916            }
917        }
918        delete drmMetadata; drmMetadata = NULL;
919        return NO_ERROR;
920    }
921
922    case CAN_HANDLE:
923    {
924        ALOGV("BnDrmManagerService::onTransact :CAN_HANDLE");
925        CHECK_INTERFACE(IDrmManagerService, data, reply);
926
927        const int uniqueId = data.readInt32();
928        const String8 path = data.readString8();
929        const String8 mimeType = data.readString8();
930
931        bool result = canHandle(uniqueId, path, mimeType);
932
933        reply->writeInt32(result);
934        return DRM_NO_ERROR;
935    }
936
937    case PROCESS_DRM_INFO:
938    {
939        ALOGV("BnDrmManagerService::onTransact :PROCESS_DRM_INFO");
940        CHECK_INTERFACE(IDrmManagerService, data, reply);
941
942        const int uniqueId = data.readInt32();
943
944        //Filling DRM info
945        const int infoType = data.readInt32();
946        const int bufferSize = data.readInt32();
947        char* buffer = NULL;
948        if (0 < bufferSize) {
949            buffer = (char *)data.readInplace(bufferSize);
950        }
951        const DrmBuffer drmBuffer(buffer, bufferSize);
952        DrmInfo* drmInfo = new DrmInfo(infoType, drmBuffer, data.readString8());
953
954        const int size = data.readInt32();
955        for (int index = 0; index < size; ++index) {
956            const String8 key(data.readString8());
957            const String8 value(data.readString8());
958            drmInfo->put(key, (value == String8("NULL")) ? String8("") : value);
959        }
960
961        DrmInfoStatus* drmInfoStatus = processDrmInfo(uniqueId, drmInfo);
962
963        if (NULL != drmInfoStatus) {
964            //Filling DRM Info Status contents
965            reply->writeInt32(drmInfoStatus->statusCode);
966            reply->writeInt32(drmInfoStatus->infoType);
967            reply->writeString8(drmInfoStatus->mimeType);
968
969            if (NULL != drmInfoStatus->drmBuffer) {
970                const DrmBuffer* drmBuffer = drmInfoStatus->drmBuffer;
971                const int bufferSize = drmBuffer->length;
972                reply->writeInt32(bufferSize);
973                if (0 < bufferSize) {
974                    reply->write(drmBuffer->data, bufferSize);
975                }
976                delete [] drmBuffer->data;
977                delete drmBuffer; drmBuffer = NULL;
978            }
979        }
980        delete drmInfo; drmInfo = NULL;
981        delete drmInfoStatus; drmInfoStatus = NULL;
982        return DRM_NO_ERROR;
983    }
984
985    case ACQUIRE_DRM_INFO:
986    {
987        ALOGV("BnDrmManagerService::onTransact :ACQUIRE_DRM_INFO");
988        CHECK_INTERFACE(IDrmManagerService, data, reply);
989
990        const int uniqueId = data.readInt32();
991
992        //Filling DRM info Request
993        const int infoType = data.readInt32();
994        const String8 mimeType = data.readString8();
995        DrmInfoRequest* drmInfoRequest = new DrmInfoRequest(infoType, mimeType);
996
997        const int size = data.readInt32();
998        for (int index = 0; index < size; ++index) {
999            const String8 key(data.readString8());
1000            const String8 value(data.readString8());
1001            drmInfoRequest->put(key, (value == String8("NULL")) ? String8("") : value);
1002        }
1003
1004        DrmInfo* drmInfo = acquireDrmInfo(uniqueId, drmInfoRequest);
1005
1006        if (NULL != drmInfo) {
1007            //Filling DRM Info
1008            const DrmBuffer drmBuffer = drmInfo->getData();
1009            reply->writeInt32(drmInfo->getInfoType());
1010
1011            const int bufferSize = drmBuffer.length;
1012            reply->writeInt32(bufferSize);
1013            if (0 < bufferSize) {
1014                reply->write(drmBuffer.data, bufferSize);
1015            }
1016            reply->writeString8(drmInfo->getMimeType());
1017            reply->writeInt32(drmInfo->getCount());
1018
1019            DrmInfo::KeyIterator keyIt = drmInfo->keyIterator();
1020            while (keyIt.hasNext()) {
1021                const String8 key = keyIt.next();
1022                reply->writeString8(key);
1023                const String8 value = drmInfo->get(key);
1024                reply->writeString8((value == String8("")) ? String8("NULL") : value);
1025            }
1026            delete [] drmBuffer.data;
1027        }
1028        delete drmInfoRequest; drmInfoRequest = NULL;
1029        delete drmInfo; drmInfo = NULL;
1030        return DRM_NO_ERROR;
1031    }
1032
1033    case SAVE_RIGHTS:
1034    {
1035        ALOGV("BnDrmManagerService::onTransact :SAVE_RIGHTS");
1036        CHECK_INTERFACE(IDrmManagerService, data, reply);
1037
1038        const int uniqueId = data.readInt32();
1039
1040        //Filling DRM Rights
1041        const int bufferSize = data.readInt32();
1042        const DrmBuffer drmBuffer((char *)data.readInplace(bufferSize), bufferSize);
1043
1044        const String8 mimeType(data.readString8());
1045        const String8 accountId(data.readString8());
1046        const String8 subscriptionId(data.readString8());
1047        const String8 rightsPath(data.readString8());
1048        const String8 contentPath(data.readString8());
1049
1050        DrmRights drmRights(drmBuffer,
1051                            ((mimeType == String8("NULL")) ? String8("") : mimeType),
1052                            ((accountId == String8("NULL")) ? String8("") : accountId),
1053                            ((subscriptionId == String8("NULL")) ? String8("") : subscriptionId));
1054
1055        const status_t status = saveRights(uniqueId, drmRights,
1056                            ((rightsPath == String8("NULL")) ? String8("") : rightsPath),
1057                            ((contentPath == String8("NULL")) ? String8("") : contentPath));
1058
1059        reply->writeInt32(status);
1060        return DRM_NO_ERROR;
1061    }
1062
1063    case GET_ORIGINAL_MIMETYPE:
1064    {
1065        ALOGV("BnDrmManagerService::onTransact :GET_ORIGINAL_MIMETYPE");
1066        CHECK_INTERFACE(IDrmManagerService, data, reply);
1067
1068        const int uniqueId = data.readInt32();
1069        const String8 path = data.readString8();
1070        const String8 originalMimeType = getOriginalMimeType(uniqueId, path);
1071
1072        reply->writeString8(originalMimeType);
1073        return DRM_NO_ERROR;
1074    }
1075
1076    case GET_DRM_OBJECT_TYPE:
1077    {
1078        ALOGV("BnDrmManagerService::onTransact :GET_DRM_OBJECT_TYPE");
1079        CHECK_INTERFACE(IDrmManagerService, data, reply);
1080
1081        const int uniqueId = data.readInt32();
1082        const String8 path = data.readString8();
1083        const String8 mimeType = data.readString8();
1084        const int drmObjectType = getDrmObjectType(uniqueId, path, mimeType);
1085
1086        reply->writeInt32(drmObjectType);
1087        return DRM_NO_ERROR;
1088    }
1089
1090    case CHECK_RIGHTS_STATUS:
1091    {
1092        ALOGV("BnDrmManagerService::onTransact :CHECK_RIGHTS_STATUS");
1093        CHECK_INTERFACE(IDrmManagerService, data, reply);
1094
1095        const int uniqueId = data.readInt32();
1096        const String8 path = data.readString8();
1097        const int action = data.readInt32();
1098        const int result = checkRightsStatus(uniqueId, path, action);
1099
1100        reply->writeInt32(result);
1101        return DRM_NO_ERROR;
1102    }
1103
1104    case CONSUME_RIGHTS:
1105    {
1106        ALOGV("BnDrmManagerService::onTransact :CONSUME_RIGHTS");
1107        CHECK_INTERFACE(IDrmManagerService, data, reply);
1108
1109        const int uniqueId = data.readInt32();
1110
1111        DecryptHandle handle;
1112        readDecryptHandleFromParcelData(&handle, data);
1113
1114        const int action = data.readInt32();
1115        const bool reserve = static_cast<bool>(data.readInt32());
1116        const status_t status
1117            = consumeRights(uniqueId, &handle, action, reserve);
1118        reply->writeInt32(status);
1119
1120        clearDecryptHandle(&handle);
1121        return DRM_NO_ERROR;
1122    }
1123
1124    case SET_PLAYBACK_STATUS:
1125    {
1126        ALOGV("BnDrmManagerService::onTransact :SET_PLAYBACK_STATUS");
1127        CHECK_INTERFACE(IDrmManagerService, data, reply);
1128
1129        const int uniqueId = data.readInt32();
1130
1131        DecryptHandle handle;
1132        readDecryptHandleFromParcelData(&handle, data);
1133
1134        const int playbackStatus = data.readInt32();
1135        const int64_t position = data.readInt64();
1136        const status_t status
1137            = setPlaybackStatus(uniqueId, &handle, playbackStatus, position);
1138        reply->writeInt32(status);
1139
1140        clearDecryptHandle(&handle);
1141        return DRM_NO_ERROR;
1142    }
1143
1144    case VALIDATE_ACTION:
1145    {
1146        ALOGV("BnDrmManagerService::onTransact :VALIDATE_ACTION");
1147        CHECK_INTERFACE(IDrmManagerService, data, reply);
1148
1149        const int uniqueId = data.readInt32();
1150        const String8 path = data.readString8();
1151        const int action = data.readInt32();
1152        const int outputType = data.readInt32();
1153        const int configuration = data.readInt32();
1154        bool result = validateAction(uniqueId, path, action,
1155                ActionDescription(outputType, configuration));
1156
1157        reply->writeInt32(result);
1158        return DRM_NO_ERROR;
1159    }
1160
1161    case REMOVE_RIGHTS:
1162    {
1163        ALOGV("BnDrmManagerService::onTransact :REMOVE_RIGHTS");
1164        CHECK_INTERFACE(IDrmManagerService, data, reply);
1165
1166        int uniqueId = data.readInt32();
1167        String8 path = data.readString8();
1168        const status_t status = removeRights(uniqueId, path);
1169        reply->writeInt32(status);
1170
1171        return DRM_NO_ERROR;
1172    }
1173
1174    case REMOVE_ALL_RIGHTS:
1175    {
1176        ALOGV("BnDrmManagerService::onTransact :REMOVE_ALL_RIGHTS");
1177        CHECK_INTERFACE(IDrmManagerService, data, reply);
1178
1179        const status_t status = removeAllRights(data.readInt32());
1180        reply->writeInt32(status);
1181
1182        return DRM_NO_ERROR;
1183    }
1184
1185    case OPEN_CONVERT_SESSION:
1186    {
1187        ALOGV("BnDrmManagerService::onTransact :OPEN_CONVERT_SESSION");
1188        CHECK_INTERFACE(IDrmManagerService, data, reply);
1189
1190        const int uniqueId = data.readInt32();
1191        const String8 mimeType = data.readString8();
1192        const int convertId = openConvertSession(uniqueId, mimeType);
1193
1194        reply->writeInt32(convertId);
1195        return DRM_NO_ERROR;
1196    }
1197
1198    case CONVERT_DATA:
1199    {
1200        ALOGV("BnDrmManagerService::onTransact :CONVERT_DATA");
1201        CHECK_INTERFACE(IDrmManagerService, data, reply);
1202
1203        const int uniqueId = data.readInt32();
1204        const int convertId = data.readInt32();
1205
1206        //Filling input data
1207        const int bufferSize = data.readInt32();
1208        DrmBuffer* inputData = new DrmBuffer((char *)data.readInplace(bufferSize), bufferSize);
1209
1210        DrmConvertedStatus*    drmConvertedStatus = convertData(uniqueId, convertId, inputData);
1211
1212        if (NULL != drmConvertedStatus) {
1213            //Filling Drm Converted Ststus
1214            reply->writeInt32(drmConvertedStatus->statusCode);
1215            reply->writeInt64(drmConvertedStatus->offset);
1216
1217            if (NULL != drmConvertedStatus->convertedData) {
1218                const DrmBuffer* convertedData = drmConvertedStatus->convertedData;
1219                const int bufferSize = convertedData->length;
1220                reply->writeInt32(bufferSize);
1221                if (0 < bufferSize) {
1222                    reply->write(convertedData->data, bufferSize);
1223                }
1224                delete [] convertedData->data;
1225                delete convertedData; convertedData = NULL;
1226            }
1227        }
1228        delete inputData; inputData = NULL;
1229        delete drmConvertedStatus; drmConvertedStatus = NULL;
1230        return DRM_NO_ERROR;
1231    }
1232
1233    case CLOSE_CONVERT_SESSION:
1234    {
1235        ALOGV("BnDrmManagerService::onTransact :CLOSE_CONVERT_SESSION");
1236        CHECK_INTERFACE(IDrmManagerService, data, reply);
1237
1238        const int uniqueId = data.readInt32();
1239        const int convertId = data.readInt32();
1240        DrmConvertedStatus* drmConvertedStatus
1241            = closeConvertSession(uniqueId, convertId);
1242
1243        if (NULL != drmConvertedStatus) {
1244            //Filling Drm Converted Ststus
1245            reply->writeInt32(drmConvertedStatus->statusCode);
1246            reply->writeInt64(drmConvertedStatus->offset);
1247
1248            if (NULL != drmConvertedStatus->convertedData) {
1249                const DrmBuffer* convertedData = drmConvertedStatus->convertedData;
1250                const int bufferSize = convertedData->length;
1251                reply->writeInt32(bufferSize);
1252                if (0 < bufferSize) {
1253                    reply->write(convertedData->data, bufferSize);
1254                }
1255                delete [] convertedData->data;
1256                delete convertedData; convertedData = NULL;
1257            }
1258        }
1259        delete drmConvertedStatus; drmConvertedStatus = NULL;
1260        return DRM_NO_ERROR;
1261    }
1262
1263    case GET_ALL_SUPPORT_INFO:
1264    {
1265        ALOGV("BnDrmManagerService::onTransact :GET_ALL_SUPPORT_INFO");
1266        CHECK_INTERFACE(IDrmManagerService, data, reply);
1267
1268        const int uniqueId = data.readInt32();
1269        int length = 0;
1270        DrmSupportInfo* drmSupportInfoArray = NULL;
1271
1272        status_t status = getAllSupportInfo(uniqueId, &length, &drmSupportInfoArray);
1273
1274        reply->writeInt32(length);
1275        for (int i = 0; i < length; ++i) {
1276            DrmSupportInfo drmSupportInfo = drmSupportInfoArray[i];
1277
1278            reply->writeInt32(drmSupportInfo.getFileSuffixCount());
1279            DrmSupportInfo::FileSuffixIterator fileSuffixIt
1280                = drmSupportInfo.getFileSuffixIterator();
1281            while (fileSuffixIt.hasNext()) {
1282                reply->writeString8(fileSuffixIt.next());
1283            }
1284
1285            reply->writeInt32(drmSupportInfo.getMimeTypeCount());
1286            DrmSupportInfo::MimeTypeIterator mimeTypeIt = drmSupportInfo.getMimeTypeIterator();
1287            while (mimeTypeIt.hasNext()) {
1288                reply->writeString8(mimeTypeIt.next());
1289            }
1290            reply->writeString8(drmSupportInfo.getDescription());
1291        }
1292        delete [] drmSupportInfoArray; drmSupportInfoArray = NULL;
1293        reply->writeInt32(status);
1294        return DRM_NO_ERROR;
1295    }
1296
1297    case OPEN_DECRYPT_SESSION:
1298    {
1299        ALOGV("BnDrmManagerService::onTransact :OPEN_DECRYPT_SESSION");
1300        CHECK_INTERFACE(IDrmManagerService, data, reply);
1301
1302        const int uniqueId = data.readInt32();
1303        const int fd = data.readFileDescriptor();
1304
1305        const off64_t offset = data.readInt64();
1306        const off64_t length = data.readInt64();
1307        const String8 mime = data.readString8();
1308
1309        DecryptHandle* handle
1310            = openDecryptSession(uniqueId, fd, offset, length, mime.string());
1311
1312        if (NULL != handle) {
1313            writeDecryptHandleToParcelData(handle, reply);
1314            clearDecryptHandle(handle);
1315            delete handle; handle = NULL;
1316        }
1317        return DRM_NO_ERROR;
1318    }
1319
1320    case OPEN_DECRYPT_SESSION_FROM_URI:
1321    {
1322        ALOGV("BnDrmManagerService::onTransact :OPEN_DECRYPT_SESSION_FROM_URI");
1323        CHECK_INTERFACE(IDrmManagerService, data, reply);
1324
1325        const int uniqueId = data.readInt32();
1326        const String8 uri = data.readString8();
1327        const String8 mime = data.readString8();
1328
1329        DecryptHandle* handle = openDecryptSession(uniqueId, uri.string(), mime.string());
1330
1331        if (NULL != handle) {
1332            writeDecryptHandleToParcelData(handle, reply);
1333
1334            clearDecryptHandle(handle);
1335            delete handle; handle = NULL;
1336        } else {
1337            ALOGV("NULL decryptHandle is returned");
1338        }
1339        return DRM_NO_ERROR;
1340    }
1341
1342    case OPEN_DECRYPT_SESSION_FOR_STREAMING:
1343    {
1344        ALOGV("BnDrmManagerService::onTransact :OPEN_DECRYPT_SESSION_FOR_STREAMING");
1345        CHECK_INTERFACE(IDrmManagerService, data, reply);
1346
1347        const int uniqueId = data.readInt32();
1348        const int bufferSize = data.readInt32();
1349        DrmBuffer buf((bufferSize > 0) ? (char *)data.readInplace(bufferSize) : NULL,
1350                bufferSize);
1351        const String8 mimeType(data.readString8());
1352
1353        DecryptHandle* handle = openDecryptSession(uniqueId, buf, mimeType);
1354
1355        if (handle != NULL) {
1356            writeDecryptHandleToParcelData(handle, reply);
1357            clearDecryptHandle(handle);
1358            delete handle;
1359            handle = NULL;
1360        } else {
1361            ALOGV("NULL decryptHandle is returned");
1362        }
1363        return DRM_NO_ERROR;
1364    }
1365
1366    case CLOSE_DECRYPT_SESSION:
1367    {
1368        ALOGV("BnDrmManagerService::onTransact :CLOSE_DECRYPT_SESSION");
1369        CHECK_INTERFACE(IDrmManagerService, data, reply);
1370
1371        const int uniqueId = data.readInt32();
1372
1373        DecryptHandle* handle = new DecryptHandle();
1374        readDecryptHandleFromParcelData(handle, data);
1375
1376        const status_t status = closeDecryptSession(uniqueId, handle);
1377        reply->writeInt32(status);
1378        return DRM_NO_ERROR;
1379    }
1380
1381    case INITIALIZE_DECRYPT_UNIT:
1382    {
1383        ALOGV("BnDrmManagerService::onTransact :INITIALIZE_DECRYPT_UNIT");
1384        CHECK_INTERFACE(IDrmManagerService, data, reply);
1385
1386        const int uniqueId = data.readInt32();
1387
1388        DecryptHandle handle;
1389        readDecryptHandleFromParcelData(&handle, data);
1390
1391        const int decryptUnitId = data.readInt32();
1392
1393        //Filling Header info
1394        const int bufferSize = data.readInt32();
1395        DrmBuffer* headerInfo = NULL;
1396        headerInfo = new DrmBuffer((char *)data.readInplace(bufferSize), bufferSize);
1397
1398        const status_t status
1399            = initializeDecryptUnit(uniqueId, &handle, decryptUnitId, headerInfo);
1400        reply->writeInt32(status);
1401
1402        clearDecryptHandle(&handle);
1403        delete headerInfo; headerInfo = NULL;
1404        return DRM_NO_ERROR;
1405    }
1406
1407    case DECRYPT:
1408    {
1409        ALOGV("BnDrmManagerService::onTransact :DECRYPT");
1410        CHECK_INTERFACE(IDrmManagerService, data, reply);
1411
1412        const int uniqueId = data.readInt32();
1413
1414        DecryptHandle handle;
1415        readDecryptHandleFromParcelData(&handle, data);
1416
1417        const int decryptUnitId = data.readInt32();
1418        const int decBufferSize = data.readInt32();
1419
1420        const int encBufferSize = data.readInt32();
1421        DrmBuffer* encBuffer
1422            = new DrmBuffer((char *)data.readInplace(encBufferSize), encBufferSize);
1423
1424        char* buffer = NULL;
1425        buffer = new char[decBufferSize];
1426        DrmBuffer* decBuffer = new DrmBuffer(buffer, decBufferSize);
1427
1428        DrmBuffer* IV = NULL;
1429        if (0 != data.dataAvail()) {
1430            const int ivBufferlength = data.readInt32();
1431            IV = new DrmBuffer((char *)data.readInplace(ivBufferlength), ivBufferlength);
1432        }
1433
1434        const status_t status
1435            = decrypt(uniqueId, &handle, decryptUnitId, encBuffer, &decBuffer, IV);
1436
1437        reply->writeInt32(status);
1438
1439        const int size = decBuffer->length;
1440        reply->writeInt32(size);
1441        reply->write(decBuffer->data, size);
1442
1443        clearDecryptHandle(&handle);
1444        delete encBuffer; encBuffer = NULL;
1445        delete decBuffer; decBuffer = NULL;
1446        delete [] buffer; buffer = NULL;
1447        delete IV; IV = NULL;
1448        return DRM_NO_ERROR;
1449    }
1450
1451    case FINALIZE_DECRYPT_UNIT:
1452    {
1453        ALOGV("BnDrmManagerService::onTransact :FINALIZE_DECRYPT_UNIT");
1454        CHECK_INTERFACE(IDrmManagerService, data, reply);
1455
1456        const int uniqueId = data.readInt32();
1457
1458        DecryptHandle handle;
1459        readDecryptHandleFromParcelData(&handle, data);
1460
1461        const status_t status = finalizeDecryptUnit(uniqueId, &handle, data.readInt32());
1462        reply->writeInt32(status);
1463
1464        clearDecryptHandle(&handle);
1465        return DRM_NO_ERROR;
1466    }
1467
1468    case PREAD:
1469    {
1470        ALOGV("BnDrmManagerService::onTransact :READ");
1471        CHECK_INTERFACE(IDrmManagerService, data, reply);
1472
1473        const int uniqueId = data.readInt32();
1474
1475        DecryptHandle handle;
1476        readDecryptHandleFromParcelData(&handle, data);
1477
1478        const int numBytes = data.readInt32();
1479        char* buffer = new char[numBytes];
1480
1481        const off64_t offset = data.readInt64();
1482
1483        ssize_t result = pread(uniqueId, &handle, buffer, numBytes, offset);
1484        reply->writeInt32(result);
1485        if (0 < result) {
1486            reply->write(buffer, result);
1487        }
1488
1489        clearDecryptHandle(&handle);
1490        delete [] buffer, buffer = NULL;
1491        return DRM_NO_ERROR;
1492    }
1493
1494    default:
1495        return BBinder::onTransact(code, data, reply, flags);
1496    }
1497}
1498
1499