DrmManagerClientImpl.cpp revision cba7b32d8f2c47632313f54118ed3733b4b02cc8
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 "DrmManagerClientImpl(Native)" 19#include <utils/Log.h> 20 21#include <utils/String8.h> 22#include <utils/Vector.h> 23#include <binder/IServiceManager.h> 24 25#include "DrmManagerClientImpl.h" 26 27using namespace android; 28 29#define INVALID_VALUE -1 30 31Mutex DrmManagerClientImpl::sMutex; 32sp<IDrmManagerService> DrmManagerClientImpl::sDrmManagerService; 33sp<DrmManagerClientImpl::DeathNotifier> DrmManagerClientImpl::sDeathNotifier; 34const String8 DrmManagerClientImpl::EMPTY_STRING(""); 35 36DrmManagerClientImpl* DrmManagerClientImpl::create( 37 int* pUniqueId, bool isNative) { 38 *pUniqueId = getDrmManagerService()->addUniqueId(isNative); 39 40 return new DrmManagerClientImpl(); 41} 42 43void DrmManagerClientImpl::remove(int uniqueId) { 44 getDrmManagerService()->removeUniqueId(uniqueId); 45} 46 47const sp<IDrmManagerService>& DrmManagerClientImpl::getDrmManagerService() { 48 Mutex::Autolock lock(sMutex); 49 if (NULL == sDrmManagerService.get()) { 50 sp<IServiceManager> sm = defaultServiceManager(); 51 sp<IBinder> binder; 52 do { 53 binder = sm->getService(String16("drm.drmManager")); 54 if (binder != 0) { 55 break; 56 } 57 ALOGW("DrmManagerService not published, waiting..."); 58 struct timespec reqt; 59 reqt.tv_sec = 0; 60 reqt.tv_nsec = 500000000; //0.5 sec 61 nanosleep(&reqt, NULL); 62 } while (true); 63 if (NULL == sDeathNotifier.get()) { 64 sDeathNotifier = new DeathNotifier(); 65 } 66 binder->linkToDeath(sDeathNotifier); 67 sDrmManagerService = interface_cast<IDrmManagerService>(binder); 68 } 69 return sDrmManagerService; 70} 71 72void DrmManagerClientImpl::addClient(int uniqueId) { 73 getDrmManagerService()->addClient(uniqueId); 74} 75 76void DrmManagerClientImpl::removeClient(int uniqueId) { 77 getDrmManagerService()->removeClient(uniqueId); 78} 79 80status_t DrmManagerClientImpl::setOnInfoListener( 81 int uniqueId, 82 const sp<DrmManagerClient::OnInfoListener>& infoListener) { 83 Mutex::Autolock _l(mLock); 84 mOnInfoListener = infoListener; 85 return getDrmManagerService()->setDrmServiceListener(uniqueId, 86 (NULL != infoListener.get()) ? this : NULL); 87} 88 89status_t DrmManagerClientImpl::installDrmEngine( 90 int uniqueId, const String8& drmEngineFile) { 91 status_t status = DRM_ERROR_UNKNOWN; 92 if (EMPTY_STRING != drmEngineFile) { 93 status = getDrmManagerService()->installDrmEngine(uniqueId, drmEngineFile); 94 } 95 return status; 96} 97 98DrmConstraints* DrmManagerClientImpl::getConstraints( 99 int uniqueId, const String8* path, const int action) { 100 DrmConstraints *drmConstraints = NULL; 101 if ((NULL != path) && (EMPTY_STRING != *path)) { 102 drmConstraints = 103 getDrmManagerService()->getConstraints(uniqueId, path, action); 104 } 105 return drmConstraints; 106} 107 108DrmMetadata* DrmManagerClientImpl::getMetadata(int uniqueId, const String8* path) { 109 DrmMetadata *drmMetadata = NULL; 110 if ((NULL != path) && (EMPTY_STRING != *path)) { 111 drmMetadata = getDrmManagerService()->getMetadata(uniqueId, path); 112 } 113 return drmMetadata; 114} 115 116bool DrmManagerClientImpl::canHandle( 117 int uniqueId, const String8& path, const String8& mimeType) { 118 bool retCode = false; 119 if ((EMPTY_STRING != path) || (EMPTY_STRING != mimeType)) { 120 retCode = getDrmManagerService()->canHandle(uniqueId, path, mimeType); 121 } 122 return retCode; 123} 124 125DrmInfoStatus* DrmManagerClientImpl::processDrmInfo( 126 int uniqueId, const DrmInfo* drmInfo) { 127 DrmInfoStatus *drmInfoStatus = NULL; 128 if (NULL != drmInfo) { 129 drmInfoStatus = getDrmManagerService()->processDrmInfo(uniqueId, drmInfo); 130 } 131 return drmInfoStatus; 132} 133 134DrmInfo* DrmManagerClientImpl::acquireDrmInfo( 135 int uniqueId, const DrmInfoRequest* drmInfoRequest) { 136 DrmInfo* drmInfo = NULL; 137 if (NULL != drmInfoRequest) { 138 drmInfo = getDrmManagerService()->acquireDrmInfo(uniqueId, drmInfoRequest); 139 } 140 return drmInfo; 141} 142 143status_t DrmManagerClientImpl::saveRights(int uniqueId, const DrmRights& drmRights, 144 const String8& rightsPath, const String8& contentPath) { 145 return getDrmManagerService()->saveRights( 146 uniqueId, drmRights, rightsPath, contentPath); 147} 148 149String8 DrmManagerClientImpl::getOriginalMimeType( 150 int uniqueId, const String8& path) { 151 String8 mimeType = EMPTY_STRING; 152 if (EMPTY_STRING != path) { 153 mimeType = getDrmManagerService()->getOriginalMimeType(uniqueId, path); 154 } 155 return mimeType; 156} 157 158int DrmManagerClientImpl::getDrmObjectType( 159 int uniqueId, const String8& path, const String8& mimeType) { 160 int drmOjectType = DrmObjectType::UNKNOWN; 161 if ((EMPTY_STRING != path) || (EMPTY_STRING != mimeType)) { 162 drmOjectType = 163 getDrmManagerService()->getDrmObjectType(uniqueId, path, mimeType); 164 } 165 return drmOjectType; 166} 167 168int DrmManagerClientImpl::checkRightsStatus( 169 int uniqueId, const String8& path, int action) { 170 int rightsStatus = RightsStatus::RIGHTS_INVALID; 171 if (EMPTY_STRING != path) { 172 rightsStatus = 173 getDrmManagerService()->checkRightsStatus(uniqueId, path, action); 174 } 175 return rightsStatus; 176} 177 178status_t DrmManagerClientImpl::consumeRights( 179 int uniqueId, sp<DecryptHandle> &decryptHandle, 180 int action, bool reserve) { 181 status_t status = DRM_ERROR_UNKNOWN; 182 if (NULL != decryptHandle.get()) { 183 status = getDrmManagerService()->consumeRights( 184 uniqueId, decryptHandle.get(), action, reserve); 185 } 186 return status; 187} 188 189status_t DrmManagerClientImpl::setPlaybackStatus( 190 int uniqueId, sp<DecryptHandle> &decryptHandle, 191 int playbackStatus, int64_t position) { 192 status_t status = DRM_ERROR_UNKNOWN; 193 if (NULL != decryptHandle.get()) { 194 status = getDrmManagerService()->setPlaybackStatus( 195 uniqueId, decryptHandle.get(), playbackStatus, position); 196 } 197 return status; 198} 199 200bool DrmManagerClientImpl::validateAction( 201 int uniqueId, const String8& path, 202 int action, const ActionDescription& description) { 203 bool retCode = false; 204 if (EMPTY_STRING != path) { 205 retCode = getDrmManagerService()->validateAction( 206 uniqueId, path, action, description); 207 } 208 return retCode; 209} 210 211status_t DrmManagerClientImpl::removeRights(int uniqueId, const String8& path) { 212 status_t status = DRM_ERROR_UNKNOWN; 213 if (EMPTY_STRING != path) { 214 status = getDrmManagerService()->removeRights(uniqueId, path); 215 } 216 return status; 217} 218 219status_t DrmManagerClientImpl::removeAllRights(int uniqueId) { 220 return getDrmManagerService()->removeAllRights(uniqueId); 221} 222 223int DrmManagerClientImpl::openConvertSession( 224 int uniqueId, const String8& mimeType) { 225 int retCode = INVALID_VALUE; 226 if (EMPTY_STRING != mimeType) { 227 retCode = getDrmManagerService()->openConvertSession(uniqueId, mimeType); 228 } 229 return retCode; 230} 231 232DrmConvertedStatus* DrmManagerClientImpl::convertData( 233 int uniqueId, int convertId, const DrmBuffer* inputData) { 234 DrmConvertedStatus* drmConvertedStatus = NULL; 235 if (NULL != inputData) { 236 drmConvertedStatus = 237 getDrmManagerService()->convertData(uniqueId, convertId, inputData); 238 } 239 return drmConvertedStatus; 240} 241 242DrmConvertedStatus* DrmManagerClientImpl::closeConvertSession( 243 int uniqueId, int convertId) { 244 return getDrmManagerService()->closeConvertSession(uniqueId, convertId); 245} 246 247status_t DrmManagerClientImpl::getAllSupportInfo( 248 int uniqueId, int* length, DrmSupportInfo** drmSupportInfoArray) { 249 status_t status = DRM_ERROR_UNKNOWN; 250 if ((NULL != drmSupportInfoArray) && (NULL != length)) { 251 status = getDrmManagerService()->getAllSupportInfo( 252 uniqueId, length, drmSupportInfoArray); 253 } 254 return status; 255} 256 257sp<DecryptHandle> DrmManagerClientImpl::openDecryptSession( 258 int uniqueId, int fd, off64_t offset, 259 off64_t length, const char* mime) { 260 261 return getDrmManagerService()->openDecryptSession( 262 uniqueId, fd, offset, length, mime); 263} 264 265sp<DecryptHandle> DrmManagerClientImpl::openDecryptSession( 266 int uniqueId, const char* uri, const char* mime) { 267 268 DecryptHandle* handle = NULL; 269 if (NULL != uri) { 270 handle = getDrmManagerService()->openDecryptSession(uniqueId, uri, mime); 271 } 272 return handle; 273} 274 275sp<DecryptHandle> DrmManagerClientImpl::openDecryptSession( 276 int uniqueId, const DrmBuffer& buf, const String8& mimeType) { 277 return getDrmManagerService()->openDecryptSession(uniqueId, buf, mimeType); 278} 279 280status_t DrmManagerClientImpl::closeDecryptSession( 281 int uniqueId, sp<DecryptHandle> &decryptHandle) { 282 status_t status = DRM_ERROR_UNKNOWN; 283 if (NULL != decryptHandle.get()) { 284 status = getDrmManagerService()->closeDecryptSession( 285 uniqueId, decryptHandle.get()); 286 } 287 return status; 288} 289 290status_t DrmManagerClientImpl::initializeDecryptUnit( 291 int uniqueId, sp<DecryptHandle> &decryptHandle, 292 int decryptUnitId, const DrmBuffer* headerInfo) { 293 status_t status = DRM_ERROR_UNKNOWN; 294 if ((NULL != decryptHandle.get()) && (NULL != headerInfo)) { 295 status = getDrmManagerService()->initializeDecryptUnit( 296 uniqueId, decryptHandle.get(), decryptUnitId, headerInfo); 297 } 298 return status; 299} 300 301status_t DrmManagerClientImpl::decrypt( 302 int uniqueId, sp<DecryptHandle> &decryptHandle, 303 int decryptUnitId, const DrmBuffer* encBuffer, 304 DrmBuffer** decBuffer, DrmBuffer* IV) { 305 status_t status = DRM_ERROR_UNKNOWN; 306 if ((NULL != decryptHandle.get()) && (NULL != encBuffer) 307 && (NULL != decBuffer) && (NULL != *decBuffer)) { 308 status = getDrmManagerService()->decrypt( 309 uniqueId, decryptHandle.get(), decryptUnitId, 310 encBuffer, decBuffer, IV); 311 } 312 return status; 313} 314 315status_t DrmManagerClientImpl::finalizeDecryptUnit( 316 int uniqueId, sp<DecryptHandle> &decryptHandle, int decryptUnitId) { 317 status_t status = DRM_ERROR_UNKNOWN; 318 if (NULL != decryptHandle.get()) { 319 status = getDrmManagerService()->finalizeDecryptUnit( 320 uniqueId, decryptHandle.get(), decryptUnitId); 321 } 322 return status; 323} 324 325ssize_t DrmManagerClientImpl::pread(int uniqueId, sp<DecryptHandle> &decryptHandle, 326 void* buffer, ssize_t numBytes, off64_t offset) { 327 ssize_t retCode = INVALID_VALUE; 328 if ((NULL != decryptHandle.get()) && (NULL != buffer) && (0 < numBytes)) { 329 retCode = getDrmManagerService()->pread( 330 uniqueId, decryptHandle.get(), buffer, numBytes, offset); 331 } 332 return retCode; 333} 334 335status_t DrmManagerClientImpl::notify(const DrmInfoEvent& event) { 336 if (NULL != mOnInfoListener.get()) { 337 Mutex::Autolock _l(mLock); 338 sp<DrmManagerClient::OnInfoListener> listener = mOnInfoListener; 339 listener->onInfo(event); 340 } 341 return DRM_NO_ERROR; 342} 343 344DrmManagerClientImpl::DeathNotifier::~DeathNotifier() { 345 Mutex::Autolock lock(sMutex); 346 if (NULL != sDrmManagerService.get()) { 347 sDrmManagerService->asBinder()->unlinkToDeath(this); 348 } 349} 350 351void DrmManagerClientImpl::DeathNotifier::binderDied(const wp<IBinder>& who) { 352 Mutex::Autolock lock(sMutex); 353 DrmManagerClientImpl::sDrmManagerService.clear(); 354 ALOGW("DrmManager server died!"); 355} 356 357