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 27 using namespace android; 28 29 #define INVALID_VALUE -1 30 31 Mutex DrmManagerClientImpl::sMutex; 32 sp<IDrmManagerService> DrmManagerClientImpl::sDrmManagerService; 33 sp<DrmManagerClientImpl::DeathNotifier> DrmManagerClientImpl::sDeathNotifier; 34 const String8 DrmManagerClientImpl::EMPTY_STRING(""); 35 36 DrmManagerClientImpl* DrmManagerClientImpl::create( 37 int* pUniqueId, bool isNative) { 38 *pUniqueId = getDrmManagerService()->addUniqueId(isNative); 39 40 return new DrmManagerClientImpl(); 41 } 42 43 void DrmManagerClientImpl::remove(int uniqueId) { 44 getDrmManagerService()->removeUniqueId(uniqueId); 45 } 46 47 const 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 72 void DrmManagerClientImpl::addClient(int uniqueId) { 73 getDrmManagerService()->addClient(uniqueId); 74 } 75 76 void DrmManagerClientImpl::removeClient(int uniqueId) { 77 getDrmManagerService()->removeClient(uniqueId); 78 } 79 80 status_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 89 status_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 98 DrmConstraints* 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 108 DrmMetadata* 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 116 bool 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 125 DrmInfoStatus* 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 134 DrmInfo* 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 143 status_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 149 String8 DrmManagerClientImpl::getOriginalMimeType( 150 int uniqueId, const String8& path, int fd) { 151 String8 mimeType = EMPTY_STRING; 152 if (EMPTY_STRING != path) { 153 mimeType = getDrmManagerService()->getOriginalMimeType(uniqueId, path, fd); 154 } 155 return mimeType; 156 } 157 158 int 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 168 int 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 178 status_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 189 status_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 200 bool 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 211 status_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 219 status_t DrmManagerClientImpl::removeAllRights(int uniqueId) { 220 return getDrmManagerService()->removeAllRights(uniqueId); 221 } 222 223 int 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 232 DrmConvertedStatus* 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 242 DrmConvertedStatus* DrmManagerClientImpl::closeConvertSession( 243 int uniqueId, int convertId) { 244 return getDrmManagerService()->closeConvertSession(uniqueId, convertId); 245 } 246 247 status_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 257 sp<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 265 sp<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 275 sp<DecryptHandle> DrmManagerClientImpl::openDecryptSession( 276 int uniqueId, const DrmBuffer& buf, const String8& mimeType) { 277 return getDrmManagerService()->openDecryptSession(uniqueId, buf, mimeType); 278 } 279 280 status_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 290 status_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 301 status_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 315 status_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 325 ssize_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 335 status_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 344 DrmManagerClientImpl::DeathNotifier::~DeathNotifier() { 345 Mutex::Autolock lock(sMutex); 346 if (NULL != sDrmManagerService.get()) { 347 sDrmManagerService->asBinder()->unlinkToDeath(this); 348 } 349 } 350 351 void DrmManagerClientImpl::DeathNotifier::binderDied(const wp<IBinder>& who) { 352 Mutex::Autolock lock(sMutex); 353 DrmManagerClientImpl::sDrmManagerService.clear(); 354 ALOGW("DrmManager server died!"); 355 } 356 357