DrmManager.cpp revision 9d2f386dd2885eaffa11fd494ae258bb09fe6397
11320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci/* 21320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci * Copyright (C) 2010 The Android Open Source Project 31320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci * 41320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci * Licensed under the Apache License, Version 2.0 (the "License"); 51320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci * you may not use this file except in compliance with the License. 61320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci * You may obtain a copy of the License at 71320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci * 81320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci * http://www.apache.org/licenses/LICENSE-2.0 91320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci * 101320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci * Unless required by applicable law or agreed to in writing, software 111320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci * distributed under the License is distributed on an "AS IS" BASIS, 121320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 131320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci * See the License for the specific language governing permissions and 141320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci * limitations under the License. 151320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci */ 161320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 171320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci//#define LOG_NDEBUG 0 181320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#define LOG_TAG "DrmManager(Native)" 191320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#include "utils/Log.h" 201320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 211320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#include <utils/String8.h> 221320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#include <drm/DrmInfo.h> 231320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#include <drm/DrmInfoEvent.h> 241320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#include <drm/DrmRights.h> 251320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#include <drm/DrmConstraints.h> 261320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#include <drm/DrmMetadata.h> 271320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#include <drm/DrmInfoStatus.h> 281320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#include <drm/DrmInfoRequest.h> 291320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#include <drm/DrmSupportInfo.h> 301320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#include <drm/DrmConvertedStatus.h> 311320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#include <IDrmEngine.h> 321320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 331320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#include "DrmManager.h" 341320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#include "ReadWriteUtils.h" 351320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 361320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#define DECRYPT_FILE_ERROR -1 371320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 381320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucciusing namespace android; 391320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 401320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucciconst String8 DrmManager::EMPTY_STRING(""); 411320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 421320f92c476a1ad9d19dba2a48c72b75566198e9Primiano TucciDrmManager::DrmManager() : 431320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci mDecryptSessionId(0), 441320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci mConvertId(0) { 451320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 461320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci} 471320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 481320f92c476a1ad9d19dba2a48c72b75566198e9Primiano TucciDrmManager::~DrmManager() { 491320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 501320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci} 511320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 521320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucciint DrmManager::addUniqueId(bool isNative) { 531320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci Mutex::Autolock _l(mLock); 541320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 551320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci int temp = 0; 561320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci bool foundUniqueId = false; 571320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci const int size = mUniqueIdVector.size(); 581320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci const int uniqueIdRange = 0xfff; 591320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci int maxLoopTimes = (uniqueIdRange - 1) / 2; 601320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci srand(time(NULL)); 611320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 621320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci while (!foundUniqueId) { 631320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci temp = rand() & uniqueIdRange; 641320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 651320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci if (isNative) { 661320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci // set a flag to differentiate DrmManagerClient 671320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci // created from native side and java side 681320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci temp |= 0x1000; 691320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci } 701320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 711320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci int index = 0; 721320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci for (; index < size; ++index) { 731320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci if (mUniqueIdVector.itemAt(index) == temp) { 741320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci foundUniqueId = false; 751320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci break; 761320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci } 771320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci } 781320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci if (index == size) { 791320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci foundUniqueId = true; 801320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci } 811320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 821320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci maxLoopTimes --; 831320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci LOG_FATAL_IF(maxLoopTimes <= 0, "cannot find an unique ID for this session"); 841320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci } 851320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 861320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci mUniqueIdVector.push(temp); 871320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci return temp; 881320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci} 891320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 901320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tuccivoid DrmManager::removeUniqueId(int uniqueId) { 911320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci Mutex::Autolock _l(mLock); 921320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci for (unsigned int i = 0; i < mUniqueIdVector.size(); i++) { 931320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci if (uniqueId == mUniqueIdVector.itemAt(i)) { 941320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci mUniqueIdVector.removeAt(i); 951320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci break; 961320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci } 971320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci } 981320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci} 99 100status_t DrmManager::loadPlugIns() { 101 102 String8 vendorPluginDirPath("/vendor/lib/drm"); 103 loadPlugIns(vendorPluginDirPath); 104 105 String8 pluginDirPath("/system/lib/drm"); 106 loadPlugIns(pluginDirPath); 107 return DRM_NO_ERROR; 108 109} 110 111status_t DrmManager::loadPlugIns(const String8& plugInDirPath) { 112 mPlugInManager.loadPlugIns(plugInDirPath); 113 Vector<String8> plugInPathList = mPlugInManager.getPlugInIdList(); 114 for (unsigned int i = 0; i < plugInPathList.size(); ++i) { 115 String8 plugInPath = plugInPathList[i]; 116 DrmSupportInfo* info = mPlugInManager.getPlugIn(plugInPath).getSupportInfo(0); 117 if (NULL != info) { 118 if (mSupportInfoToPlugInIdMap.indexOfKey(*info) < 0) { 119 mSupportInfoToPlugInIdMap.add(*info, plugInPath); 120 } 121 delete info; 122 } 123 } 124 return DRM_NO_ERROR; 125} 126 127status_t DrmManager::unloadPlugIns() { 128 Mutex::Autolock _l(mLock); 129 mConvertSessionMap.clear(); 130 mDecryptSessionMap.clear(); 131 mPlugInManager.unloadPlugIns(); 132 mSupportInfoToPlugInIdMap.clear(); 133 return DRM_NO_ERROR; 134} 135 136status_t DrmManager::setDrmServiceListener( 137 int uniqueId, const sp<IDrmServiceListener>& drmServiceListener) { 138 Mutex::Autolock _l(mListenerLock); 139 if (NULL != drmServiceListener.get()) { 140 mServiceListeners.add(uniqueId, drmServiceListener); 141 } else { 142 mServiceListeners.removeItem(uniqueId); 143 } 144 return DRM_NO_ERROR; 145} 146 147void DrmManager::addClient(int uniqueId) { 148 Mutex::Autolock _l(mLock); 149 if (!mSupportInfoToPlugInIdMap.isEmpty()) { 150 Vector<String8> plugInIdList = mPlugInManager.getPlugInIdList(); 151 for (unsigned int index = 0; index < plugInIdList.size(); index++) { 152 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInIdList.itemAt(index)); 153 rDrmEngine.initialize(uniqueId); 154 rDrmEngine.setOnInfoListener(uniqueId, this); 155 } 156 } 157} 158 159void DrmManager::removeClient(int uniqueId) { 160 Mutex::Autolock _l(mLock); 161 Vector<String8> plugInIdList = mPlugInManager.getPlugInIdList(); 162 for (unsigned int index = 0; index < plugInIdList.size(); index++) { 163 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInIdList.itemAt(index)); 164 rDrmEngine.terminate(uniqueId); 165 } 166} 167 168DrmConstraints* DrmManager::getConstraints(int uniqueId, const String8* path, const int action) { 169 Mutex::Autolock _l(mLock); 170 const String8 plugInId = getSupportedPlugInIdFromPath(uniqueId, *path); 171 if (EMPTY_STRING != plugInId) { 172 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 173 return rDrmEngine.getConstraints(uniqueId, path, action); 174 } 175 return NULL; 176} 177 178DrmMetadata* DrmManager::getMetadata(int uniqueId, const String8* path) { 179 Mutex::Autolock _l(mLock); 180 const String8 plugInId = getSupportedPlugInIdFromPath(uniqueId, *path); 181 if (EMPTY_STRING != plugInId) { 182 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 183 return rDrmEngine.getMetadata(uniqueId, path); 184 } 185 return NULL; 186} 187 188status_t DrmManager::installDrmEngine(int uniqueId, const String8& absolutePath) { 189 Mutex::Autolock _l(mLock); 190 mPlugInManager.loadPlugIn(absolutePath); 191 192 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(absolutePath); 193 rDrmEngine.initialize(uniqueId); 194 rDrmEngine.setOnInfoListener(uniqueId, this); 195 196 DrmSupportInfo* info = rDrmEngine.getSupportInfo(0); 197 mSupportInfoToPlugInIdMap.add(*info, absolutePath); 198 delete info; 199 200 return DRM_NO_ERROR; 201} 202 203bool DrmManager::canHandle(int uniqueId, const String8& path, const String8& mimeType) { 204 Mutex::Autolock _l(mLock); 205 const String8 plugInId = getSupportedPlugInId(mimeType); 206 bool result = (EMPTY_STRING != plugInId) ? true : false; 207 208 if (0 < path.length()) { 209 if (result) { 210 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 211 result = rDrmEngine.canHandle(uniqueId, path); 212 } else { 213 String8 extension = path.getPathExtension(); 214 if (String8("") != extension) { 215 result = canHandle(uniqueId, path); 216 } 217 } 218 } 219 return result; 220} 221 222DrmInfoStatus* DrmManager::processDrmInfo(int uniqueId, const DrmInfo* drmInfo) { 223 Mutex::Autolock _l(mLock); 224 const String8 plugInId = getSupportedPlugInId(drmInfo->getMimeType()); 225 if (EMPTY_STRING != plugInId) { 226 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 227 return rDrmEngine.processDrmInfo(uniqueId, drmInfo); 228 } 229 return NULL; 230} 231 232bool DrmManager::canHandle(int uniqueId, const String8& path) { 233 bool result = false; 234 Vector<String8> plugInPathList = mPlugInManager.getPlugInIdList(); 235 236 for (unsigned int i = 0; i < plugInPathList.size(); ++i) { 237 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInPathList[i]); 238 result = rDrmEngine.canHandle(uniqueId, path); 239 240 if (result) { 241 break; 242 } 243 } 244 return result; 245} 246 247DrmInfo* DrmManager::acquireDrmInfo(int uniqueId, const DrmInfoRequest* drmInfoRequest) { 248 Mutex::Autolock _l(mLock); 249 const String8 plugInId = getSupportedPlugInId(drmInfoRequest->getMimeType()); 250 if (EMPTY_STRING != plugInId) { 251 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 252 return rDrmEngine.acquireDrmInfo(uniqueId, drmInfoRequest); 253 } 254 return NULL; 255} 256 257status_t DrmManager::saveRights(int uniqueId, const DrmRights& drmRights, 258 const String8& rightsPath, const String8& contentPath) { 259 Mutex::Autolock _l(mLock); 260 const String8 plugInId = getSupportedPlugInId(drmRights.getMimeType()); 261 status_t result = DRM_ERROR_UNKNOWN; 262 if (EMPTY_STRING != plugInId) { 263 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 264 result = rDrmEngine.saveRights(uniqueId, drmRights, rightsPath, contentPath); 265 } 266 return result; 267} 268 269String8 DrmManager::getOriginalMimeType(int uniqueId, const String8& path) { 270 Mutex::Autolock _l(mLock); 271 const String8 plugInId = getSupportedPlugInIdFromPath(uniqueId, path); 272 if (EMPTY_STRING != plugInId) { 273 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 274 return rDrmEngine.getOriginalMimeType(uniqueId, path); 275 } 276 return EMPTY_STRING; 277} 278 279int DrmManager::getDrmObjectType(int uniqueId, const String8& path, const String8& mimeType) { 280 Mutex::Autolock _l(mLock); 281 const String8 plugInId = getSupportedPlugInId(uniqueId, path, mimeType); 282 if (EMPTY_STRING != plugInId) { 283 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 284 return rDrmEngine.getDrmObjectType(uniqueId, path, mimeType); 285 } 286 return DrmObjectType::UNKNOWN; 287} 288 289int DrmManager::checkRightsStatus(int uniqueId, const String8& path, int action) { 290 Mutex::Autolock _l(mLock); 291 const String8 plugInId = getSupportedPlugInIdFromPath(uniqueId, path); 292 if (EMPTY_STRING != plugInId) { 293 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 294 return rDrmEngine.checkRightsStatus(uniqueId, path, action); 295 } 296 return RightsStatus::RIGHTS_INVALID; 297} 298 299status_t DrmManager::consumeRights( 300 int uniqueId, DecryptHandle* decryptHandle, int action, bool reserve) { 301 status_t result = DRM_ERROR_UNKNOWN; 302 Mutex::Autolock _l(mDecryptLock); 303 if (mDecryptSessionMap.indexOfKey(decryptHandle->decryptId) != NAME_NOT_FOUND) { 304 IDrmEngine* drmEngine = mDecryptSessionMap.valueFor(decryptHandle->decryptId); 305 result = drmEngine->consumeRights(uniqueId, decryptHandle, action, reserve); 306 } 307 return result; 308} 309 310status_t DrmManager::setPlaybackStatus( 311 int uniqueId, DecryptHandle* decryptHandle, int playbackStatus, int64_t position) { 312 status_t result = DRM_ERROR_UNKNOWN; 313 Mutex::Autolock _l(mDecryptLock); 314 if (mDecryptSessionMap.indexOfKey(decryptHandle->decryptId) != NAME_NOT_FOUND) { 315 IDrmEngine* drmEngine = mDecryptSessionMap.valueFor(decryptHandle->decryptId); 316 result = drmEngine->setPlaybackStatus(uniqueId, decryptHandle, playbackStatus, position); 317 } 318 return result; 319} 320 321bool DrmManager::validateAction( 322 int uniqueId, const String8& path, int action, const ActionDescription& description) { 323 Mutex::Autolock _l(mLock); 324 const String8 plugInId = getSupportedPlugInIdFromPath(uniqueId, path); 325 if (EMPTY_STRING != plugInId) { 326 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 327 return rDrmEngine.validateAction(uniqueId, path, action, description); 328 } 329 return false; 330} 331 332status_t DrmManager::removeRights(int uniqueId, const String8& path) { 333 Mutex::Autolock _l(mLock); 334 const String8 plugInId = getSupportedPlugInIdFromPath(uniqueId, path); 335 status_t result = DRM_ERROR_UNKNOWN; 336 if (EMPTY_STRING != plugInId) { 337 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 338 result = rDrmEngine.removeRights(uniqueId, path); 339 } 340 return result; 341} 342 343status_t DrmManager::removeAllRights(int uniqueId) { 344 Vector<String8> plugInIdList = mPlugInManager.getPlugInIdList(); 345 status_t result = DRM_ERROR_UNKNOWN; 346 for (unsigned int index = 0; index < plugInIdList.size(); index++) { 347 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInIdList.itemAt(index)); 348 result = rDrmEngine.removeAllRights(uniqueId); 349 if (DRM_NO_ERROR != result) { 350 break; 351 } 352 } 353 return result; 354} 355 356int DrmManager::openConvertSession(int uniqueId, const String8& mimeType) { 357 Mutex::Autolock _l(mConvertLock); 358 int convertId = -1; 359 360 const String8 plugInId = getSupportedPlugInId(mimeType); 361 if (EMPTY_STRING != plugInId) { 362 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 363 364 if (DRM_NO_ERROR == rDrmEngine.openConvertSession(uniqueId, mConvertId + 1)) { 365 ++mConvertId; 366 convertId = mConvertId; 367 mConvertSessionMap.add(convertId, &rDrmEngine); 368 } 369 } 370 return convertId; 371} 372 373DrmConvertedStatus* DrmManager::convertData( 374 int uniqueId, int convertId, const DrmBuffer* inputData) { 375 DrmConvertedStatus *drmConvertedStatus = NULL; 376 377 Mutex::Autolock _l(mConvertLock); 378 if (mConvertSessionMap.indexOfKey(convertId) != NAME_NOT_FOUND) { 379 IDrmEngine* drmEngine = mConvertSessionMap.valueFor(convertId); 380 drmConvertedStatus = drmEngine->convertData(uniqueId, convertId, inputData); 381 } 382 return drmConvertedStatus; 383} 384 385DrmConvertedStatus* DrmManager::closeConvertSession(int uniqueId, int convertId) { 386 Mutex::Autolock _l(mConvertLock); 387 DrmConvertedStatus *drmConvertedStatus = NULL; 388 389 if (mConvertSessionMap.indexOfKey(convertId) != NAME_NOT_FOUND) { 390 IDrmEngine* drmEngine = mConvertSessionMap.valueFor(convertId); 391 drmConvertedStatus = drmEngine->closeConvertSession(uniqueId, convertId); 392 mConvertSessionMap.removeItem(convertId); 393 } 394 return drmConvertedStatus; 395} 396 397status_t DrmManager::getAllSupportInfo( 398 int uniqueId, int* length, DrmSupportInfo** drmSupportInfoArray) { 399 Mutex::Autolock _l(mLock); 400 Vector<String8> plugInPathList = mPlugInManager.getPlugInIdList(); 401 int size = plugInPathList.size(); 402 int validPlugins = 0; 403 404 if (0 < size) { 405 Vector<DrmSupportInfo> drmSupportInfoList; 406 407 for (int i = 0; i < size; ++i) { 408 String8 plugInPath = plugInPathList[i]; 409 DrmSupportInfo* drmSupportInfo 410 = mPlugInManager.getPlugIn(plugInPath).getSupportInfo(0); 411 if (NULL != drmSupportInfo) { 412 drmSupportInfoList.add(*drmSupportInfo); 413 delete drmSupportInfo; drmSupportInfo = NULL; 414 } 415 } 416 417 validPlugins = drmSupportInfoList.size(); 418 if (0 < validPlugins) { 419 *drmSupportInfoArray = new DrmSupportInfo[validPlugins]; 420 for (int i = 0; i < validPlugins; ++i) { 421 (*drmSupportInfoArray)[i] = drmSupportInfoList[i]; 422 } 423 } 424 } 425 *length = validPlugins; 426 return DRM_NO_ERROR; 427} 428 429DecryptHandle* DrmManager::openDecryptSession( 430 int uniqueId, int fd, off64_t offset, off64_t length, const char* mime) { 431 432 Mutex::Autolock _l(mDecryptLock); 433 status_t result = DRM_ERROR_CANNOT_HANDLE; 434 Vector<String8> plugInIdList = mPlugInManager.getPlugInIdList(); 435 436 DecryptHandle* handle = new DecryptHandle(); 437 if (NULL != handle) { 438 handle->decryptId = mDecryptSessionId + 1; 439 440 for (unsigned int index = 0; index < plugInIdList.size(); index++) { 441 String8 plugInId = plugInIdList.itemAt(index); 442 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 443 result = rDrmEngine.openDecryptSession(uniqueId, handle, fd, offset, length, mime); 444 445 if (DRM_NO_ERROR == result) { 446 ++mDecryptSessionId; 447 mDecryptSessionMap.add(mDecryptSessionId, &rDrmEngine); 448 break; 449 } 450 } 451 } 452 if (DRM_NO_ERROR != result) { 453 delete handle; handle = NULL; 454 } 455 return handle; 456} 457 458DecryptHandle* DrmManager::openDecryptSession( 459 int uniqueId, const char* uri, const char* mime) { 460 Mutex::Autolock _l(mDecryptLock); 461 status_t result = DRM_ERROR_CANNOT_HANDLE; 462 Vector<String8> plugInIdList = mPlugInManager.getPlugInIdList(); 463 464 DecryptHandle* handle = new DecryptHandle(); 465 if (NULL != handle) { 466 handle->decryptId = mDecryptSessionId + 1; 467 468 for (unsigned int index = 0; index < plugInIdList.size(); index++) { 469 String8 plugInId = plugInIdList.itemAt(index); 470 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 471 result = rDrmEngine.openDecryptSession(uniqueId, handle, uri, mime); 472 473 if (DRM_NO_ERROR == result) { 474 ++mDecryptSessionId; 475 mDecryptSessionMap.add(mDecryptSessionId, &rDrmEngine); 476 break; 477 } 478 } 479 } 480 if (DRM_NO_ERROR != result) { 481 delete handle; handle = NULL; 482 ALOGV("DrmManager::openDecryptSession: no capable plug-in found"); 483 } 484 return handle; 485} 486 487status_t DrmManager::closeDecryptSession(int uniqueId, DecryptHandle* decryptHandle) { 488 Mutex::Autolock _l(mDecryptLock); 489 status_t result = DRM_ERROR_UNKNOWN; 490 if (mDecryptSessionMap.indexOfKey(decryptHandle->decryptId) != NAME_NOT_FOUND) { 491 IDrmEngine* drmEngine = mDecryptSessionMap.valueFor(decryptHandle->decryptId); 492 result = drmEngine->closeDecryptSession(uniqueId, decryptHandle); 493 if (DRM_NO_ERROR == result) { 494 mDecryptSessionMap.removeItem(decryptHandle->decryptId); 495 } 496 } 497 return result; 498} 499 500status_t DrmManager::initializeDecryptUnit( 501 int uniqueId, DecryptHandle* decryptHandle, int decryptUnitId, const DrmBuffer* headerInfo) { 502 status_t result = DRM_ERROR_UNKNOWN; 503 Mutex::Autolock _l(mDecryptLock); 504 if (mDecryptSessionMap.indexOfKey(decryptHandle->decryptId) != NAME_NOT_FOUND) { 505 IDrmEngine* drmEngine = mDecryptSessionMap.valueFor(decryptHandle->decryptId); 506 result = drmEngine->initializeDecryptUnit(uniqueId, decryptHandle, decryptUnitId, headerInfo); 507 } 508 return result; 509} 510 511status_t DrmManager::decrypt(int uniqueId, DecryptHandle* decryptHandle, int decryptUnitId, 512 const DrmBuffer* encBuffer, DrmBuffer** decBuffer, DrmBuffer* IV) { 513 status_t result = DRM_ERROR_UNKNOWN; 514 515 Mutex::Autolock _l(mDecryptLock); 516 if (mDecryptSessionMap.indexOfKey(decryptHandle->decryptId) != NAME_NOT_FOUND) { 517 IDrmEngine* drmEngine = mDecryptSessionMap.valueFor(decryptHandle->decryptId); 518 result = drmEngine->decrypt( 519 uniqueId, decryptHandle, decryptUnitId, encBuffer, decBuffer, IV); 520 } 521 return result; 522} 523 524status_t DrmManager::finalizeDecryptUnit( 525 int uniqueId, DecryptHandle* decryptHandle, int decryptUnitId) { 526 status_t result = DRM_ERROR_UNKNOWN; 527 Mutex::Autolock _l(mDecryptLock); 528 if (mDecryptSessionMap.indexOfKey(decryptHandle->decryptId) != NAME_NOT_FOUND) { 529 IDrmEngine* drmEngine = mDecryptSessionMap.valueFor(decryptHandle->decryptId); 530 result = drmEngine->finalizeDecryptUnit(uniqueId, decryptHandle, decryptUnitId); 531 } 532 return result; 533} 534 535ssize_t DrmManager::pread(int uniqueId, DecryptHandle* decryptHandle, 536 void* buffer, ssize_t numBytes, off64_t offset) { 537 ssize_t result = DECRYPT_FILE_ERROR; 538 539 Mutex::Autolock _l(mDecryptLock); 540 if (mDecryptSessionMap.indexOfKey(decryptHandle->decryptId) != NAME_NOT_FOUND) { 541 IDrmEngine* drmEngine = mDecryptSessionMap.valueFor(decryptHandle->decryptId); 542 result = drmEngine->pread(uniqueId, decryptHandle, buffer, numBytes, offset); 543 } 544 return result; 545} 546 547String8 DrmManager::getSupportedPlugInId( 548 int uniqueId, const String8& path, const String8& mimeType) { 549 String8 plugInId(""); 550 551 if (EMPTY_STRING != mimeType) { 552 plugInId = getSupportedPlugInId(mimeType); 553 } else { 554 plugInId = getSupportedPlugInIdFromPath(uniqueId, path); 555 } 556 return plugInId; 557} 558 559String8 DrmManager::getSupportedPlugInId(const String8& mimeType) { 560 String8 plugInId(""); 561 562 if (EMPTY_STRING != mimeType) { 563 for (unsigned int index = 0; index < mSupportInfoToPlugInIdMap.size(); index++) { 564 const DrmSupportInfo& drmSupportInfo = mSupportInfoToPlugInIdMap.keyAt(index); 565 566 if (drmSupportInfo.isSupportedMimeType(mimeType)) { 567 plugInId = mSupportInfoToPlugInIdMap.valueFor(drmSupportInfo); 568 break; 569 } 570 } 571 } 572 return plugInId; 573} 574 575String8 DrmManager::getSupportedPlugInIdFromPath(int uniqueId, const String8& path) { 576 String8 plugInId(""); 577 const String8 fileSuffix = path.getPathExtension(); 578 579 for (unsigned int index = 0; index < mSupportInfoToPlugInIdMap.size(); index++) { 580 const DrmSupportInfo& drmSupportInfo = mSupportInfoToPlugInIdMap.keyAt(index); 581 582 if (drmSupportInfo.isSupportedFileSuffix(fileSuffix)) { 583 String8 key = mSupportInfoToPlugInIdMap.valueFor(drmSupportInfo); 584 IDrmEngine& drmEngine = mPlugInManager.getPlugIn(key); 585 586 if (drmEngine.canHandle(uniqueId, path)) { 587 plugInId = key; 588 break; 589 } 590 } 591 } 592 return plugInId; 593} 594 595void DrmManager::onInfo(const DrmInfoEvent& event) { 596 Mutex::Autolock _l(mListenerLock); 597 for (unsigned int index = 0; index < mServiceListeners.size(); index++) { 598 int uniqueId = mServiceListeners.keyAt(index); 599 600 if (uniqueId == event.getUniqueId()) { 601 sp<IDrmServiceListener> serviceListener = mServiceListeners.valueFor(uniqueId); 602 serviceListener->notify(event); 603 } 604 } 605} 606 607