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