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