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