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