IDrmManagerService.cpp revision 9d2f386dd2885eaffa11fd494ae258bb09fe6397 
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
655status_t BpDrmManagerService::closeDecryptSession(int uniqueId, DecryptHandle* decryptHandle) {
656    ALOGV("closeDecryptSession");
657    Parcel data, reply;
658
659    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
660    data.writeInt32(uniqueId);
661
662    writeDecryptHandleToParcelData(decryptHandle, &data);
663
664    remote()->transact(CLOSE_DECRYPT_SESSION, data, &reply);
665
666    return reply.readInt32();
667}
668
669status_t BpDrmManagerService::initializeDecryptUnit(
670            int uniqueId, DecryptHandle* decryptHandle,
671            int decryptUnitId, const DrmBuffer* headerInfo) {
672    ALOGV("initializeDecryptUnit");
673    Parcel data, reply;
674
675    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
676    data.writeInt32(uniqueId);
677
678    writeDecryptHandleToParcelData(decryptHandle, &data);
679
680    data.writeInt32(decryptUnitId);
681
682    data.writeInt32(headerInfo->length);
683    data.write(headerInfo->data, headerInfo->length);
684
685    remote()->transact(INITIALIZE_DECRYPT_UNIT, data, &reply);
686    return reply.readInt32();
687}
688
689status_t BpDrmManagerService::decrypt(
690            int uniqueId, DecryptHandle* decryptHandle, int decryptUnitId,
691            const DrmBuffer* encBuffer, DrmBuffer** decBuffer, DrmBuffer* IV) {
692    ALOGV("decrypt");
693    Parcel data, reply;
694
695    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
696    data.writeInt32(uniqueId);
697
698    writeDecryptHandleToParcelData(decryptHandle, &data);
699
700    data.writeInt32(decryptUnitId);
701    data.writeInt32((*decBuffer)->length);
702
703    data.writeInt32(encBuffer->length);
704    data.write(encBuffer->data, encBuffer->length);
705
706    if (NULL != IV) {
707        data.writeInt32(IV->length);
708        data.write(IV->data, IV->length);
709    }
710
711    remote()->transact(DECRYPT, data, &reply);
712
713    const status_t status = reply.readInt32();
714    ALOGV("Return value of decrypt() is %d", status);
715
716    const int size = reply.readInt32();
717    (*decBuffer)->length = size;
718    reply.read((void *)(*decBuffer)->data, size);
719
720    return status;
721}
722
723status_t BpDrmManagerService::finalizeDecryptUnit(
724            int uniqueId, DecryptHandle* decryptHandle, int decryptUnitId) {
725    ALOGV("finalizeDecryptUnit");
726    Parcel data, reply;
727
728    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
729    data.writeInt32(uniqueId);
730
731    writeDecryptHandleToParcelData(decryptHandle, &data);
732
733    data.writeInt32(decryptUnitId);
734
735    remote()->transact(FINALIZE_DECRYPT_UNIT, data, &reply);
736    return reply.readInt32();
737}
738
739ssize_t BpDrmManagerService::pread(
740            int uniqueId, DecryptHandle* decryptHandle, void* buffer,
741            ssize_t numBytes, off64_t offset) {
742    ALOGV("read");
743    Parcel data, reply;
744    int result;
745
746    data.writeInterfaceToken(IDrmManagerService::getInterfaceDescriptor());
747    data.writeInt32(uniqueId);
748
749    writeDecryptHandleToParcelData(decryptHandle, &data);
750
751    data.writeInt32(numBytes);
752    data.writeInt64(offset);
753
754    remote()->transact(PREAD, data, &reply);
755    result = reply.readInt32();
756    if (0 < result) {
757        reply.read(buffer, result);
758    }
759    return result;
760}
761
762IMPLEMENT_META_INTERFACE(DrmManagerService, "drm.IDrmManagerService");
763
764status_t BnDrmManagerService::onTransact(
765            uint32_t code, const Parcel& data,
766            Parcel* reply, uint32_t flags) {
767    ALOGV("Entering BnDrmManagerService::onTransact with code %d", code);
768
769    switch (code) {
770    case ADD_UNIQUEID:
771    {
772        ALOGV("BnDrmManagerService::onTransact :ADD_UNIQUEID");
773        CHECK_INTERFACE(IDrmManagerService, data, reply);
774        int uniqueId = addUniqueId(data.readInt32());
775        reply->writeInt32(uniqueId);
776        return DRM_NO_ERROR;
777    }
778
779    case REMOVE_UNIQUEID:
780    {
781        ALOGV("BnDrmManagerService::onTransact :REMOVE_UNIQUEID");
782        CHECK_INTERFACE(IDrmManagerService, data, reply);
783        removeUniqueId(data.readInt32());
784        return DRM_NO_ERROR;
785    }
786
787    case ADD_CLIENT:
788    {
789        ALOGV("BnDrmManagerService::onTransact :ADD_CLIENT");
790        CHECK_INTERFACE(IDrmManagerService, data, reply);
791        addClient(data.readInt32());
792        return DRM_NO_ERROR;
793    }
794
795    case REMOVE_CLIENT:
796    {
797        ALOGV("BnDrmManagerService::onTransact :REMOVE_CLIENT");
798        CHECK_INTERFACE(IDrmManagerService, data, reply);
799        removeClient(data.readInt32());
800        return DRM_NO_ERROR;
801    }
802
803    case SET_DRM_SERVICE_LISTENER:
804    {
805        ALOGV("BnDrmManagerService::onTransact :SET_DRM_SERVICE_LISTENER");
806        CHECK_INTERFACE(IDrmManagerService, data, reply);
807
808        const int uniqueId = data.readInt32();
809        const sp<IDrmServiceListener> drmServiceListener
810            = interface_cast<IDrmServiceListener> (data.readStrongBinder());
811
812        status_t status = setDrmServiceListener(uniqueId, drmServiceListener);
813
814        reply->writeInt32(status);
815        return DRM_NO_ERROR;
816    }
817
818    case INSTALL_DRM_ENGINE:
819    {
820        ALOGV("BnDrmManagerService::onTransact :INSTALL_DRM_ENGINE");
821        CHECK_INTERFACE(IDrmManagerService, data, reply);
822
823        const int uniqueId = data.readInt32();
824        const String8 engineFile = data.readString8();
825        status_t status = installDrmEngine(uniqueId, engineFile);
826
827        reply->writeInt32(status);
828        return DRM_NO_ERROR;
829    }
830
831    case GET_CONSTRAINTS_FROM_CONTENT:
832    {
833        ALOGV("BnDrmManagerService::onTransact :GET_CONSTRAINTS_FROM_CONTENT");
834        CHECK_INTERFACE(IDrmManagerService, data, reply);
835
836        const int uniqueId = data.readInt32();
837        const String8 path = data.readString8();
838
839        DrmConstraints* drmConstraints
840            = getConstraints(uniqueId, &path, data.readInt32());
841
842        if (NULL != drmConstraints) {
843            //Filling DRM Constraints contents
844            reply->writeInt32(drmConstraints->getCount());
845
846            DrmConstraints::KeyIterator keyIt = drmConstraints->keyIterator();
847            while (keyIt.hasNext()) {
848                const String8 key = keyIt.next();
849                reply->writeString8(key);
850                const char* value = drmConstraints->getAsByteArray(&key);
851                int bufferSize = 0;
852                if (NULL != value) {
853                    bufferSize = strlen(value);
854                }
855                reply->writeInt32(bufferSize + 1);
856                reply->write(value, bufferSize + 1);
857            }
858        }
859        delete drmConstraints; drmConstraints = NULL;
860        return DRM_NO_ERROR;
861    }
862
863    case GET_METADATA_FROM_CONTENT:
864    {
865        ALOGV("BnDrmManagerService::onTransact :GET_METADATA_FROM_CONTENT");
866        CHECK_INTERFACE(IDrmManagerService, data, reply);
867
868        const int uniqueId = data.readInt32();
869        const String8 path = data.readString8();
870
871        DrmMetadata* drmMetadata = getMetadata(uniqueId, &path);
872        if (NULL != drmMetadata) {
873            //Filling DRM Metadata contents
874            reply->writeInt32(drmMetadata->getCount());
875
876            DrmMetadata::KeyIterator keyIt = drmMetadata->keyIterator();
877            while (keyIt.hasNext()) {
878                const String8 key = keyIt.next();
879                reply->writeString8(key);
880                const char* value = drmMetadata->getAsByteArray(&key);
881                int bufferSize = 0;
882                if (NULL != value) {
883                    bufferSize = strlen(value);
884                    reply->writeInt32(bufferSize + 1);
885                    reply->write(value, bufferSize + 1);
886                } else {
887                    reply->writeInt32(0);
888                }
889            }
890        }
891        delete drmMetadata; drmMetadata = NULL;
892        return NO_ERROR;
893    }
894
895    case CAN_HANDLE:
896    {
897        ALOGV("BnDrmManagerService::onTransact :CAN_HANDLE");
898        CHECK_INTERFACE(IDrmManagerService, data, reply);
899
900        const int uniqueId = data.readInt32();
901        const String8 path = data.readString8();
902        const String8 mimeType = data.readString8();
903
904        bool result = canHandle(uniqueId, path, mimeType);
905
906        reply->writeInt32(result);
907        return DRM_NO_ERROR;
908    }
909
910    case PROCESS_DRM_INFO:
911    {
912        ALOGV("BnDrmManagerService::onTransact :PROCESS_DRM_INFO");
913        CHECK_INTERFACE(IDrmManagerService, data, reply);
914
915        const int uniqueId = data.readInt32();
916
917        //Filling DRM info
918        const int infoType = data.readInt32();
919        const int bufferSize = data.readInt32();
920        char* buffer = NULL;
921        if (0 < bufferSize) {
922            buffer = (char *)data.readInplace(bufferSize);
923        }
924        const DrmBuffer drmBuffer(buffer, bufferSize);
925        DrmInfo* drmInfo = new DrmInfo(infoType, drmBuffer, data.readString8());
926
927        const int size = data.readInt32();
928        for (int index = 0; index < size; ++index) {
929            const String8 key(data.readString8());
930            const String8 value(data.readString8());
931            drmInfo->put(key, (value == String8("NULL")) ? String8("") : value);
932        }
933
934        DrmInfoStatus* drmInfoStatus = processDrmInfo(uniqueId, drmInfo);
935
936        if (NULL != drmInfoStatus) {
937            //Filling DRM Info Status contents
938            reply->writeInt32(drmInfoStatus->statusCode);
939            reply->writeInt32(drmInfoStatus->infoType);
940            reply->writeString8(drmInfoStatus->mimeType);
941
942            if (NULL != drmInfoStatus->drmBuffer) {
943                const DrmBuffer* drmBuffer = drmInfoStatus->drmBuffer;
944                const int bufferSize = drmBuffer->length;
945                reply->writeInt32(bufferSize);
946                if (0 < bufferSize) {
947                    reply->write(drmBuffer->data, bufferSize);
948                }
949                delete [] drmBuffer->data;
950                delete drmBuffer; drmBuffer = NULL;
951            }
952        }
953        delete drmInfo; drmInfo = NULL;
954        delete drmInfoStatus; drmInfoStatus = NULL;
955        return DRM_NO_ERROR;
956    }
957
958    case ACQUIRE_DRM_INFO:
959    {
960        ALOGV("BnDrmManagerService::onTransact :ACQUIRE_DRM_INFO");
961        CHECK_INTERFACE(IDrmManagerService, data, reply);
962
963        const int uniqueId = data.readInt32();
964
965        //Filling DRM info Request
966        const int infoType = data.readInt32();
967        const String8 mimeType = data.readString8();
968        DrmInfoRequest* drmInfoRequest = new DrmInfoRequest(infoType, mimeType);
969
970        const int size = data.readInt32();
971        for (int index = 0; index < size; ++index) {
972            const String8 key(data.readString8());
973            const String8 value(data.readString8());
974            drmInfoRequest->put(key, (value == String8("NULL")) ? String8("") : value);
975        }
976
977        DrmInfo* drmInfo = acquireDrmInfo(uniqueId, drmInfoRequest);
978
979        if (NULL != drmInfo) {
980            //Filling DRM Info
981            const DrmBuffer drmBuffer = drmInfo->getData();
982            reply->writeInt32(drmInfo->getInfoType());
983
984            const int bufferSize = drmBuffer.length;
985            reply->writeInt32(bufferSize);
986            if (0 < bufferSize) {
987                reply->write(drmBuffer.data, bufferSize);
988            }
989            reply->writeString8(drmInfo->getMimeType());
990            reply->writeInt32(drmInfo->getCount());
991
992            DrmInfo::KeyIterator keyIt = drmInfo->keyIterator();
993            while (keyIt.hasNext()) {
994                const String8 key = keyIt.next();
995                reply->writeString8(key);
996                const String8 value = drmInfo->get(key);
997                reply->writeString8((value == String8("")) ? String8("NULL") : value);
998            }
999            delete [] drmBuffer.data;
1000        }
1001        delete drmInfoRequest; drmInfoRequest = NULL;
1002        delete drmInfo; drmInfo = NULL;
1003        return DRM_NO_ERROR;
1004    }
1005
1006    case SAVE_RIGHTS:
1007    {
1008        ALOGV("BnDrmManagerService::onTransact :SAVE_RIGHTS");
1009        CHECK_INTERFACE(IDrmManagerService, data, reply);
1010
1011        const int uniqueId = data.readInt32();
1012
1013        //Filling DRM Rights
1014        const int bufferSize = data.readInt32();
1015        const DrmBuffer drmBuffer((char *)data.readInplace(bufferSize), bufferSize);
1016
1017        const String8 mimeType(data.readString8());
1018        const String8 accountId(data.readString8());
1019        const String8 subscriptionId(data.readString8());
1020        const String8 rightsPath(data.readString8());
1021        const String8 contentPath(data.readString8());
1022
1023        DrmRights drmRights(drmBuffer,
1024                            ((mimeType == String8("NULL")) ? String8("") : mimeType),
1025                            ((accountId == String8("NULL")) ? String8("") : accountId),
1026                            ((subscriptionId == String8("NULL")) ? String8("") : subscriptionId));
1027
1028        const status_t status = saveRights(uniqueId, drmRights,
1029                            ((rightsPath == String8("NULL")) ? String8("") : rightsPath),
1030                            ((contentPath == String8("NULL")) ? String8("") : contentPath));
1031
1032        reply->writeInt32(status);
1033        return DRM_NO_ERROR;
1034    }
1035
1036    case GET_ORIGINAL_MIMETYPE:
1037    {
1038        ALOGV("BnDrmManagerService::onTransact :GET_ORIGINAL_MIMETYPE");
1039        CHECK_INTERFACE(IDrmManagerService, data, reply);
1040
1041        const int uniqueId = data.readInt32();
1042        const String8 path = data.readString8();
1043        const String8 originalMimeType = getOriginalMimeType(uniqueId, path);
1044
1045        reply->writeString8(originalMimeType);
1046        return DRM_NO_ERROR;
1047    }
1048
1049    case GET_DRM_OBJECT_TYPE:
1050    {
1051        ALOGV("BnDrmManagerService::onTransact :GET_DRM_OBJECT_TYPE");
1052        CHECK_INTERFACE(IDrmManagerService, data, reply);
1053
1054        const int uniqueId = data.readInt32();
1055        const String8 path = data.readString8();
1056        const String8 mimeType = data.readString8();
1057        const int drmObjectType = getDrmObjectType(uniqueId, path, mimeType);
1058
1059        reply->writeInt32(drmObjectType);
1060        return DRM_NO_ERROR;
1061    }
1062
1063    case CHECK_RIGHTS_STATUS:
1064    {
1065        ALOGV("BnDrmManagerService::onTransact :CHECK_RIGHTS_STATUS");
1066        CHECK_INTERFACE(IDrmManagerService, data, reply);
1067
1068        const int uniqueId = data.readInt32();
1069        const String8 path = data.readString8();
1070        const int action = data.readInt32();
1071        const int result = checkRightsStatus(uniqueId, path, action);
1072
1073        reply->writeInt32(result);
1074        return DRM_NO_ERROR;
1075    }
1076
1077    case CONSUME_RIGHTS:
1078    {
1079        ALOGV("BnDrmManagerService::onTransact :CONSUME_RIGHTS");
1080        CHECK_INTERFACE(IDrmManagerService, data, reply);
1081
1082        const int uniqueId = data.readInt32();
1083
1084        DecryptHandle handle;
1085        readDecryptHandleFromParcelData(&handle, data);
1086
1087        const int action = data.readInt32();
1088        const bool reserve = static_cast<bool>(data.readInt32());
1089        const status_t status
1090            = consumeRights(uniqueId, &handle, action, reserve);
1091        reply->writeInt32(status);
1092
1093        clearDecryptHandle(&handle);
1094        return DRM_NO_ERROR;
1095    }
1096
1097    case SET_PLAYBACK_STATUS:
1098    {
1099        ALOGV("BnDrmManagerService::onTransact :SET_PLAYBACK_STATUS");
1100        CHECK_INTERFACE(IDrmManagerService, data, reply);
1101
1102        const int uniqueId = data.readInt32();
1103
1104        DecryptHandle handle;
1105        readDecryptHandleFromParcelData(&handle, data);
1106
1107        const int playbackStatus = data.readInt32();
1108        const int64_t position = data.readInt64();
1109        const status_t status
1110            = setPlaybackStatus(uniqueId, &handle, playbackStatus, position);
1111        reply->writeInt32(status);
1112
1113        clearDecryptHandle(&handle);
1114        return DRM_NO_ERROR;
1115    }
1116
1117    case VALIDATE_ACTION:
1118    {
1119        ALOGV("BnDrmManagerService::onTransact :VALIDATE_ACTION");
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 outputType = data.readInt32();
1126        const int configuration = data.readInt32();
1127        bool result = validateAction(uniqueId, path, action,
1128                ActionDescription(outputType, configuration));
1129
1130        reply->writeInt32(result);
1131        return DRM_NO_ERROR;
1132    }
1133
1134    case REMOVE_RIGHTS:
1135    {
1136        ALOGV("BnDrmManagerService::onTransact :REMOVE_RIGHTS");
1137        CHECK_INTERFACE(IDrmManagerService, data, reply);
1138
1139        int uniqueId = data.readInt32();
1140        String8 path = data.readString8();
1141        const status_t status = removeRights(uniqueId, path);
1142        reply->writeInt32(status);
1143
1144        return DRM_NO_ERROR;
1145    }
1146
1147    case REMOVE_ALL_RIGHTS:
1148    {
1149        ALOGV("BnDrmManagerService::onTransact :REMOVE_ALL_RIGHTS");
1150        CHECK_INTERFACE(IDrmManagerService, data, reply);
1151
1152        const status_t status = removeAllRights(data.readInt32());
1153        reply->writeInt32(status);
1154
1155        return DRM_NO_ERROR;
1156    }
1157
1158    case OPEN_CONVERT_SESSION:
1159    {
1160        ALOGV("BnDrmManagerService::onTransact :OPEN_CONVERT_SESSION");
1161        CHECK_INTERFACE(IDrmManagerService, data, reply);
1162
1163        const int uniqueId = data.readInt32();
1164        const String8 mimeType = data.readString8();
1165        const int convertId = openConvertSession(uniqueId, mimeType);
1166
1167        reply->writeInt32(convertId);
1168        return DRM_NO_ERROR;
1169    }
1170
1171    case CONVERT_DATA:
1172    {
1173        ALOGV("BnDrmManagerService::onTransact :CONVERT_DATA");
1174        CHECK_INTERFACE(IDrmManagerService, data, reply);
1175
1176        const int uniqueId = data.readInt32();
1177        const int convertId = data.readInt32();
1178
1179        //Filling input data
1180        const int bufferSize = data.readInt32();
1181        DrmBuffer* inputData = new DrmBuffer((char *)data.readInplace(bufferSize), bufferSize);
1182
1183        DrmConvertedStatus*    drmConvertedStatus = convertData(uniqueId, convertId, inputData);
1184
1185        if (NULL != drmConvertedStatus) {
1186            //Filling Drm Converted Ststus
1187            reply->writeInt32(drmConvertedStatus->statusCode);
1188            reply->writeInt64(drmConvertedStatus->offset);
1189
1190            if (NULL != drmConvertedStatus->convertedData) {
1191                const DrmBuffer* convertedData = drmConvertedStatus->convertedData;
1192                const int bufferSize = convertedData->length;
1193                reply->writeInt32(bufferSize);
1194                if (0 < bufferSize) {
1195                    reply->write(convertedData->data, bufferSize);
1196                }
1197                delete [] convertedData->data;
1198                delete convertedData; convertedData = NULL;
1199            }
1200        }
1201        delete inputData; inputData = NULL;
1202        delete drmConvertedStatus; drmConvertedStatus = NULL;
1203        return DRM_NO_ERROR;
1204    }
1205
1206    case CLOSE_CONVERT_SESSION:
1207    {
1208        ALOGV("BnDrmManagerService::onTransact :CLOSE_CONVERT_SESSION");
1209        CHECK_INTERFACE(IDrmManagerService, data, reply);
1210
1211        const int uniqueId = data.readInt32();
1212        const int convertId = data.readInt32();
1213        DrmConvertedStatus* drmConvertedStatus
1214            = closeConvertSession(uniqueId, convertId);
1215
1216        if (NULL != drmConvertedStatus) {
1217            //Filling Drm Converted Ststus
1218            reply->writeInt32(drmConvertedStatus->statusCode);
1219            reply->writeInt64(drmConvertedStatus->offset);
1220
1221            if (NULL != drmConvertedStatus->convertedData) {
1222                const DrmBuffer* convertedData = drmConvertedStatus->convertedData;
1223                const int bufferSize = convertedData->length;
1224                reply->writeInt32(bufferSize);
1225                if (0 < bufferSize) {
1226                    reply->write(convertedData->data, bufferSize);
1227                }
1228                delete [] convertedData->data;
1229                delete convertedData; convertedData = NULL;
1230            }
1231        }
1232        delete drmConvertedStatus; drmConvertedStatus = NULL;
1233        return DRM_NO_ERROR;
1234    }
1235
1236    case GET_ALL_SUPPORT_INFO:
1237    {
1238        ALOGV("BnDrmManagerService::onTransact :GET_ALL_SUPPORT_INFO");
1239        CHECK_INTERFACE(IDrmManagerService, data, reply);
1240
1241        const int uniqueId = data.readInt32();
1242        int length = 0;
1243        DrmSupportInfo* drmSupportInfoArray = NULL;
1244
1245        status_t status = getAllSupportInfo(uniqueId, &length, &drmSupportInfoArray);
1246
1247        reply->writeInt32(length);
1248        for (int i = 0; i < length; ++i) {
1249            DrmSupportInfo drmSupportInfo = drmSupportInfoArray[i];
1250
1251            reply->writeInt32(drmSupportInfo.getFileSuffixCount());
1252            DrmSupportInfo::FileSuffixIterator fileSuffixIt
1253                = drmSupportInfo.getFileSuffixIterator();
1254            while (fileSuffixIt.hasNext()) {
1255                reply->writeString8(fileSuffixIt.next());
1256            }
1257
1258            reply->writeInt32(drmSupportInfo.getMimeTypeCount());
1259            DrmSupportInfo::MimeTypeIterator mimeTypeIt = drmSupportInfo.getMimeTypeIterator();
1260            while (mimeTypeIt.hasNext()) {
1261                reply->writeString8(mimeTypeIt.next());
1262            }
1263            reply->writeString8(drmSupportInfo.getDescription());
1264        }
1265        delete [] drmSupportInfoArray; drmSupportInfoArray = NULL;
1266        reply->writeInt32(status);
1267        return DRM_NO_ERROR;
1268    }
1269
1270    case OPEN_DECRYPT_SESSION:
1271    {
1272        ALOGV("BnDrmManagerService::onTransact :OPEN_DECRYPT_SESSION");
1273        CHECK_INTERFACE(IDrmManagerService, data, reply);
1274
1275        const int uniqueId = data.readInt32();
1276        const int fd = data.readFileDescriptor();
1277
1278        const off64_t offset = data.readInt64();
1279        const off64_t length = data.readInt64();
1280        const String8 mime = data.readString8();
1281
1282        DecryptHandle* handle
1283            = openDecryptSession(uniqueId, fd, offset, length, mime.string());
1284
1285        if (NULL != handle) {
1286            writeDecryptHandleToParcelData(handle, reply);
1287            clearDecryptHandle(handle);
1288            delete handle; handle = NULL;
1289        }
1290        return DRM_NO_ERROR;
1291    }
1292
1293    case OPEN_DECRYPT_SESSION_FROM_URI:
1294    {
1295        ALOGV("BnDrmManagerService::onTransact :OPEN_DECRYPT_SESSION_FROM_URI");
1296        CHECK_INTERFACE(IDrmManagerService, data, reply);
1297
1298        const int uniqueId = data.readInt32();
1299        const String8 uri = data.readString8();
1300        const String8 mime = data.readString8();
1301
1302        DecryptHandle* handle = openDecryptSession(uniqueId, uri.string(), mime.string());
1303
1304        if (NULL != handle) {
1305            writeDecryptHandleToParcelData(handle, reply);
1306
1307            clearDecryptHandle(handle);
1308            delete handle; handle = NULL;
1309        } else {
1310            ALOGV("NULL decryptHandle is returned");
1311        }
1312        return DRM_NO_ERROR;
1313    }
1314
1315    case CLOSE_DECRYPT_SESSION:
1316    {
1317        ALOGV("BnDrmManagerService::onTransact :CLOSE_DECRYPT_SESSION");
1318        CHECK_INTERFACE(IDrmManagerService, data, reply);
1319
1320        const int uniqueId = data.readInt32();
1321
1322        DecryptHandle* handle = new DecryptHandle();
1323        readDecryptHandleFromParcelData(handle, data);
1324
1325        const status_t status = closeDecryptSession(uniqueId, handle);
1326        reply->writeInt32(status);
1327        return DRM_NO_ERROR;
1328    }
1329
1330    case INITIALIZE_DECRYPT_UNIT:
1331    {
1332        ALOGV("BnDrmManagerService::onTransact :INITIALIZE_DECRYPT_UNIT");
1333        CHECK_INTERFACE(IDrmManagerService, data, reply);
1334
1335        const int uniqueId = data.readInt32();
1336
1337        DecryptHandle handle;
1338        readDecryptHandleFromParcelData(&handle, data);
1339
1340        const int decryptUnitId = data.readInt32();
1341
1342        //Filling Header info
1343        const int bufferSize = data.readInt32();
1344        DrmBuffer* headerInfo = NULL;
1345        headerInfo = new DrmBuffer((char *)data.readInplace(bufferSize), bufferSize);
1346
1347        const status_t status
1348            = initializeDecryptUnit(uniqueId, &handle, decryptUnitId, headerInfo);
1349        reply->writeInt32(status);
1350
1351        clearDecryptHandle(&handle);
1352        delete headerInfo; headerInfo = NULL;
1353        return DRM_NO_ERROR;
1354    }
1355
1356    case DECRYPT:
1357    {
1358        ALOGV("BnDrmManagerService::onTransact :DECRYPT");
1359        CHECK_INTERFACE(IDrmManagerService, data, reply);
1360
1361        const int uniqueId = data.readInt32();
1362
1363        DecryptHandle handle;
1364        readDecryptHandleFromParcelData(&handle, data);
1365
1366        const int decryptUnitId = data.readInt32();
1367        const int decBufferSize = data.readInt32();
1368
1369        const int encBufferSize = data.readInt32();
1370        DrmBuffer* encBuffer
1371            = new DrmBuffer((char *)data.readInplace(encBufferSize), encBufferSize);
1372
1373        char* buffer = NULL;
1374        buffer = new char[decBufferSize];
1375        DrmBuffer* decBuffer = new DrmBuffer(buffer, decBufferSize);
1376
1377        DrmBuffer* IV = NULL;
1378        if (0 != data.dataAvail()) {
1379            const int ivBufferlength = data.readInt32();
1380            IV = new DrmBuffer((char *)data.readInplace(ivBufferlength), ivBufferlength);
1381        }
1382
1383        const status_t status
1384            = decrypt(uniqueId, &handle, decryptUnitId, encBuffer, &decBuffer, IV);
1385
1386        reply->writeInt32(status);
1387
1388        const int size = decBuffer->length;
1389        reply->writeInt32(size);
1390        reply->write(decBuffer->data, size);
1391
1392        clearDecryptHandle(&handle);
1393        delete encBuffer; encBuffer = NULL;
1394        delete decBuffer; decBuffer = NULL;
1395        delete [] buffer; buffer = NULL;
1396        delete IV; IV = NULL;
1397        return DRM_NO_ERROR;
1398    }
1399
1400    case FINALIZE_DECRYPT_UNIT:
1401    {
1402        ALOGV("BnDrmManagerService::onTransact :FINALIZE_DECRYPT_UNIT");
1403        CHECK_INTERFACE(IDrmManagerService, data, reply);
1404
1405        const int uniqueId = data.readInt32();
1406
1407        DecryptHandle handle;
1408        readDecryptHandleFromParcelData(&handle, data);
1409
1410        const status_t status = finalizeDecryptUnit(uniqueId, &handle, data.readInt32());
1411        reply->writeInt32(status);
1412
1413        clearDecryptHandle(&handle);
1414        return DRM_NO_ERROR;
1415    }
1416
1417    case PREAD:
1418    {
1419        ALOGV("BnDrmManagerService::onTransact :READ");
1420        CHECK_INTERFACE(IDrmManagerService, data, reply);
1421
1422        const int uniqueId = data.readInt32();
1423
1424        DecryptHandle handle;
1425        readDecryptHandleFromParcelData(&handle, data);
1426
1427        const int numBytes = data.readInt32();
1428        char* buffer = new char[numBytes];
1429
1430        const off64_t offset = data.readInt64();
1431
1432        ssize_t result = pread(uniqueId, &handle, buffer, numBytes, offset);
1433        reply->writeInt32(result);
1434        if (0 < result) {
1435            reply->write(buffer, result);
1436        }
1437
1438        clearDecryptHandle(&handle);
1439        delete [] buffer, buffer = NULL;
1440        return DRM_NO_ERROR;
1441    }
1442
1443    default:
1444        return BBinder::onTransact(code, data, reply, flags);
1445    }
1446}
1447
1448