DrmManager.cpp revision 8d2577b9ac2f95f218db59a78447efd3c6a742dd
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 "DrmManager(Native)" 19#include "utils/Log.h" 20 21#include <utils/String8.h> 22#include <drm/DrmInfo.h> 23#include <drm/DrmInfoEvent.h> 24#include <drm/DrmRights.h> 25#include <drm/DrmConstraints.h> 26#include <drm/DrmMetadata.h> 27#include <drm/DrmInfoStatus.h> 28#include <drm/DrmInfoRequest.h> 29#include <drm/DrmSupportInfo.h> 30#include <drm/DrmConvertedStatus.h> 31#include <IDrmEngine.h> 32 33#include "DrmManager.h" 34#include "ReadWriteUtils.h" 35 36#define DECRYPT_FILE_ERROR -1 37 38using namespace android; 39 40const String8 DrmManager::EMPTY_STRING(""); 41 42DrmManager::DrmManager() : 43 mDecryptSessionId(0), 44 mConvertId(0) { 45 46} 47 48DrmManager::~DrmManager() { 49 50} 51 52int DrmManager::addUniqueId(int uniqueId) { 53 Mutex::Autolock _l(mLock); 54 if (0 == uniqueId) { 55 int temp = 0; 56 bool foundUniqueId = false; 57 srand(time(NULL)); 58 59 while (!foundUniqueId) { 60 const int size = mUniqueIdVector.size(); 61 temp = rand() % 100; 62 63 int index = 0; 64 for (; index < size; ++index) { 65 if (mUniqueIdVector.itemAt(index) == temp) { 66 foundUniqueId = false; 67 break; 68 } 69 } 70 if (index == size) { 71 foundUniqueId = true; 72 } 73 } 74 uniqueId = temp; 75 } 76 mUniqueIdVector.push(uniqueId); 77 return uniqueId; 78} 79 80void DrmManager::removeUniqueId(int uniqueId) { 81 Mutex::Autolock _l(mLock); 82 for (unsigned int i = 0; i < mUniqueIdVector.size(); i++) { 83 if (uniqueId == mUniqueIdVector.itemAt(i)) { 84 mUniqueIdVector.removeAt(i); 85 break; 86 } 87 } 88} 89 90status_t DrmManager::loadPlugIns() { 91 String8 pluginDirPath("/system/lib/drm"); 92 return loadPlugIns(pluginDirPath); 93} 94 95status_t DrmManager::loadPlugIns(const String8& plugInDirPath) { 96 if (mSupportInfoToPlugInIdMap.isEmpty()) { 97 mPlugInManager.loadPlugIns(plugInDirPath); 98 Vector<String8> plugInPathList = mPlugInManager.getPlugInIdList(); 99 for (unsigned int i = 0; i < plugInPathList.size(); ++i) { 100 String8 plugInPath = plugInPathList[i]; 101 DrmSupportInfo* info = mPlugInManager.getPlugIn(plugInPath).getSupportInfo(0); 102 if (NULL != info) { 103 mSupportInfoToPlugInIdMap.add(*info, plugInPath); 104 } 105 } 106 } 107 return DRM_NO_ERROR; 108} 109 110status_t DrmManager::unloadPlugIns() { 111 Mutex::Autolock _l(mLock); 112 mConvertSessionMap.clear(); 113 mDecryptSessionMap.clear(); 114 mPlugInManager.unloadPlugIns(); 115 mSupportInfoToPlugInIdMap.clear(); 116 return DRM_NO_ERROR; 117} 118 119status_t DrmManager::setDrmServiceListener( 120 int uniqueId, const sp<IDrmServiceListener>& drmServiceListener) { 121 Mutex::Autolock _l(mLock); 122 if (NULL != drmServiceListener.get()) { 123 mServiceListeners.add(uniqueId, drmServiceListener); 124 } else { 125 mServiceListeners.removeItem(uniqueId); 126 } 127 return DRM_NO_ERROR; 128} 129 130void DrmManager::addClient(int uniqueId) { 131 Mutex::Autolock _l(mLock); 132 if (!mSupportInfoToPlugInIdMap.isEmpty()) { 133 Vector<String8> plugInIdList = mPlugInManager.getPlugInIdList(); 134 for (unsigned int index = 0; index < plugInIdList.size(); index++) { 135 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInIdList.itemAt(index)); 136 rDrmEngine.initialize(uniqueId); 137 rDrmEngine.setOnInfoListener(uniqueId, this); 138 } 139 } 140} 141 142void DrmManager::removeClient(int uniqueId) { 143 Mutex::Autolock _l(mLock); 144 Vector<String8> plugInIdList = mPlugInManager.getPlugInIdList(); 145 for (unsigned int index = 0; index < plugInIdList.size(); index++) { 146 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInIdList.itemAt(index)); 147 rDrmEngine.terminate(uniqueId); 148 } 149} 150 151DrmConstraints* DrmManager::getConstraints(int uniqueId, const String8* path, const int action) { 152 Mutex::Autolock _l(mLock); 153 const String8 plugInId = getSupportedPlugInIdFromPath(uniqueId, *path); 154 if (EMPTY_STRING != plugInId) { 155 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 156 return rDrmEngine.getConstraints(uniqueId, path, action); 157 } 158 return NULL; 159} 160 161DrmMetadata* DrmManager::getMetadata(int uniqueId, const String8* path) { 162 Mutex::Autolock _l(mLock); 163 const String8 plugInId = getSupportedPlugInIdFromPath(uniqueId, *path); 164 if (EMPTY_STRING != plugInId) { 165 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 166 return rDrmEngine.getMetadata(uniqueId, path); 167 } 168 return NULL; 169} 170 171status_t DrmManager::installDrmEngine(int uniqueId, const String8& absolutePath) { 172 Mutex::Autolock _l(mLock); 173 mPlugInManager.loadPlugIn(absolutePath); 174 175 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(absolutePath); 176 rDrmEngine.initialize(uniqueId); 177 rDrmEngine.setOnInfoListener(uniqueId, this); 178 179 DrmSupportInfo* info = rDrmEngine.getSupportInfo(0); 180 mSupportInfoToPlugInIdMap.add(*info, absolutePath); 181 182 return DRM_NO_ERROR; 183} 184 185bool DrmManager::canHandle(int uniqueId, const String8& path, const String8& mimeType) { 186 Mutex::Autolock _l(mLock); 187 const String8 plugInId = getSupportedPlugInId(mimeType); 188 bool result = (EMPTY_STRING != plugInId) ? true : false; 189 190 if (0 < path.length()) { 191 if (result) { 192 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 193 result = rDrmEngine.canHandle(uniqueId, path); 194 } else { 195 String8 extension = path.getPathExtension(); 196 if (String8("") != extension) { 197 result = canHandle(uniqueId, path); 198 } 199 } 200 } 201 return result; 202} 203 204DrmInfoStatus* DrmManager::processDrmInfo(int uniqueId, const DrmInfo* drmInfo) { 205 Mutex::Autolock _l(mLock); 206 const String8 plugInId = getSupportedPlugInId(drmInfo->getMimeType()); 207 if (EMPTY_STRING != plugInId) { 208 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 209 return rDrmEngine.processDrmInfo(uniqueId, drmInfo); 210 } 211 return NULL; 212} 213 214bool DrmManager::canHandle(int uniqueId, const String8& path) { 215 bool result = false; 216 Vector<String8> plugInPathList = mPlugInManager.getPlugInIdList(); 217 218 for (unsigned int i = 0; i < plugInPathList.size(); ++i) { 219 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInPathList[i]); 220 result = rDrmEngine.canHandle(uniqueId, path); 221 222 if (result) { 223 break; 224 } 225 } 226 return result; 227} 228 229DrmInfo* DrmManager::acquireDrmInfo(int uniqueId, const DrmInfoRequest* drmInfoRequest) { 230 Mutex::Autolock _l(mLock); 231 const String8 plugInId = getSupportedPlugInId(drmInfoRequest->getMimeType()); 232 if (EMPTY_STRING != plugInId) { 233 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 234 return rDrmEngine.acquireDrmInfo(uniqueId, drmInfoRequest); 235 } 236 return NULL; 237} 238 239status_t DrmManager::saveRights(int uniqueId, const DrmRights& drmRights, 240 const String8& rightsPath, const String8& contentPath) { 241 Mutex::Autolock _l(mLock); 242 const String8 plugInId = getSupportedPlugInId(drmRights.getMimeType()); 243 status_t result = DRM_ERROR_UNKNOWN; 244 if (EMPTY_STRING != plugInId) { 245 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 246 result = rDrmEngine.saveRights(uniqueId, drmRights, rightsPath, contentPath); 247 } 248 return result; 249} 250 251String8 DrmManager::getOriginalMimeType(int uniqueId, const String8& path) { 252 Mutex::Autolock _l(mLock); 253 const String8 plugInId = getSupportedPlugInIdFromPath(uniqueId, path); 254 if (EMPTY_STRING != plugInId) { 255 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 256 return rDrmEngine.getOriginalMimeType(uniqueId, path); 257 } 258 return EMPTY_STRING; 259} 260 261int DrmManager::getDrmObjectType(int uniqueId, const String8& path, const String8& mimeType) { 262 Mutex::Autolock _l(mLock); 263 const String8 plugInId = getSupportedPlugInId(uniqueId, path, mimeType); 264 if (EMPTY_STRING != plugInId) { 265 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 266 return rDrmEngine.getDrmObjectType(uniqueId, path, mimeType); 267 } 268 return DrmObjectType::UNKNOWN; 269} 270 271int DrmManager::checkRightsStatus(int uniqueId, const String8& path, int action) { 272 Mutex::Autolock _l(mLock); 273 const String8 plugInId = getSupportedPlugInIdFromPath(uniqueId, path); 274 if (EMPTY_STRING != plugInId) { 275 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 276 return rDrmEngine.checkRightsStatus(uniqueId, path, action); 277 } 278 return RightsStatus::RIGHTS_INVALID; 279} 280 281status_t DrmManager::consumeRights( 282 int uniqueId, DecryptHandle* decryptHandle, int action, bool reserve) { 283 status_t result = DRM_ERROR_UNKNOWN; 284 Mutex::Autolock _l(mDecryptLock); 285 if (mDecryptSessionMap.indexOfKey(decryptHandle->decryptId) != NAME_NOT_FOUND) { 286 IDrmEngine* drmEngine = mDecryptSessionMap.valueFor(decryptHandle->decryptId); 287 result = drmEngine->consumeRights(uniqueId, decryptHandle, action, reserve); 288 } 289 return result; 290} 291 292status_t DrmManager::setPlaybackStatus( 293 int uniqueId, DecryptHandle* decryptHandle, int playbackStatus, int64_t position) { 294 status_t result = DRM_ERROR_UNKNOWN; 295 Mutex::Autolock _l(mDecryptLock); 296 if (mDecryptSessionMap.indexOfKey(decryptHandle->decryptId) != NAME_NOT_FOUND) { 297 IDrmEngine* drmEngine = mDecryptSessionMap.valueFor(decryptHandle->decryptId); 298 result = drmEngine->setPlaybackStatus(uniqueId, decryptHandle, playbackStatus, position); 299 } 300 return result; 301} 302 303bool DrmManager::validateAction( 304 int uniqueId, const String8& path, int action, const ActionDescription& description) { 305 Mutex::Autolock _l(mLock); 306 const String8 plugInId = getSupportedPlugInIdFromPath(uniqueId, path); 307 if (EMPTY_STRING != plugInId) { 308 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 309 return rDrmEngine.validateAction(uniqueId, path, action, description); 310 } 311 return false; 312} 313 314status_t DrmManager::removeRights(int uniqueId, const String8& path) { 315 Mutex::Autolock _l(mLock); 316 const String8 plugInId = getSupportedPlugInIdFromPath(uniqueId, path); 317 status_t result = DRM_ERROR_UNKNOWN; 318 if (EMPTY_STRING != plugInId) { 319 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 320 result = rDrmEngine.removeRights(uniqueId, path); 321 } 322 return result; 323} 324 325status_t DrmManager::removeAllRights(int uniqueId) { 326 Vector<String8> plugInIdList = mPlugInManager.getPlugInIdList(); 327 status_t result = DRM_ERROR_UNKNOWN; 328 for (unsigned int index = 0; index < plugInIdList.size(); index++) { 329 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInIdList.itemAt(index)); 330 result = rDrmEngine.removeAllRights(uniqueId); 331 if (DRM_NO_ERROR != result) { 332 break; 333 } 334 } 335 return result; 336} 337 338int DrmManager::openConvertSession(int uniqueId, const String8& mimeType) { 339 Mutex::Autolock _l(mConvertLock); 340 int convertId = -1; 341 342 const String8 plugInId = getSupportedPlugInId(mimeType); 343 if (EMPTY_STRING != plugInId) { 344 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 345 346 if (DRM_NO_ERROR == rDrmEngine.openConvertSession(uniqueId, mConvertId + 1)) { 347 ++mConvertId; 348 convertId = mConvertId; 349 mConvertSessionMap.add(convertId, &rDrmEngine); 350 } 351 } 352 return convertId; 353} 354 355DrmConvertedStatus* DrmManager::convertData( 356 int uniqueId, int convertId, const DrmBuffer* inputData) { 357 DrmConvertedStatus *drmConvertedStatus = NULL; 358 359 Mutex::Autolock _l(mConvertLock); 360 if (mConvertSessionMap.indexOfKey(convertId) != NAME_NOT_FOUND) { 361 IDrmEngine* drmEngine = mConvertSessionMap.valueFor(convertId); 362 drmConvertedStatus = drmEngine->convertData(uniqueId, convertId, inputData); 363 } 364 return drmConvertedStatus; 365} 366 367DrmConvertedStatus* DrmManager::closeConvertSession(int uniqueId, int convertId) { 368 Mutex::Autolock _l(mConvertLock); 369 DrmConvertedStatus *drmConvertedStatus = NULL; 370 371 if (mConvertSessionMap.indexOfKey(convertId) != NAME_NOT_FOUND) { 372 IDrmEngine* drmEngine = mConvertSessionMap.valueFor(convertId); 373 drmConvertedStatus = drmEngine->closeConvertSession(uniqueId, convertId); 374 mConvertSessionMap.removeItem(convertId); 375 } 376 return drmConvertedStatus; 377} 378 379status_t DrmManager::getAllSupportInfo( 380 int uniqueId, int* length, DrmSupportInfo** drmSupportInfoArray) { 381 Mutex::Autolock _l(mLock); 382 Vector<String8> plugInPathList = mPlugInManager.getPlugInIdList(); 383 int size = plugInPathList.size(); 384 int validPlugins = 0; 385 386 if (0 < size) { 387 Vector<DrmSupportInfo> drmSupportInfoList; 388 389 for (int i = 0; i < size; ++i) { 390 String8 plugInPath = plugInPathList[i]; 391 DrmSupportInfo* drmSupportInfo 392 = mPlugInManager.getPlugIn(plugInPath).getSupportInfo(0); 393 if (NULL != drmSupportInfo) { 394 drmSupportInfoList.add(*drmSupportInfo); 395 delete drmSupportInfo; drmSupportInfo = NULL; 396 } 397 } 398 399 validPlugins = drmSupportInfoList.size(); 400 if (0 < validPlugins) { 401 *drmSupportInfoArray = new DrmSupportInfo[validPlugins]; 402 for (int i = 0; i < validPlugins; ++i) { 403 (*drmSupportInfoArray)[i] = drmSupportInfoList[i]; 404 } 405 } 406 } 407 *length = validPlugins; 408 return DRM_NO_ERROR; 409} 410 411DecryptHandle* DrmManager::openDecryptSession(int uniqueId, int fd, off64_t offset, off64_t length) { 412 Mutex::Autolock _l(mDecryptLock); 413 status_t result = DRM_ERROR_CANNOT_HANDLE; 414 Vector<String8> plugInIdList = mPlugInManager.getPlugInIdList(); 415 416 DecryptHandle* handle = new DecryptHandle(); 417 if (NULL != handle) { 418 handle->decryptId = mDecryptSessionId + 1; 419 420 for (unsigned int index = 0; index < plugInIdList.size(); index++) { 421 String8 plugInId = plugInIdList.itemAt(index); 422 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 423 result = rDrmEngine.openDecryptSession(uniqueId, handle, fd, offset, length); 424 425 if (DRM_NO_ERROR == result) { 426 ++mDecryptSessionId; 427 mDecryptSessionMap.add(mDecryptSessionId, &rDrmEngine); 428 break; 429 } 430 } 431 } 432 if (DRM_NO_ERROR != result) { 433 delete handle; handle = NULL; 434 } 435 return handle; 436} 437 438DecryptHandle* DrmManager::openDecryptSession(int uniqueId, const char* uri) { 439 Mutex::Autolock _l(mDecryptLock); 440 status_t result = DRM_ERROR_CANNOT_HANDLE; 441 Vector<String8> plugInIdList = mPlugInManager.getPlugInIdList(); 442 443 DecryptHandle* handle = new DecryptHandle(); 444 if (NULL != handle) { 445 handle->decryptId = mDecryptSessionId + 1; 446 447 for (unsigned int index = 0; index < plugInIdList.size(); index++) { 448 String8 plugInId = plugInIdList.itemAt(index); 449 IDrmEngine& rDrmEngine = mPlugInManager.getPlugIn(plugInId); 450 result = rDrmEngine.openDecryptSession(uniqueId, handle, uri); 451 452 if (DRM_NO_ERROR == result) { 453 ++mDecryptSessionId; 454 mDecryptSessionMap.add(mDecryptSessionId, &rDrmEngine); 455 break; 456 } 457 } 458 } 459 if (DRM_NO_ERROR != result) { 460 delete handle; handle = NULL; 461 LOGV("DrmManager::openDecryptSession: no capable plug-in found"); 462 } 463 return handle; 464} 465 466status_t DrmManager::closeDecryptSession(int uniqueId, DecryptHandle* decryptHandle) { 467 Mutex::Autolock _l(mDecryptLock); 468 status_t result = DRM_ERROR_UNKNOWN; 469 if (mDecryptSessionMap.indexOfKey(decryptHandle->decryptId) != NAME_NOT_FOUND) { 470 IDrmEngine* drmEngine = mDecryptSessionMap.valueFor(decryptHandle->decryptId); 471 result = drmEngine->closeDecryptSession(uniqueId, decryptHandle); 472 if (DRM_NO_ERROR == result) { 473 mDecryptSessionMap.removeItem(decryptHandle->decryptId); 474 } 475 } 476 return result; 477} 478 479status_t DrmManager::initializeDecryptUnit( 480 int uniqueId, DecryptHandle* decryptHandle, int decryptUnitId, const DrmBuffer* headerInfo) { 481 status_t result = DRM_ERROR_UNKNOWN; 482 Mutex::Autolock _l(mDecryptLock); 483 if (mDecryptSessionMap.indexOfKey(decryptHandle->decryptId) != NAME_NOT_FOUND) { 484 IDrmEngine* drmEngine = mDecryptSessionMap.valueFor(decryptHandle->decryptId); 485 result = drmEngine->initializeDecryptUnit(uniqueId, decryptHandle, decryptUnitId, headerInfo); 486 } 487 return result; 488} 489 490status_t DrmManager::decrypt(int uniqueId, DecryptHandle* decryptHandle, int decryptUnitId, 491 const DrmBuffer* encBuffer, DrmBuffer** decBuffer, DrmBuffer* IV) { 492 status_t result = DRM_ERROR_UNKNOWN; 493 494 Mutex::Autolock _l(mDecryptLock); 495 if (mDecryptSessionMap.indexOfKey(decryptHandle->decryptId) != NAME_NOT_FOUND) { 496 IDrmEngine* drmEngine = mDecryptSessionMap.valueFor(decryptHandle->decryptId); 497 result = drmEngine->decrypt( 498 uniqueId, decryptHandle, decryptUnitId, encBuffer, decBuffer, IV); 499 } 500 return result; 501} 502 503status_t DrmManager::finalizeDecryptUnit( 504 int uniqueId, DecryptHandle* decryptHandle, int decryptUnitId) { 505 status_t result = DRM_ERROR_UNKNOWN; 506 Mutex::Autolock _l(mDecryptLock); 507 if (mDecryptSessionMap.indexOfKey(decryptHandle->decryptId) != NAME_NOT_FOUND) { 508 IDrmEngine* drmEngine = mDecryptSessionMap.valueFor(decryptHandle->decryptId); 509 result = drmEngine->finalizeDecryptUnit(uniqueId, decryptHandle, decryptUnitId); 510 } 511 return result; 512} 513 514ssize_t DrmManager::pread(int uniqueId, DecryptHandle* decryptHandle, 515 void* buffer, ssize_t numBytes, off64_t offset) { 516 ssize_t result = DECRYPT_FILE_ERROR; 517 518 Mutex::Autolock _l(mDecryptLock); 519 if (mDecryptSessionMap.indexOfKey(decryptHandle->decryptId) != NAME_NOT_FOUND) { 520 IDrmEngine* drmEngine = mDecryptSessionMap.valueFor(decryptHandle->decryptId); 521 result = drmEngine->pread(uniqueId, decryptHandle, buffer, numBytes, offset); 522 } 523 return result; 524} 525 526String8 DrmManager::getSupportedPlugInId( 527 int uniqueId, const String8& path, const String8& mimeType) { 528 String8 plugInId(""); 529 530 if (EMPTY_STRING != mimeType) { 531 plugInId = getSupportedPlugInId(mimeType); 532 } else { 533 plugInId = getSupportedPlugInIdFromPath(uniqueId, path); 534 } 535 return plugInId; 536} 537 538String8 DrmManager::getSupportedPlugInId(const String8& mimeType) { 539 String8 plugInId(""); 540 541 if (EMPTY_STRING != mimeType) { 542 for (unsigned int index = 0; index < mSupportInfoToPlugInIdMap.size(); index++) { 543 const DrmSupportInfo& drmSupportInfo = mSupportInfoToPlugInIdMap.keyAt(index); 544 545 if (drmSupportInfo.isSupportedMimeType(mimeType)) { 546 plugInId = mSupportInfoToPlugInIdMap.valueFor(drmSupportInfo); 547 break; 548 } 549 } 550 } 551 return plugInId; 552} 553 554String8 DrmManager::getSupportedPlugInIdFromPath(int uniqueId, const String8& path) { 555 String8 plugInId(""); 556 const String8 fileSuffix = path.getPathExtension(); 557 558 for (unsigned int index = 0; index < mSupportInfoToPlugInIdMap.size(); index++) { 559 const DrmSupportInfo& drmSupportInfo = mSupportInfoToPlugInIdMap.keyAt(index); 560 561 if (drmSupportInfo.isSupportedFileSuffix(fileSuffix)) { 562 String8 key = mSupportInfoToPlugInIdMap.valueFor(drmSupportInfo); 563 IDrmEngine& drmEngine = mPlugInManager.getPlugIn(key); 564 565 if (drmEngine.canHandle(uniqueId, path)) { 566 plugInId = key; 567 break; 568 } 569 } 570 } 571 return plugInId; 572} 573 574void DrmManager::onInfo(const DrmInfoEvent& event) { 575 Mutex::Autolock _l(mLock); 576 for (unsigned int index = 0; index < mServiceListeners.size(); index++) { 577 int uniqueId = mServiceListeners.keyAt(index); 578 579 if (uniqueId == event.getUniqueId()) { 580 sp<IDrmServiceListener> serviceListener = mServiceListeners.valueFor(uniqueId); 581 serviceListener->notify(event); 582 } 583 } 584} 585 586