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 "DrmPassthruPlugIn" 19 #include <utils/Log.h> 20 21 #include <drm/DrmRights.h> 22 #include <drm/DrmConstraints.h> 23 #include <drm/DrmMetadata.h> 24 #include <drm/DrmInfo.h> 25 #include <drm/DrmInfoEvent.h> 26 #include <drm/DrmInfoStatus.h> 27 #include <drm/DrmConvertedStatus.h> 28 #include <drm/DrmInfoRequest.h> 29 #include <drm/DrmSupportInfo.h> 30 #include <DrmPassthruPlugIn.h> 31 32 using namespace android; 33 34 35 // This extern "C" is mandatory to be managed by TPlugInManager 36 extern "C" IDrmEngine* create() { 37 return new DrmPassthruPlugIn(); 38 } 39 40 // This extern "C" is mandatory to be managed by TPlugInManager 41 extern "C" void destroy(IDrmEngine* pPlugIn) { 42 delete pPlugIn; 43 pPlugIn = NULL; 44 } 45 46 DrmPassthruPlugIn::DrmPassthruPlugIn() 47 : DrmEngineBase() { 48 49 } 50 51 DrmPassthruPlugIn::~DrmPassthruPlugIn() { 52 53 } 54 55 DrmMetadata* DrmPassthruPlugIn::onGetMetadata(int uniqueId, const String8* path) { 56 return NULL; 57 } 58 59 DrmConstraints* DrmPassthruPlugIn::onGetConstraints( 60 int uniqueId, const String8* path, int action) { 61 ALOGV("DrmPassthruPlugIn::onGetConstraints From Path: %d", uniqueId); 62 DrmConstraints* drmConstraints = new DrmConstraints(); 63 64 String8 value("dummy_available_time"); 65 char* charValue = NULL; 66 charValue = new char[value.length() + 1]; 67 strncpy(charValue, value.string(), value.length()); 68 charValue[value.length()] = '\0'; 69 70 //Just add dummy available time for verification 71 drmConstraints->put(&(DrmConstraints::LICENSE_AVAILABLE_TIME), charValue); 72 delete[] charValue; 73 return drmConstraints; 74 } 75 76 DrmInfoStatus* DrmPassthruPlugIn::onProcessDrmInfo(int uniqueId, const DrmInfo* drmInfo) { 77 ALOGV("DrmPassthruPlugIn::onProcessDrmInfo - Enter : %d", uniqueId); 78 DrmInfoStatus* drmInfoStatus = NULL; 79 if (NULL != drmInfo) { 80 switch (drmInfo->getInfoType()) { 81 case DrmInfoRequest::TYPE_REGISTRATION_INFO: { 82 const DrmBuffer* emptyBuffer = new DrmBuffer(); 83 drmInfoStatus = new DrmInfoStatus(DrmInfoStatus::STATUS_OK, 84 DrmInfoRequest::TYPE_REGISTRATION_INFO, emptyBuffer, drmInfo->getMimeType()); 85 break; 86 } 87 case DrmInfoRequest::TYPE_UNREGISTRATION_INFO: { 88 const DrmBuffer* emptyBuffer = new DrmBuffer(); 89 drmInfoStatus = new DrmInfoStatus(DrmInfoStatus::STATUS_OK, 90 DrmInfoRequest::TYPE_UNREGISTRATION_INFO, emptyBuffer, drmInfo->getMimeType()); 91 break; 92 } 93 case DrmInfoRequest::TYPE_RIGHTS_ACQUISITION_INFO: { 94 String8 licenseString("dummy_license_string"); 95 const int bufferSize = licenseString.size(); 96 char* data = NULL; 97 data = new char[bufferSize]; 98 memcpy(data, licenseString.string(), bufferSize); 99 const DrmBuffer* buffer = new DrmBuffer(data, bufferSize); 100 drmInfoStatus = new DrmInfoStatus(DrmInfoStatus::STATUS_OK, 101 DrmInfoRequest::TYPE_RIGHTS_ACQUISITION_INFO, buffer, drmInfo->getMimeType()); 102 break; 103 } 104 } 105 } 106 ALOGV("DrmPassthruPlugIn::onProcessDrmInfo - Exit"); 107 return drmInfoStatus; 108 } 109 110 status_t DrmPassthruPlugIn::onSetOnInfoListener( 111 int uniqueId, const IDrmEngine::OnInfoListener* infoListener) { 112 ALOGV("DrmPassthruPlugIn::onSetOnInfoListener : %d", uniqueId); 113 return DRM_NO_ERROR; 114 } 115 116 status_t DrmPassthruPlugIn::onInitialize(int uniqueId) { 117 ALOGV("DrmPassthruPlugIn::onInitialize : %d", uniqueId); 118 return DRM_NO_ERROR; 119 } 120 121 status_t DrmPassthruPlugIn::onTerminate(int uniqueId) { 122 ALOGV("DrmPassthruPlugIn::onTerminate : %d", uniqueId); 123 return DRM_NO_ERROR; 124 } 125 126 DrmSupportInfo* DrmPassthruPlugIn::onGetSupportInfo(int uniqueId) { 127 ALOGV("DrmPassthruPlugIn::onGetSupportInfo : %d", uniqueId); 128 DrmSupportInfo* drmSupportInfo = new DrmSupportInfo(); 129 // Add mimetype's 130 drmSupportInfo->addMimeType(String8("application/vnd.passthru.drm")); 131 // Add File Suffixes 132 drmSupportInfo->addFileSuffix(String8(".passthru")); 133 // Add plug-in description 134 drmSupportInfo->setDescription(String8("Passthru plug-in")); 135 return drmSupportInfo; 136 } 137 138 status_t DrmPassthruPlugIn::onSaveRights(int uniqueId, const DrmRights& drmRights, 139 const String8& rightsPath, const String8& contentPath) { 140 ALOGV("DrmPassthruPlugIn::onSaveRights : %d", uniqueId); 141 return DRM_NO_ERROR; 142 } 143 144 DrmInfo* DrmPassthruPlugIn::onAcquireDrmInfo(int uniqueId, const DrmInfoRequest* drmInfoRequest) { 145 ALOGV("DrmPassthruPlugIn::onAcquireDrmInfo : %d", uniqueId); 146 DrmInfo* drmInfo = NULL; 147 148 if (NULL != drmInfoRequest) { 149 String8 dataString("dummy_acquistion_string"); 150 int length = dataString.length(); 151 char* data = NULL; 152 data = new char[length]; 153 memcpy(data, dataString.string(), length); 154 drmInfo = new DrmInfo(drmInfoRequest->getInfoType(), 155 DrmBuffer(data, length), drmInfoRequest->getMimeType()); 156 } 157 return drmInfo; 158 } 159 160 bool DrmPassthruPlugIn::onCanHandle(int uniqueId, const String8& path) { 161 ALOGV("DrmPassthruPlugIn::canHandle: %s ", path.string()); 162 String8 extension = path.getPathExtension(); 163 extension.toLower(); 164 return (String8(".passthru") == extension); 165 } 166 167 String8 DrmPassthruPlugIn::onGetOriginalMimeType(int uniqueId, const String8& path, int fd) { 168 ALOGV("DrmPassthruPlugIn::onGetOriginalMimeType() : %d", uniqueId); 169 return String8("video/passthru"); 170 } 171 172 int DrmPassthruPlugIn::onGetDrmObjectType( 173 int uniqueId, const String8& path, const String8& mimeType) { 174 ALOGV("DrmPassthruPlugIn::onGetDrmObjectType() : %d", uniqueId); 175 return DrmObjectType::UNKNOWN; 176 } 177 178 int DrmPassthruPlugIn::onCheckRightsStatus(int uniqueId, const String8& path, int action) { 179 ALOGV("DrmPassthruPlugIn::onCheckRightsStatus() : %d", uniqueId); 180 int rightsStatus = RightsStatus::RIGHTS_VALID; 181 return rightsStatus; 182 } 183 184 status_t DrmPassthruPlugIn::onConsumeRights(int uniqueId, DecryptHandle* decryptHandle, 185 int action, bool reserve) { 186 ALOGV("DrmPassthruPlugIn::onConsumeRights() : %d", uniqueId); 187 return DRM_NO_ERROR; 188 } 189 190 status_t DrmPassthruPlugIn::onSetPlaybackStatus(int uniqueId, DecryptHandle* decryptHandle, 191 int playbackStatus, int64_t position) { 192 ALOGV("DrmPassthruPlugIn::onSetPlaybackStatus() : %d", uniqueId); 193 return DRM_NO_ERROR; 194 } 195 196 bool DrmPassthruPlugIn::onValidateAction(int uniqueId, const String8& path, 197 int action, const ActionDescription& description) { 198 ALOGV("DrmPassthruPlugIn::onValidateAction() : %d", uniqueId); 199 return true; 200 } 201 202 status_t DrmPassthruPlugIn::onRemoveRights(int uniqueId, const String8& path) { 203 ALOGV("DrmPassthruPlugIn::onRemoveRights() : %d", uniqueId); 204 return DRM_NO_ERROR; 205 } 206 207 status_t DrmPassthruPlugIn::onRemoveAllRights(int uniqueId) { 208 ALOGV("DrmPassthruPlugIn::onRemoveAllRights() : %d", uniqueId); 209 return DRM_NO_ERROR; 210 } 211 212 status_t DrmPassthruPlugIn::onOpenConvertSession(int uniqueId, int convertId) { 213 ALOGV("DrmPassthruPlugIn::onOpenConvertSession() : %d", uniqueId); 214 return DRM_NO_ERROR; 215 } 216 217 DrmConvertedStatus* DrmPassthruPlugIn::onConvertData( 218 int uniqueId, int convertId, const DrmBuffer* inputData) { 219 ALOGV("DrmPassthruPlugIn::onConvertData() : %d", uniqueId); 220 DrmBuffer* convertedData = NULL; 221 222 if (NULL != inputData && 0 < inputData->length) { 223 int length = inputData->length; 224 char* data = NULL; 225 data = new char[length]; 226 convertedData = new DrmBuffer(data, length); 227 memcpy(convertedData->data, inputData->data, length); 228 } 229 return new DrmConvertedStatus(DrmConvertedStatus::STATUS_OK, convertedData, 0 /*offset*/); 230 } 231 232 DrmConvertedStatus* DrmPassthruPlugIn::onCloseConvertSession(int uniqueId, int convertId) { 233 ALOGV("DrmPassthruPlugIn::onCloseConvertSession() : %d", uniqueId); 234 return new DrmConvertedStatus(DrmConvertedStatus::STATUS_OK, NULL, 0 /*offset*/); 235 } 236 237 status_t DrmPassthruPlugIn::onOpenDecryptSession( 238 int uniqueId, DecryptHandle* decryptHandle, int fd, off64_t offset, off64_t length) { 239 ALOGV("DrmPassthruPlugIn::onOpenDecryptSession() : %d", uniqueId); 240 241 #ifdef ENABLE_PASSTHRU_DECRYPTION 242 decryptHandle->mimeType = String8("video/passthru"); 243 decryptHandle->decryptApiType = DecryptApiType::ELEMENTARY_STREAM_BASED; 244 decryptHandle->status = DRM_NO_ERROR; 245 decryptHandle->decryptInfo = NULL; 246 return DRM_NO_ERROR; 247 #endif 248 249 return DRM_ERROR_CANNOT_HANDLE; 250 } 251 252 status_t DrmPassthruPlugIn::onOpenDecryptSession( 253 int uniqueId, DecryptHandle* decryptHandle, const char* uri) { 254 return DRM_ERROR_CANNOT_HANDLE; 255 } 256 257 status_t DrmPassthruPlugIn::onCloseDecryptSession(int uniqueId, DecryptHandle* decryptHandle) { 258 ALOGV("DrmPassthruPlugIn::onCloseDecryptSession() : %d", uniqueId); 259 if (NULL != decryptHandle) { 260 if (NULL != decryptHandle->decryptInfo) { 261 delete decryptHandle->decryptInfo; decryptHandle->decryptInfo = NULL; 262 } 263 delete decryptHandle; decryptHandle = NULL; 264 } 265 return DRM_NO_ERROR; 266 } 267 268 status_t DrmPassthruPlugIn::onInitializeDecryptUnit(int uniqueId, DecryptHandle* decryptHandle, 269 int decryptUnitId, const DrmBuffer* headerInfo) { 270 ALOGV("DrmPassthruPlugIn::onInitializeDecryptUnit() : %d", uniqueId); 271 return DRM_NO_ERROR; 272 } 273 274 status_t DrmPassthruPlugIn::onDecrypt(int uniqueId, DecryptHandle* decryptHandle, 275 int decryptUnitId, const DrmBuffer* encBuffer, DrmBuffer** decBuffer, DrmBuffer* IV) { 276 ALOGV("DrmPassthruPlugIn::onDecrypt() : %d", uniqueId); 277 /** 278 * As a workaround implementation passthru would copy the given 279 * encrypted buffer as it is to decrypted buffer. Note, decBuffer 280 * memory has to be allocated by the caller. 281 */ 282 if (NULL != (*decBuffer) && 0 < (*decBuffer)->length) { 283 if ((*decBuffer)->length >= encBuffer->length) { 284 memcpy((*decBuffer)->data, encBuffer->data, encBuffer->length); 285 (*decBuffer)->length = encBuffer->length; 286 } else { 287 ALOGE("decBuffer size (%d) too small to hold %d bytes", 288 (*decBuffer)->length, encBuffer->length); 289 return DRM_ERROR_UNKNOWN; 290 } 291 } 292 return DRM_NO_ERROR; 293 } 294 295 status_t DrmPassthruPlugIn::onFinalizeDecryptUnit( 296 int uniqueId, DecryptHandle* decryptHandle, int decryptUnitId) { 297 ALOGV("DrmPassthruPlugIn::onFinalizeDecryptUnit() : %d", uniqueId); 298 return DRM_NO_ERROR; 299 } 300 301 ssize_t DrmPassthruPlugIn::onPread(int uniqueId, DecryptHandle* decryptHandle, 302 void* buffer, ssize_t numBytes, off64_t offset) { 303 ALOGV("DrmPassthruPlugIn::onPread() : %d", uniqueId); 304 return 0; 305 } 306 307