blob: 9e30708cd42aad842c57ff61f0ab92011e0a80cf [file] [log] [blame]
Kyle Zhang6605add2022-01-13 17:51:23 +00001/*
2 * Copyright (C) 2021 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 "DrmHalAidl"
19
Kyle Zhang994023a2022-02-09 05:32:12 +000020#include <array>
21#include <algorithm>
Robert Shih06a2bab2022-02-14 14:07:41 -080022#include <map>
Kyle Zhang6605add2022-01-13 17:51:23 +000023#include <android/binder_auto_utils.h>
24#include <android/binder_manager.h>
25#include <media/PluginMetricsReporting.h>
26#include <media/stagefright/foundation/ADebug.h>
27#include <media/stagefright/foundation/AString.h>
28#include <media/stagefright/foundation/base64.h>
29#include <media/stagefright/foundation/hexdump.h>
30#include <mediadrm/DrmHalAidl.h>
31#include <mediadrm/DrmSessionManager.h>
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +053032#include <mediadrm/DrmStatus.h>
Kyle Zhang6605add2022-01-13 17:51:23 +000033#include <mediadrm/DrmUtils.h>
34
Kyle Zhang994023a2022-02-09 05:32:12 +000035using ::aidl::android::hardware::drm::CryptoSchemes;
Kyle Zhang6605add2022-01-13 17:51:23 +000036using ::aidl::android::hardware::drm::DrmMetricNamedValue;
37using ::aidl::android::hardware::drm::DrmMetricValue;
38using ::aidl::android::hardware::drm::HdcpLevel;
39using ::aidl::android::hardware::drm::HdcpLevels;
40using ::aidl::android::hardware::drm::KeyRequest;
41using ::aidl::android::hardware::drm::KeyRequestType;
42using ::aidl::android::hardware::drm::KeySetId;
43using ::aidl::android::hardware::drm::KeyStatus;
44using ::aidl::android::hardware::drm::KeyStatusType;
45using ::aidl::android::hardware::drm::KeyType;
46using ::aidl::android::hardware::drm::KeyValue;
47using ::aidl::android::hardware::drm::NumberOfSessions;
48using ::aidl::android::hardware::drm::OfflineLicenseState;
49using ::aidl::android::hardware::drm::OpaqueData;
50using ::aidl::android::hardware::drm::ProvideProvisionResponseResult;
51using ::aidl::android::hardware::drm::ProvisionRequest;
52using ::aidl::android::hardware::drm::SecureStop;
53using ::aidl::android::hardware::drm::SecureStopId;
54using ::aidl::android::hardware::drm::SecurityLevel;
55using ::aidl::android::hardware::drm::Status;
Robert Shih06a2bab2022-02-14 14:07:41 -080056using ::aidl::android::hardware::drm::SupportedContentType;
Kyle Zhang6605add2022-01-13 17:51:23 +000057using ::aidl::android::hardware::drm::Uuid;
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +053058using ::android::DrmUtils::statusAidlToDrmStatus;
Kyle Zhang6605add2022-01-13 17:51:23 +000059using DrmMetricGroupAidl = ::aidl::android::hardware::drm::DrmMetricGroup;
60using DrmMetricGroupHidl = ::android::hardware::drm::V1_1::DrmMetricGroup;
61using DrmMetricAidl = ::aidl::android::hardware::drm::DrmMetric;
62using DrmMetricHidl = ::android::hardware::drm::V1_1::DrmMetricGroup::Metric;
63using ValueHidl = ::android::hardware::drm::V1_1::DrmMetricGroup::Value;
64using AttributeHidl = ::android::hardware::drm::V1_1::DrmMetricGroup::Attribute;
65using IDrmPluginAidl = ::aidl::android::hardware::drm::IDrmPlugin;
66using EventTypeAidl = ::aidl::android::hardware::drm::EventType;
Kyle Zhang6605add2022-01-13 17:51:23 +000067using ::android::hardware::hidl_vec;
68
69namespace {
70
71constexpr char kPropertyDeviceUniqueId[] = "deviceUniqueId";
72constexpr char kEqualsSign[] = "=";
73
74template <typename T>
75std::string toBase64StringNoPad(const T* data, size_t size) {
76 // Note that the base 64 conversion only works with arrays of single-byte
77 // values. If the source is empty or is not an array of single-byte values,
78 // return empty string.
79 if (size == 0 || sizeof(data[0]) != 1) {
80 return "";
81 }
82
83 android::AString outputString;
84 encodeBase64(data, size, &outputString);
85 // Remove trailing equals padding if it exists.
86 while (outputString.size() > 0 && outputString.endsWith(kEqualsSign)) {
87 outputString.erase(outputString.size() - 1, 1);
88 }
89
90 return std::string(outputString.c_str(), outputString.size());
91}
92
93} // anonymous namespace
94
95namespace android {
96
97#define INIT_CHECK() \
98 { \
99 if (mInitCheck != OK) return mInitCheck; \
100 }
101
Kyle Zhang6605add2022-01-13 17:51:23 +0000102template <typename Byte = uint8_t>
103static std::vector<Byte> toStdVec(const Vector<uint8_t>& vector) {
104 auto v = reinterpret_cast<const Byte*>(vector.array());
105 std::vector<Byte> vec(v, v + vector.size());
106 return vec;
107}
108
109static const Vector<uint8_t> toVector(const std::vector<uint8_t>& vec) {
110 Vector<uint8_t> vector;
111 vector.appendArray(vec.data(), vec.size());
112 return *const_cast<const Vector<uint8_t>*>(&vector);
113}
114
115static String8 toString8(const std::string& string) {
116 return String8(string.c_str());
117}
118
119static std::string toStdString(const String8& string8) {
Tomasz Wasilczyk09977ff2023-08-11 15:52:22 +0000120 return std::string(string8.c_str());
Kyle Zhang6605add2022-01-13 17:51:23 +0000121}
122
123static std::vector<KeyValue> toKeyValueVector(const KeyedVector<String8, String8>& keyedVector) {
124 std::vector<KeyValue> stdKeyedVector;
125 for (size_t i = 0; i < keyedVector.size(); i++) {
126 KeyValue keyValue;
127 keyValue.key = toStdString(keyedVector.keyAt(i));
128 keyValue.value = toStdString(keyedVector.valueAt(i));
129 stdKeyedVector.push_back(keyValue);
130 }
131 return stdKeyedVector;
132}
133
134static KeyedVector<String8, String8> toKeyedVector(const std::vector<KeyValue>& keyValueVec) {
135 KeyedVector<String8, String8> keyedVector;
136 for (size_t i = 0; i < keyValueVec.size(); i++) {
137 keyedVector.add(toString8(keyValueVec[i].key), toString8(keyValueVec[i].value));
138 }
139 return keyedVector;
140}
141
142static DrmPlugin::KeyRequestType toKeyRequestType(KeyRequestType keyRequestType) {
143 switch (keyRequestType) {
144 case KeyRequestType::INITIAL:
145 return DrmPlugin::kKeyRequestType_Initial;
146 break;
147 case KeyRequestType::RENEWAL:
148 return DrmPlugin::kKeyRequestType_Renewal;
149 break;
150 case KeyRequestType::RELEASE:
151 return DrmPlugin::kKeyRequestType_Release;
152 break;
153 case KeyRequestType::NONE:
154 return DrmPlugin::kKeyRequestType_None;
155 break;
156 case KeyRequestType::UPDATE:
157 return DrmPlugin::kKeyRequestType_Update;
158 break;
159 default:
160 return DrmPlugin::kKeyRequestType_Unknown;
161 break;
162 }
163}
164
165static List<Vector<uint8_t>> toSecureStops(const std::vector<SecureStop>& aSecureStops) {
166 List<Vector<uint8_t>> secureStops;
167 for (size_t i = 0; i < aSecureStops.size(); i++) {
168 secureStops.push_back(toVector(aSecureStops[i].opaqueData));
169 }
170 return secureStops;
171}
172
173static List<Vector<uint8_t>> toSecureStopIds(const std::vector<SecureStopId>& aSecureStopIds) {
174 List<Vector<uint8_t>> secureStopIds;
175 for (size_t i = 0; i < aSecureStopIds.size(); i++) {
176 secureStopIds.push_back(toVector(aSecureStopIds[i].secureStopId));
177 }
178 return secureStopIds;
179}
180
181static DrmPlugin::HdcpLevel toHdcpLevel(HdcpLevel level) {
182 switch (level) {
183 case HdcpLevel::HDCP_NONE:
184 return DrmPlugin::kHdcpNone;
185 case HdcpLevel::HDCP_V1:
186 return DrmPlugin::kHdcpV1;
187 case HdcpLevel::HDCP_V2:
188 return DrmPlugin::kHdcpV2;
189 case HdcpLevel::HDCP_V2_1:
190 return DrmPlugin::kHdcpV2_1;
191 case HdcpLevel::HDCP_V2_2:
192 return DrmPlugin::kHdcpV2_2;
193 case HdcpLevel::HDCP_V2_3:
194 return DrmPlugin::kHdcpV2_3;
195 case HdcpLevel::HDCP_NO_OUTPUT:
196 return DrmPlugin::kHdcpNoOutput;
197 default:
198 return DrmPlugin::kHdcpLevelUnknown;
199 }
200}
201
202static DrmPlugin::SecurityLevel toSecurityLevel(SecurityLevel level) {
203 switch (level) {
204 case SecurityLevel::SW_SECURE_CRYPTO:
205 return DrmPlugin::kSecurityLevelSwSecureCrypto;
206 case SecurityLevel::SW_SECURE_DECODE:
207 return DrmPlugin::kSecurityLevelSwSecureDecode;
208 case SecurityLevel::HW_SECURE_CRYPTO:
209 return DrmPlugin::kSecurityLevelHwSecureCrypto;
210 case SecurityLevel::HW_SECURE_DECODE:
211 return DrmPlugin::kSecurityLevelHwSecureDecode;
212 case SecurityLevel::HW_SECURE_ALL:
213 return DrmPlugin::kSecurityLevelHwSecureAll;
214 case SecurityLevel::DEFAULT:
215 return DrmPlugin::kSecurityLevelMax;
216 default:
217 return DrmPlugin::kSecurityLevelUnknown;
218 }
219}
220
221static SecurityLevel toAidlSecurityLevel(DrmPlugin::SecurityLevel level) {
222 switch (level) {
223 case DrmPlugin::kSecurityLevelSwSecureCrypto:
224 return SecurityLevel::SW_SECURE_CRYPTO;
225 case DrmPlugin::kSecurityLevelSwSecureDecode:
226 return SecurityLevel::SW_SECURE_DECODE;
227 case DrmPlugin::kSecurityLevelHwSecureCrypto:
228 return SecurityLevel::HW_SECURE_CRYPTO;
229 case DrmPlugin::kSecurityLevelHwSecureDecode:
230 return SecurityLevel::HW_SECURE_DECODE;
231 case DrmPlugin::kSecurityLevelHwSecureAll:
232 return SecurityLevel::HW_SECURE_ALL;
233 case DrmPlugin::kSecurityLevelMax:
234 return SecurityLevel::DEFAULT;
235 default:
236 return SecurityLevel::UNKNOWN;
237 }
238}
239
240static List<Vector<uint8_t>> toKeySetIds(const std::vector<KeySetId>& hKeySetIds) {
241 List<Vector<uint8_t>> keySetIds;
242 for (size_t i = 0; i < hKeySetIds.size(); i++) {
243 keySetIds.push_back(toVector(hKeySetIds[i].keySetId));
244 }
245 return keySetIds;
246}
247
Kyle Zhangfa72c482022-02-04 03:55:43 +0000248static hidl_vec<uint8_t> toHidlVec(const Vector<uint8_t>& vector) {
249 hidl_vec<uint8_t> vec;
250 vec.setToExternal(const_cast<uint8_t*>(vector.array()), vector.size());
251 return vec;
252}
253
Kyle Zhang6605add2022-01-13 17:51:23 +0000254static DrmPlugin::OfflineLicenseState toOfflineLicenseState(OfflineLicenseState licenseState) {
255 switch (licenseState) {
256 case OfflineLicenseState::USABLE:
257 return DrmPlugin::kOfflineLicenseStateUsable;
258 case OfflineLicenseState::INACTIVE:
259 return DrmPlugin::kOfflineLicenseStateReleased;
260 default:
261 return DrmPlugin::kOfflineLicenseStateUnknown;
262 }
263}
264
Kyle Zhang6605add2022-01-13 17:51:23 +0000265Mutex DrmHalAidl::mLock;
266
267static hidl_vec<DrmMetricGroupHidl> toDrmMetricGroupHidl(std::vector<DrmMetricGroupAidl> result) {
Kyle Zhangfa72c482022-02-04 03:55:43 +0000268 std::vector<DrmMetricGroupHidl> resultHidl;
Kyle Zhang6605add2022-01-13 17:51:23 +0000269 for (auto r : result) {
270 DrmMetricGroupHidl re;
Kyle Zhangfa72c482022-02-04 03:55:43 +0000271 std::vector<DrmMetricHidl> tmpMetric;
Kyle Zhang6605add2022-01-13 17:51:23 +0000272 for (auto m : r.metrics) {
273 DrmMetricHidl me;
274 me.name = m.name;
Kyle Zhangfa72c482022-02-04 03:55:43 +0000275 std::vector<AttributeHidl> aTmp;
Kyle Zhang6605add2022-01-13 17:51:23 +0000276 for (auto attr : m.attributes) {
277 AttributeHidl attrHidl;
278 attrHidl.name = attr.name;
279
280 switch (attr.value.getTag()) {
281 case DrmMetricValue::Tag::int64Value:
282 attrHidl.type = DrmMetricGroupHidl::ValueType::INT64_TYPE;
283 attrHidl.int64Value = attr.value.get<DrmMetricValue::Tag::int64Value>();
284 break;
285 case DrmMetricValue::Tag::doubleValue:
286 attrHidl.type = DrmMetricGroupHidl::ValueType::DOUBLE_TYPE;
287 attrHidl.doubleValue = attr.value.get<DrmMetricValue::Tag::doubleValue>();
288 break;
289 case DrmMetricValue::Tag::stringValue:
290 attrHidl.type = DrmMetricGroupHidl::ValueType::STRING_TYPE;
291 attrHidl.stringValue = attr.value.get<DrmMetricValue::Tag::stringValue>();
292 break;
293 default:
294 break;
295 }
296
297 aTmp.push_back(attrHidl);
298 }
299
Kyle Zhangfa72c482022-02-04 03:55:43 +0000300 me.attributes = aTmp;
Kyle Zhang6605add2022-01-13 17:51:23 +0000301
Kyle Zhangfa72c482022-02-04 03:55:43 +0000302 std::vector<ValueHidl> vTmp;
Kyle Zhang6605add2022-01-13 17:51:23 +0000303 for (auto value : m.values) {
304 ValueHidl valueHidl;
305 valueHidl.componentName = value.name;
306 switch (value.value.getTag()) {
307 case DrmMetricValue::Tag::int64Value:
308 valueHidl.type = DrmMetricGroupHidl::ValueType::INT64_TYPE;
309 valueHidl.int64Value = value.value.get<DrmMetricValue::Tag::int64Value>();
310 break;
311 case DrmMetricValue::Tag::doubleValue:
312 valueHidl.type = DrmMetricGroupHidl::ValueType::DOUBLE_TYPE;
313 valueHidl.doubleValue = value.value.get<DrmMetricValue::Tag::doubleValue>();
314 break;
315 case DrmMetricValue::Tag::stringValue:
316 valueHidl.type = DrmMetricGroupHidl::ValueType::STRING_TYPE;
317 valueHidl.stringValue = value.value.get<DrmMetricValue::Tag::stringValue>();
318 break;
319 default:
320 break;
321 }
322
323 vTmp.push_back(valueHidl);
324 }
325
Kyle Zhangfa72c482022-02-04 03:55:43 +0000326 me.values = vTmp;
Kyle Zhang6605add2022-01-13 17:51:23 +0000327 tmpMetric.push_back(me);
328 }
329
Kyle Zhangfa72c482022-02-04 03:55:43 +0000330 re.metrics = tmpMetric;
Kyle Zhang6605add2022-01-13 17:51:23 +0000331 resultHidl.push_back(re);
332 }
333
Kyle Zhangfa72c482022-02-04 03:55:43 +0000334 return resultHidl;
Kyle Zhang6605add2022-01-13 17:51:23 +0000335}
336
337// DrmSessionClient Definition
338
339struct DrmHalAidl::DrmSessionClient : public aidl::android::media::BnResourceManagerClient {
340 explicit DrmSessionClient(DrmHalAidl* drm, const Vector<uint8_t>& sessionId)
341 : mSessionId(sessionId), mDrm(drm) {}
342
343 ::ndk::ScopedAStatus reclaimResource(bool* _aidl_return) override;
344 ::ndk::ScopedAStatus getName(::std::string* _aidl_return) override;
345
346 const Vector<uint8_t> mSessionId;
347
348 virtual ~DrmSessionClient();
349
350 private:
351 wp<DrmHalAidl> mDrm;
352
353 DISALLOW_EVIL_CONSTRUCTORS(DrmSessionClient);
354};
355
356::ndk::ScopedAStatus DrmHalAidl::DrmSessionClient::reclaimResource(bool* _aidl_return) {
357 auto sessionId = mSessionId;
358 sp<DrmHalAidl> drm = mDrm.promote();
359 if (drm == NULL) {
360 *_aidl_return = true;
361 return ::ndk::ScopedAStatus::ok();
362 }
363 status_t err = drm->closeSession(sessionId);
364 if (err != OK) {
365 *_aidl_return = false;
366 return ::ndk::ScopedAStatus::ok();
367 }
368 drm->onEvent(EventTypeAidl::SESSION_RECLAIMED, toHidlVec(sessionId), hidl_vec<uint8_t>());
369 *_aidl_return = true;
370 return ::ndk::ScopedAStatus::ok();
371}
372
373::ndk::ScopedAStatus DrmHalAidl::DrmSessionClient::getName(::std::string* _aidl_return) {
374 String8 name;
375 sp<DrmHalAidl> drm = mDrm.promote();
376 if (drm == NULL) {
377 name.append("<deleted>");
378 } else if (drm->getPropertyStringInternal(String8("vendor"), name) != OK || name.isEmpty()) {
379 name.append("<Get vendor failed or is empty>");
380 }
381 name.append("[");
382 for (size_t i = 0; i < mSessionId.size(); ++i) {
383 name.appendFormat("%02x", mSessionId[i]);
384 }
385 name.append("]");
386 *_aidl_return = name;
387 return ::ndk::ScopedAStatus::ok();
388}
389
390DrmHalAidl::DrmSessionClient::~DrmSessionClient() {
391 DrmSessionManager::Instance()->removeSession(mSessionId);
392}
393
394// DrmHalAidl methods
395DrmHalAidl::DrmHalAidl()
Kyle Zhangc33286b2023-02-02 22:59:05 +0000396 : mMetrics(std::make_shared<MediaDrmMetrics>()),
397 mListener(::ndk::SharedRefBase::make<DrmHalListener>(mMetrics)),
Kyle Zhang994023a2022-02-09 05:32:12 +0000398 mFactories(DrmUtils::makeDrmFactoriesAidl()),
Kyle Zhang6605add2022-01-13 17:51:23 +0000399 mInitCheck((mFactories.size() == 0) ? ERROR_UNSUPPORTED : NO_INIT) {}
400
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530401DrmStatus DrmHalAidl::initCheck() const {
402 return DrmStatus(mInitCheck);
Kyle Zhang6605add2022-01-13 17:51:23 +0000403}
404
405DrmHalAidl::~DrmHalAidl() {}
406
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530407DrmStatus DrmHalAidl::setListener(const sp<IDrmClient>& listener) {
Kyle Zhanga55209d2022-02-03 01:52:46 +0000408 mListener->setListener(listener);
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530409 return DrmStatus(NO_ERROR);
Kyle Zhang6605add2022-01-13 17:51:23 +0000410}
411
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530412DrmStatus DrmHalAidl::isCryptoSchemeSupported(const uint8_t uuid[16], const String8& mimeType,
413 DrmPlugin::SecurityLevel level, bool* isSupported) {
Kyle Zhang6605add2022-01-13 17:51:23 +0000414 Mutex::Autolock autoLock(mLock);
415 *isSupported = false;
Kyle Zhang994023a2022-02-09 05:32:12 +0000416 Uuid uuidAidl = DrmUtils::toAidlUuid(uuid);
Kyle Zhanga55209d2022-02-03 01:52:46 +0000417 SecurityLevel levelAidl = toAidlSecurityLevel(level);
Tomasz Wasilczyk09977ff2023-08-11 15:52:22 +0000418 std::string mimeTypeStr = mimeType.c_str();
Kyle Zhanga55209d2022-02-03 01:52:46 +0000419
Kyle Zhang6605add2022-01-13 17:51:23 +0000420 for (ssize_t i = mFactories.size() - 1; i >= 0; i--) {
Kyle Zhang994023a2022-02-09 05:32:12 +0000421 CryptoSchemes schemes{};
422 auto err = mFactories[i]->getSupportedCryptoSchemes(&schemes);
423 if (!err.isOk() || !std::count(schemes.uuids.begin(), schemes.uuids.end(), uuidAidl)) {
424 continue;
Kyle Zhang6605add2022-01-13 17:51:23 +0000425 }
Kyle Zhang994023a2022-02-09 05:32:12 +0000426
Robert Shih06a2bab2022-02-14 14:07:41 -0800427 ALOGV("supported schemes: %s; query: level %d mime %s",
428 schemes.toString().c_str(), levelAidl, mimeType.c_str());
429 std::map<std::string, SupportedContentType> contentTypes;
430 for (auto ct : schemes.mimeTypes) {
431 contentTypes[ct.mime] = ct;
Kyle Zhang994023a2022-02-09 05:32:12 +0000432 }
433
Robert Shih06a2bab2022-02-14 14:07:41 -0800434 // handle default value cases
435 if (levelAidl == SecurityLevel::DEFAULT || levelAidl == SecurityLevel::UNKNOWN) {
436 if (mimeType == "") {
437 // isCryptoSchemeSupported(uuid)
438 *isSupported = true;
439 } else {
440 // isCryptoSchemeSupported(uuid, mimeType)
441 *isSupported = contentTypes.count(mimeTypeStr);
Kyle Zhang994023a2022-02-09 05:32:12 +0000442 }
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530443 return DrmStatus(OK);
Robert Shih06a2bab2022-02-14 14:07:41 -0800444 } else if (mimeType == "") {
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530445 return DrmStatus(BAD_VALUE);
Robert Shih06a2bab2022-02-14 14:07:41 -0800446 }
447
448 auto ct = contentTypes[mimeTypeStr];
449 if (levelAidl > ct.maxLevel || levelAidl < ct.minLevel) {
450 continue;
Kyle Zhang994023a2022-02-09 05:32:12 +0000451 }
452
453 *isSupported = true;
454 break;
Kyle Zhang6605add2022-01-13 17:51:23 +0000455 }
456
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530457 return DrmStatus(OK);
Kyle Zhang6605add2022-01-13 17:51:23 +0000458}
459
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530460DrmStatus DrmHalAidl::createPlugin(const uint8_t uuid[16], const String8& appPackageName) {
Kyle Zhang6605add2022-01-13 17:51:23 +0000461 Mutex::Autolock autoLock(mLock);
Kyle Zhang4a7dd2c2023-03-01 21:13:29 +0000462 if (mInitCheck == ERROR_UNSUPPORTED) return mInitCheck;
Kyle Zhang994023a2022-02-09 05:32:12 +0000463 Uuid uuidAidl = DrmUtils::toAidlUuid(uuid);
Kyle Zhang6605add2022-01-13 17:51:23 +0000464 std::string appPackageNameAidl = toStdString(appPackageName);
465 std::shared_ptr<IDrmPluginAidl> pluginAidl;
Kyle Zhangc33286b2023-02-02 22:59:05 +0000466 mMetrics->SetAppPackageName(appPackageName);
467 mMetrics->SetAppUid(AIBinder_getCallingUid());
Kyle Zhang6605add2022-01-13 17:51:23 +0000468 for (ssize_t i = mFactories.size() - 1; i >= 0; i--) {
469 ::ndk::ScopedAStatus status =
Kyle Zhang994023a2022-02-09 05:32:12 +0000470 mFactories[i]->createDrmPlugin(uuidAidl, appPackageNameAidl, &pluginAidl);
Kyle Zhang6605add2022-01-13 17:51:23 +0000471 if (status.isOk()) {
472 if (pluginAidl != NULL) {
473 mPlugin = pluginAidl;
474 break;
475 }
476 } else {
477 DrmUtils::LOG2BE(uuid, "Failed to make drm plugin: %d",
478 status.getServiceSpecificError());
479 }
480 }
481
482 if (mPlugin == NULL) {
483 DrmUtils::LOG2BE(uuid, "No supported hal instance found");
484 mInitCheck = ERROR_UNSUPPORTED;
485 } else {
486 mInitCheck = OK;
Kyle Zhanga55209d2022-02-03 01:52:46 +0000487 // Stored pointer mListener upcast to base BnDrmPluginListener
488 ::ndk::ScopedAStatus status = mPlugin
489 ->setListener(std::static_pointer_cast<BnDrmPluginListener>(mListener));
490 if (!status.isOk()) {
Kyle Zhang6605add2022-01-13 17:51:23 +0000491 mInitCheck = DEAD_OBJECT;
Kyle Zhanga55209d2022-02-03 01:52:46 +0000492 ALOGE("setListener failed: ex %d svc err %d",
493 status.getExceptionCode(),
494 status.getServiceSpecificError());
Kyle Zhang6605add2022-01-13 17:51:23 +0000495 }
496
497 if (mInitCheck != OK) {
498 mPlugin.reset();
499 }
500 }
501
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530502 return DrmStatus(mInitCheck);
Kyle Zhang6605add2022-01-13 17:51:23 +0000503}
504
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530505DrmStatus DrmHalAidl::openSession(DrmPlugin::SecurityLevel level, Vector<uint8_t>& sessionId) {
Kyle Zhang6605add2022-01-13 17:51:23 +0000506 Mutex::Autolock autoLock(mLock);
507 INIT_CHECK();
508
509 SecurityLevel aSecurityLevel = toAidlSecurityLevel(level);
510
511 if (aSecurityLevel == SecurityLevel::UNKNOWN) {
512 return ERROR_DRM_CANNOT_HANDLE;
513 }
514
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530515 DrmStatus err = UNKNOWN_ERROR;
Kyle Zhang6605add2022-01-13 17:51:23 +0000516 bool retry = true;
517 do {
518 std::vector<uint8_t> aSessionId;
519
520 ::ndk::ScopedAStatus status = mPlugin->openSession(aSecurityLevel, &aSessionId);
521 if (status.isOk()) sessionId = toVector(aSessionId);
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530522 err = statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000523
524 if (err == ERROR_DRM_RESOURCE_BUSY && retry) {
525 mLock.unlock();
526 // reclaimSession may call back to closeSession, since mLock is
527 // shared between Drm instances, we should unlock here to avoid
528 // deadlock.
529 retry = DrmSessionManager::Instance()->reclaimSession(AIBinder_getCallingPid());
530 mLock.lock();
531 } else {
532 retry = false;
533 }
534 } while (retry);
535
536 if (err == OK) {
537 std::shared_ptr<DrmSessionClient> client =
538 ndk::SharedRefBase::make<DrmSessionClient>(this, sessionId);
539 DrmSessionManager::Instance()->addSession(
540 AIBinder_getCallingPid(), std::static_pointer_cast<IResourceManagerClient>(client),
541 sessionId);
542 mOpenSessions.push_back(client);
Kyle Zhangc33286b2023-02-02 22:59:05 +0000543 mMetrics->SetSessionStart(sessionId);
Kyle Zhang6605add2022-01-13 17:51:23 +0000544 }
545
Kyle Zhangc33286b2023-02-02 22:59:05 +0000546 mMetrics->mOpenSessionCounter.Increment(err);
Kyle Zhang6605add2022-01-13 17:51:23 +0000547 return err;
548}
549
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530550DrmStatus DrmHalAidl::closeSession(Vector<uint8_t> const& sessionId) {
Kyle Zhang6605add2022-01-13 17:51:23 +0000551 Mutex::Autolock autoLock(mLock);
552 INIT_CHECK();
553
554 std::vector<uint8_t> sessionIdAidl = toStdVec(sessionId);
555 ::ndk::ScopedAStatus status = mPlugin->closeSession(sessionIdAidl);
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530556 DrmStatus response = statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000557 if (status.isOk()) {
558 DrmSessionManager::Instance()->removeSession(sessionId);
559 for (auto i = mOpenSessions.begin(); i != mOpenSessions.end(); i++) {
560 if (isEqualSessionId((*i)->mSessionId, sessionId)) {
561 mOpenSessions.erase(i);
562 break;
563 }
564 }
565
Kyle Zhangc33286b2023-02-02 22:59:05 +0000566 mMetrics->SetSessionEnd(sessionId);
Kyle Zhang6605add2022-01-13 17:51:23 +0000567 }
Kyle Zhangfa72c482022-02-04 03:55:43 +0000568
Kyle Zhangc33286b2023-02-02 22:59:05 +0000569 mMetrics->mCloseSessionCounter.Increment(response);
Kyle Zhang96af9572022-02-05 06:38:53 +0000570 return response;
Kyle Zhang6605add2022-01-13 17:51:23 +0000571}
572
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530573DrmStatus DrmHalAidl::getKeyRequest(Vector<uint8_t> const& sessionId,
574 Vector<uint8_t> const& initData, String8 const& mimeType,
575 DrmPlugin::KeyType keyType,
576 KeyedVector<String8, String8> const& optionalParameters,
577 Vector<uint8_t>& request, String8& defaultUrl,
578 DrmPlugin::KeyRequestType* keyRequestType) {
Kyle Zhang6605add2022-01-13 17:51:23 +0000579 Mutex::Autolock autoLock(mLock);
580 INIT_CHECK();
Kyle Zhangc33286b2023-02-02 22:59:05 +0000581 EventTimer<status_t> keyRequestTimer(&mMetrics->mGetKeyRequestTimeUs);
Kyle Zhang6605add2022-01-13 17:51:23 +0000582
583 DrmSessionManager::Instance()->useSession(sessionId);
584
585 KeyType aKeyType;
586 if (keyType == DrmPlugin::kKeyType_Streaming) {
587 aKeyType = KeyType::STREAMING;
588 } else if (keyType == DrmPlugin::kKeyType_Offline) {
589 aKeyType = KeyType::OFFLINE;
590 } else if (keyType == DrmPlugin::kKeyType_Release) {
591 aKeyType = KeyType::RELEASE;
592 } else {
593 keyRequestTimer.SetAttribute(BAD_VALUE);
594 return BAD_VALUE;
595 }
596
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530597 DrmStatus err = UNKNOWN_ERROR;
Kyle Zhang6605add2022-01-13 17:51:23 +0000598
599 std::vector<uint8_t> sessionIdAidl = toStdVec(sessionId);
600 std::vector<uint8_t> initDataAidl = toStdVec(initData);
601 KeyRequest keyRequest;
602
603 ::ndk::ScopedAStatus status =
604 mPlugin->getKeyRequest(sessionIdAidl, initDataAidl, toStdString(mimeType), aKeyType,
605 toKeyValueVector(optionalParameters), &keyRequest);
606 if (status.isOk()) {
607 request = toVector(keyRequest.request);
608 defaultUrl = toString8(keyRequest.defaultUrl);
609 *keyRequestType = toKeyRequestType(keyRequest.requestType);
610 }
611
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530612 err = statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000613 keyRequestTimer.SetAttribute(err);
614 return err;
615}
616
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530617DrmStatus DrmHalAidl::provideKeyResponse(Vector<uint8_t> const& sessionId,
618 Vector<uint8_t> const& response,
619 Vector<uint8_t>& keySetId) {
Kyle Zhang6605add2022-01-13 17:51:23 +0000620 Mutex::Autolock autoLock(mLock);
621 INIT_CHECK();
Kyle Zhangc33286b2023-02-02 22:59:05 +0000622 EventTimer<status_t> keyResponseTimer(&mMetrics->mProvideKeyResponseTimeUs);
Kyle Zhang6605add2022-01-13 17:51:23 +0000623
624 DrmSessionManager::Instance()->useSession(sessionId);
625
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530626 DrmStatus err = UNKNOWN_ERROR;
Kyle Zhang6605add2022-01-13 17:51:23 +0000627
628 std::vector<uint8_t> sessionIdAidl = toStdVec(sessionId);
629 std::vector<uint8_t> responseAidl = toStdVec(response);
630 KeySetId keySetIdsAidl;
631 ::ndk::ScopedAStatus status =
632 mPlugin->provideKeyResponse(sessionIdAidl, responseAidl, &keySetIdsAidl);
633
634 if (status.isOk()) keySetId = toVector(keySetIdsAidl.keySetId);
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530635 err = statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000636 keyResponseTimer.SetAttribute(err);
637 return err;
638}
639
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530640DrmStatus DrmHalAidl::removeKeys(Vector<uint8_t> const& keySetId) {
Kyle Zhang6605add2022-01-13 17:51:23 +0000641 Mutex::Autolock autoLock(mLock);
642 INIT_CHECK();
643
644 ::ndk::ScopedAStatus status = mPlugin->removeKeys(toStdVec(keySetId));
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530645 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000646}
647
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530648DrmStatus DrmHalAidl::restoreKeys(Vector<uint8_t> const& sessionId,
649 Vector<uint8_t> const& keySetId) {
Kyle Zhang6605add2022-01-13 17:51:23 +0000650 Mutex::Autolock autoLock(mLock);
651 INIT_CHECK();
652
653 DrmSessionManager::Instance()->useSession(sessionId);
654
655 KeySetId keySetIdsAidl;
656 keySetIdsAidl.keySetId = toStdVec(keySetId);
657 ::ndk::ScopedAStatus status = mPlugin->restoreKeys(toStdVec(sessionId), keySetIdsAidl);
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530658 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000659}
660
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530661DrmStatus DrmHalAidl::queryKeyStatus(Vector<uint8_t> const& sessionId,
662 KeyedVector<String8, String8>& infoMap) const {
Kyle Zhang6605add2022-01-13 17:51:23 +0000663 Mutex::Autolock autoLock(mLock);
664 INIT_CHECK();
665
666 DrmSessionManager::Instance()->useSession(sessionId);
667
668 std::vector<KeyValue> infoMapAidl;
669 ::ndk::ScopedAStatus status = mPlugin->queryKeyStatus(toStdVec(sessionId), &infoMapAidl);
670
671 infoMap = toKeyedVector(infoMapAidl);
672
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530673 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000674}
675
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530676DrmStatus DrmHalAidl::getProvisionRequest(String8 const& certType, String8 const& certAuthority,
677 Vector<uint8_t>& request, String8& defaultUrl) {
Kyle Zhang6605add2022-01-13 17:51:23 +0000678 Mutex::Autolock autoLock(mLock);
679 INIT_CHECK();
680
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530681 DrmStatus err = UNKNOWN_ERROR;
Kyle Zhang6605add2022-01-13 17:51:23 +0000682
683 ProvisionRequest requestAidl;
684 ::ndk::ScopedAStatus status = mPlugin->getProvisionRequest(
685 toStdString(certType), toStdString(certAuthority), &requestAidl);
686
687 request = toVector(requestAidl.request);
688 defaultUrl = toString8(requestAidl.defaultUrl);
689
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530690 err = statusAidlToDrmStatus(status);
Kyle Zhangc33286b2023-02-02 22:59:05 +0000691 mMetrics->mGetProvisionRequestCounter.Increment(err);
Kyle Zhang6605add2022-01-13 17:51:23 +0000692 return err;
693}
694
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530695DrmStatus DrmHalAidl::provideProvisionResponse(Vector<uint8_t> const& response,
696 Vector<uint8_t>& certificate,
697 Vector<uint8_t>& wrappedKey) {
Kyle Zhang6605add2022-01-13 17:51:23 +0000698 Mutex::Autolock autoLock(mLock);
699 INIT_CHECK();
700
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530701 DrmStatus err = UNKNOWN_ERROR;
Kyle Zhang6605add2022-01-13 17:51:23 +0000702 ProvideProvisionResponseResult result;
703 ::ndk::ScopedAStatus status = mPlugin->provideProvisionResponse(toStdVec(response), &result);
704
705 certificate = toVector(result.certificate);
706 wrappedKey = toVector(result.wrappedKey);
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530707 err = statusAidlToDrmStatus(status);
Kyle Zhangc33286b2023-02-02 22:59:05 +0000708 mMetrics->mProvideProvisionResponseCounter.Increment(err);
Kyle Zhang6605add2022-01-13 17:51:23 +0000709 return err;
710}
711
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530712DrmStatus DrmHalAidl::getSecureStops(List<Vector<uint8_t>>& secureStops) {
Kyle Zhang6605add2022-01-13 17:51:23 +0000713 Mutex::Autolock autoLock(mLock);
714 INIT_CHECK();
715
716 std::vector<SecureStop> result;
717 ::ndk::ScopedAStatus status = mPlugin->getSecureStops(&result);
718
719 secureStops = toSecureStops(result);
720
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530721 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000722}
723
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530724DrmStatus DrmHalAidl::getSecureStopIds(List<Vector<uint8_t>>& secureStopIds) {
Kyle Zhang6605add2022-01-13 17:51:23 +0000725 Mutex::Autolock autoLock(mLock);
726 INIT_CHECK();
727
728 std::vector<SecureStopId> result;
729 ::ndk::ScopedAStatus status = mPlugin->getSecureStopIds(&result);
730
731 secureStopIds = toSecureStopIds(result);
732
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530733 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000734}
735
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530736DrmStatus DrmHalAidl::getSecureStop(Vector<uint8_t> const& ssid, Vector<uint8_t>& secureStop) {
Kyle Zhang6605add2022-01-13 17:51:23 +0000737 Mutex::Autolock autoLock(mLock);
738 INIT_CHECK();
739
740 SecureStopId ssidAidl;
741 ssidAidl.secureStopId = toStdVec(ssid);
742
743 SecureStop result;
744 ::ndk::ScopedAStatus status = mPlugin->getSecureStop(ssidAidl, &result);
745
746 secureStop = toVector(result.opaqueData);
747
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530748 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000749}
750
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530751DrmStatus DrmHalAidl::releaseSecureStops(Vector<uint8_t> const& ssRelease) {
Kyle Zhang6605add2022-01-13 17:51:23 +0000752 Mutex::Autolock autoLock(mLock);
753 INIT_CHECK();
754
755 OpaqueData ssId;
756 ssId.opaqueData = toStdVec(ssRelease);
757 ::ndk::ScopedAStatus status = mPlugin->releaseSecureStops(ssId);
758
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530759 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000760}
761
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530762DrmStatus DrmHalAidl::removeSecureStop(Vector<uint8_t> const& ssid) {
Kyle Zhang6605add2022-01-13 17:51:23 +0000763 Mutex::Autolock autoLock(mLock);
764
765 INIT_CHECK();
766
767 SecureStopId ssidAidl;
768 ssidAidl.secureStopId = toStdVec(ssid);
769 ::ndk::ScopedAStatus status = mPlugin->removeSecureStop(ssidAidl);
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530770 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000771}
772
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530773DrmStatus DrmHalAidl::removeAllSecureStops() {
Kyle Zhang6605add2022-01-13 17:51:23 +0000774 Mutex::Autolock autoLock(mLock);
775 INIT_CHECK();
776
777 ::ndk::ScopedAStatus status = mPlugin->releaseAllSecureStops();
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530778 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000779}
780
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530781DrmStatus DrmHalAidl::getHdcpLevels(DrmPlugin::HdcpLevel* connected,
782 DrmPlugin::HdcpLevel* max) const {
Kyle Zhang6605add2022-01-13 17:51:23 +0000783 Mutex::Autolock autoLock(mLock);
784 INIT_CHECK();
785
786 if (connected == NULL || max == NULL) {
787 return BAD_VALUE;
788 }
789
790 *connected = DrmPlugin::kHdcpLevelUnknown;
791 *max = DrmPlugin::kHdcpLevelUnknown;
792
793 HdcpLevels lvlsAidl;
794 ::ndk::ScopedAStatus status = mPlugin->getHdcpLevels(&lvlsAidl);
795
796 *connected = toHdcpLevel(lvlsAidl.connectedLevel);
797 *max = toHdcpLevel(lvlsAidl.maxLevel);
798
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530799 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000800}
801
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530802DrmStatus DrmHalAidl::getNumberOfSessions(uint32_t* open, uint32_t* max) const {
Kyle Zhang6605add2022-01-13 17:51:23 +0000803 Mutex::Autolock autoLock(mLock);
804 INIT_CHECK();
805
806 if (open == NULL || max == NULL) {
807 return BAD_VALUE;
808 }
809
810 *open = 0;
811 *max = 0;
812
813 NumberOfSessions result;
814 ::ndk::ScopedAStatus status = mPlugin->getNumberOfSessions(&result);
815
816 *open = result.currentSessions;
817 *max = result.maxSessions;
818
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530819 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000820}
821
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530822DrmStatus DrmHalAidl::getSecurityLevel(Vector<uint8_t> const& sessionId,
823 DrmPlugin::SecurityLevel* level) const {
Kyle Zhang6605add2022-01-13 17:51:23 +0000824 Mutex::Autolock autoLock(mLock);
825 INIT_CHECK();
826
827 if (level == NULL) {
828 return BAD_VALUE;
829 }
830
831 *level = DrmPlugin::kSecurityLevelUnknown;
832
833 SecurityLevel result;
834 ::ndk::ScopedAStatus status = mPlugin->getSecurityLevel(toStdVec(sessionId), &result);
835
836 *level = toSecurityLevel(result);
837
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530838 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000839}
840
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530841DrmStatus DrmHalAidl::getOfflineLicenseKeySetIds(List<Vector<uint8_t>>& keySetIds) const {
Kyle Zhang6605add2022-01-13 17:51:23 +0000842 Mutex::Autolock autoLock(mLock);
843 INIT_CHECK();
844
845 std::vector<KeySetId> result;
846 ::ndk::ScopedAStatus status = mPlugin->getOfflineLicenseKeySetIds(&result);
847
848 keySetIds = toKeySetIds(result);
849
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530850 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000851}
852
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530853DrmStatus DrmHalAidl::removeOfflineLicense(Vector<uint8_t> const& keySetId) {
Kyle Zhang6605add2022-01-13 17:51:23 +0000854 Mutex::Autolock autoLock(mLock);
855 INIT_CHECK();
856
857 KeySetId keySetIdAidl;
858 keySetIdAidl.keySetId = toStdVec(keySetId);
859 ::ndk::ScopedAStatus status = mPlugin->removeOfflineLicense(keySetIdAidl);
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530860 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000861}
862
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530863DrmStatus DrmHalAidl::getOfflineLicenseState(Vector<uint8_t> const& keySetId,
864 DrmPlugin::OfflineLicenseState* licenseState) const {
Kyle Zhang6605add2022-01-13 17:51:23 +0000865 Mutex::Autolock autoLock(mLock);
866
867 INIT_CHECK();
868 *licenseState = DrmPlugin::kOfflineLicenseStateUnknown;
869
870 KeySetId keySetIdAidl;
871 keySetIdAidl.keySetId = toStdVec(keySetId);
872
873 OfflineLicenseState result;
874 ::ndk::ScopedAStatus status = mPlugin->getOfflineLicenseState(keySetIdAidl, &result);
875
876 *licenseState = toOfflineLicenseState(result);
877
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530878 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000879}
880
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530881DrmStatus DrmHalAidl::getPropertyString(String8 const& name, String8& value) const {
Kyle Zhang6605add2022-01-13 17:51:23 +0000882 Mutex::Autolock autoLock(mLock);
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530883 return DrmStatus(getPropertyStringInternal(name, value));
Kyle Zhang6605add2022-01-13 17:51:23 +0000884}
885
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530886DrmStatus DrmHalAidl::getPropertyStringInternal(String8 const& name, String8& value) const {
Kyle Zhang6605add2022-01-13 17:51:23 +0000887 // This function is internal to the class and should only be called while
888 // mLock is already held.
889 INIT_CHECK();
890
891 std::string result;
892 ::ndk::ScopedAStatus status = mPlugin->getPropertyString(toStdString(name), &result);
893
894 value = toString8(result);
895
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530896 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000897}
898
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530899DrmStatus DrmHalAidl::getPropertyByteArray(String8 const& name, Vector<uint8_t>& value) const {
Kyle Zhang6605add2022-01-13 17:51:23 +0000900 Mutex::Autolock autoLock(mLock);
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530901 return DrmStatus(getPropertyByteArrayInternal(name, value));
Kyle Zhang6605add2022-01-13 17:51:23 +0000902}
903
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530904DrmStatus DrmHalAidl::getPropertyByteArrayInternal(String8 const& name,
905 Vector<uint8_t>& value) const {
Kyle Zhang6605add2022-01-13 17:51:23 +0000906 // This function is internal to the class and should only be called while
907 // mLock is already held.
908 INIT_CHECK();
909
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530910 DrmStatus err = UNKNOWN_ERROR;
Kyle Zhang6605add2022-01-13 17:51:23 +0000911
912 std::vector<uint8_t> result;
913 ::ndk::ScopedAStatus status = mPlugin->getPropertyByteArray(toStdString(name), &result);
914
915 value = toVector(result);
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530916 err = statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000917 if (name == kPropertyDeviceUniqueId) {
Kyle Zhangc33286b2023-02-02 22:59:05 +0000918 mMetrics->mGetDeviceUniqueIdCounter.Increment(err);
Kyle Zhang6605add2022-01-13 17:51:23 +0000919 }
920 return err;
921}
922
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530923DrmStatus DrmHalAidl::setPropertyString(String8 const& name, String8 const& value) const {
Kyle Zhang6605add2022-01-13 17:51:23 +0000924 Mutex::Autolock autoLock(mLock);
925 INIT_CHECK();
926
927 ::ndk::ScopedAStatus status = mPlugin->setPropertyString(toStdString(name), toStdString(value));
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530928 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000929}
930
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530931DrmStatus DrmHalAidl::setPropertyByteArray(String8 const& name,
932 Vector<uint8_t> const& value) const {
Kyle Zhang6605add2022-01-13 17:51:23 +0000933 Mutex::Autolock autoLock(mLock);
934 INIT_CHECK();
935
936 ::ndk::ScopedAStatus status = mPlugin->setPropertyByteArray(toStdString(name), toStdVec(value));
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530937 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000938}
939
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530940DrmStatus DrmHalAidl::getMetrics(const sp<IDrmMetricsConsumer>& consumer) {
Kyle Zhang6605add2022-01-13 17:51:23 +0000941 if (consumer == nullptr) {
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530942 return DrmStatus(UNEXPECTED_NULL);
Kyle Zhang6605add2022-01-13 17:51:23 +0000943 }
Kyle Zhangc33286b2023-02-02 22:59:05 +0000944 consumer->consumeFrameworkMetrics(*mMetrics.get());
Kyle Zhang6605add2022-01-13 17:51:23 +0000945
946 // Append vendor metrics if they are supported.
947
948 String8 vendor;
949 String8 description;
950 if (getPropertyStringInternal(String8("vendor"), vendor) != OK || vendor.isEmpty()) {
951 ALOGE("Get vendor failed or is empty");
952 vendor = "NONE";
953 }
954 if (getPropertyStringInternal(String8("description"), description) != OK ||
955 description.isEmpty()) {
956 ALOGE("Get description failed or is empty.");
957 description = "NONE";
958 }
959 vendor += ".";
960 vendor += description;
961
962 hidl_vec<DrmMetricGroupHidl> pluginMetrics;
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530963 DrmStatus err = UNKNOWN_ERROR;
Kyle Zhang6605add2022-01-13 17:51:23 +0000964
965 std::vector<DrmMetricGroupAidl> result;
966 ::ndk::ScopedAStatus status = mPlugin->getMetrics(&result);
967
968 if (status.isOk()) {
969 pluginMetrics = toDrmMetricGroupHidl(result);
970 consumer->consumeHidlMetrics(vendor, pluginMetrics);
971 }
972
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530973 err = statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000974
975 return err;
976}
977
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530978DrmStatus DrmHalAidl::setCipherAlgorithm(Vector<uint8_t> const& sessionId,
979 String8 const& algorithm) {
Kyle Zhang6605add2022-01-13 17:51:23 +0000980 Mutex::Autolock autoLock(mLock);
981 INIT_CHECK();
982
983 DrmSessionManager::Instance()->useSession(sessionId);
984
985 ::ndk::ScopedAStatus status =
986 mPlugin->setCipherAlgorithm(toStdVec(sessionId), toStdString(algorithm));
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530987 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000988}
989
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530990DrmStatus DrmHalAidl::setMacAlgorithm(Vector<uint8_t> const& sessionId, String8 const& algorithm) {
Kyle Zhang6605add2022-01-13 17:51:23 +0000991 Mutex::Autolock autoLock(mLock);
992 INIT_CHECK();
993
994 DrmSessionManager::Instance()->useSession(sessionId);
995
996 ::ndk::ScopedAStatus status =
997 mPlugin->setMacAlgorithm(toStdVec(sessionId), toStdString(algorithm));
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +0530998 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +0000999}
1000
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +05301001DrmStatus DrmHalAidl::encrypt(Vector<uint8_t> const& sessionId, Vector<uint8_t> const& keyId,
1002 Vector<uint8_t> const& input, Vector<uint8_t> const& iv,
1003 Vector<uint8_t>& output) {
Kyle Zhang6605add2022-01-13 17:51:23 +00001004 Mutex::Autolock autoLock(mLock);
1005 INIT_CHECK();
1006
1007 DrmSessionManager::Instance()->useSession(sessionId);
1008
1009 std::vector<uint8_t> result;
1010 ::ndk::ScopedAStatus status = mPlugin->encrypt(toStdVec(sessionId), toStdVec(keyId),
1011 toStdVec(input), toStdVec(iv), &result);
1012
1013 output = toVector(result);
1014
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +05301015 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +00001016}
1017
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +05301018DrmStatus DrmHalAidl::decrypt(Vector<uint8_t> const& sessionId, Vector<uint8_t> const& keyId,
1019 Vector<uint8_t> const& input, Vector<uint8_t> const& iv,
1020 Vector<uint8_t>& output) {
Kyle Zhang6605add2022-01-13 17:51:23 +00001021 Mutex::Autolock autoLock(mLock);
1022 INIT_CHECK();
1023
1024 DrmSessionManager::Instance()->useSession(sessionId);
1025
1026 std::vector<uint8_t> result;
1027 ::ndk::ScopedAStatus status = mPlugin->decrypt(toStdVec(sessionId), toStdVec(keyId),
1028 toStdVec(input), toStdVec(iv), &result);
1029
1030 output = toVector(result);
1031
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +05301032 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +00001033}
1034
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +05301035DrmStatus DrmHalAidl::sign(Vector<uint8_t> const& sessionId, Vector<uint8_t> const& keyId,
1036 Vector<uint8_t> const& message, Vector<uint8_t>& signature) {
Kyle Zhang6605add2022-01-13 17:51:23 +00001037 Mutex::Autolock autoLock(mLock);
1038 INIT_CHECK();
1039
1040 DrmSessionManager::Instance()->useSession(sessionId);
1041
1042 std::vector<uint8_t> result;
1043 ::ndk::ScopedAStatus status =
1044 mPlugin->sign(toStdVec(sessionId), toStdVec(keyId), toStdVec(message), &result);
1045
1046 signature = toVector(result);
1047
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +05301048 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +00001049}
1050
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +05301051DrmStatus DrmHalAidl::verify(Vector<uint8_t> const& sessionId, Vector<uint8_t> const& keyId,
1052 Vector<uint8_t> const& message, Vector<uint8_t> const& signature,
1053 bool& match) {
Kyle Zhang6605add2022-01-13 17:51:23 +00001054 Mutex::Autolock autoLock(mLock);
1055 INIT_CHECK();
1056
1057 DrmSessionManager::Instance()->useSession(sessionId);
1058
1059 ::ndk::ScopedAStatus status = mPlugin->verify(toStdVec(sessionId), toStdVec(keyId),
1060 toStdVec(message), toStdVec(signature), &match);
1061
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +05301062 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +00001063}
1064
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +05301065DrmStatus DrmHalAidl::signRSA(Vector<uint8_t> const& sessionId, String8 const& algorithm,
1066 Vector<uint8_t> const& message, Vector<uint8_t> const& wrappedKey,
1067 Vector<uint8_t>& signature) {
Kyle Zhang6605add2022-01-13 17:51:23 +00001068 Mutex::Autolock autoLock(mLock);
1069 INIT_CHECK();
1070
1071 DrmSessionManager::Instance()->useSession(sessionId);
1072
1073 std::vector<uint8_t> result;
1074 ::ndk::ScopedAStatus status =
1075 mPlugin->signRSA(toStdVec(sessionId), toStdString(algorithm), toStdVec(message),
1076 toStdVec(wrappedKey), &result);
1077
1078 signature = toVector(result);
1079
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +05301080 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +00001081}
1082
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +05301083DrmStatus DrmHalAidl::requiresSecureDecoder(const char* mime, bool* required) const {
Kyle Zhang6605add2022-01-13 17:51:23 +00001084 Mutex::Autolock autoLock(mLock);
1085 INIT_CHECK();
1086
1087 std::string mimeAidl(mime);
Kyle Zhang994023a2022-02-09 05:32:12 +00001088 ::ndk::ScopedAStatus status =
1089 mPlugin->requiresSecureDecoder(mimeAidl, SecurityLevel::DEFAULT, required);
Kyle Zhang6605add2022-01-13 17:51:23 +00001090 if (!status.isOk()) {
1091 DrmUtils::LOG2BE("requiresSecureDecoder txn failed: %d", status.getServiceSpecificError());
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +05301092 return DrmStatus(DEAD_OBJECT);
Kyle Zhang6605add2022-01-13 17:51:23 +00001093 }
1094
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +05301095 return DrmStatus(OK);
Kyle Zhang6605add2022-01-13 17:51:23 +00001096}
1097
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +05301098DrmStatus DrmHalAidl::requiresSecureDecoder(const char* mime,
1099 DrmPlugin::SecurityLevel securityLevel,
1100 bool* required) const {
Kyle Zhang6605add2022-01-13 17:51:23 +00001101 Mutex::Autolock autoLock(mLock);
1102 INIT_CHECK();
1103
1104 auto aLevel = toAidlSecurityLevel(securityLevel);
1105 std::string mimeAidl(mime);
1106 ::ndk::ScopedAStatus status = mPlugin->requiresSecureDecoder(mimeAidl, aLevel, required);
Kyle Zhang96af9572022-02-05 06:38:53 +00001107
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +05301108 DrmStatus err = statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +00001109 if (!status.isOk()) {
1110 DrmUtils::LOG2BE("requiresSecureDecoder txn failed: %d", status.getServiceSpecificError());
Kyle Zhang6605add2022-01-13 17:51:23 +00001111 }
1112
Kyle Zhang96af9572022-02-05 06:38:53 +00001113 return err;
Kyle Zhang6605add2022-01-13 17:51:23 +00001114}
1115
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +05301116DrmStatus DrmHalAidl::setPlaybackId(Vector<uint8_t> const& sessionId, const char* playbackId) {
Kyle Zhang6605add2022-01-13 17:51:23 +00001117 Mutex::Autolock autoLock(mLock);
1118 INIT_CHECK();
1119 std::string playbackIdAidl(playbackId);
1120 ::ndk::ScopedAStatus status = mPlugin->setPlaybackId(toStdVec(sessionId), playbackIdAidl);
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +05301121 return statusAidlToDrmStatus(status);
Kyle Zhang6605add2022-01-13 17:51:23 +00001122}
1123
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +05301124DrmStatus DrmHalAidl::getLogMessages(Vector<drm::V1_4::LogMessage>& logs) const {
Kyle Zhang6605add2022-01-13 17:51:23 +00001125 Mutex::Autolock autoLock(mLock);
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +05301126 return DrmStatus(DrmUtils::GetLogMessagesAidl<IDrmPluginAidl>(mPlugin, logs));
Kyle Zhang6605add2022-01-13 17:51:23 +00001127}
1128
1129void DrmHalAidl::closeOpenSessions() {
1130 Mutex::Autolock autoLock(mLock);
1131 auto openSessions = mOpenSessions;
1132 for (size_t i = 0; i < openSessions.size(); i++) {
1133 mLock.unlock();
1134 closeSession(openSessions[i]->mSessionId);
1135 mLock.lock();
1136 }
1137 mOpenSessions.clear();
1138}
1139
1140std::string DrmHalAidl::reportPluginMetrics() const {
1141 Vector<uint8_t> metricsVector;
1142 String8 vendor;
1143 String8 description;
1144 std::string metricsString;
1145 if (getPropertyStringInternal(String8("vendor"), vendor) == OK &&
1146 getPropertyStringInternal(String8("description"), description) == OK &&
1147 getPropertyByteArrayInternal(String8("metrics"), metricsVector) == OK) {
1148 metricsString = toBase64StringNoPad(metricsVector.array(), metricsVector.size());
1149 status_t res = android::reportDrmPluginMetrics(metricsString, vendor, description,
Kyle Zhangc33286b2023-02-02 22:59:05 +00001150 mMetrics->GetAppUid());
Kyle Zhang6605add2022-01-13 17:51:23 +00001151 if (res != OK) {
1152 ALOGE("Metrics were retrieved but could not be reported: %d", res);
1153 }
1154 }
1155 return metricsString;
1156}
1157
1158std::string DrmHalAidl::reportFrameworkMetrics(const std::string& pluginMetrics) const {
1159 mediametrics_handle_t item(mediametrics_create("mediadrm"));
Kyle Zhangc33286b2023-02-02 22:59:05 +00001160 mediametrics_setUid(item, mMetrics->GetAppUid());
Kyle Zhang6605add2022-01-13 17:51:23 +00001161 String8 vendor;
1162 String8 description;
1163 status_t result = getPropertyStringInternal(String8("vendor"), vendor);
1164 if (result != OK) {
1165 ALOGE("Failed to get vendor from drm plugin: %d", result);
1166 } else {
1167 mediametrics_setCString(item, "vendor", vendor.c_str());
1168 }
1169 result = getPropertyStringInternal(String8("description"), description);
1170 if (result != OK) {
1171 ALOGE("Failed to get description from drm plugin: %d", result);
1172 } else {
1173 mediametrics_setCString(item, "description", description.c_str());
1174 }
1175
1176 std::string serializedMetrics;
Kyle Zhangc33286b2023-02-02 22:59:05 +00001177 result = mMetrics->GetSerializedMetrics(&serializedMetrics);
Kyle Zhang6605add2022-01-13 17:51:23 +00001178 if (result != OK) {
1179 ALOGE("Failed to serialize framework metrics: %d", result);
1180 }
1181 std::string b64EncodedMetrics =
1182 toBase64StringNoPad(serializedMetrics.data(), serializedMetrics.size());
1183 if (!b64EncodedMetrics.empty()) {
1184 mediametrics_setCString(item, "serialized_metrics", b64EncodedMetrics.c_str());
1185 }
1186 if (!pluginMetrics.empty()) {
1187 mediametrics_setCString(item, "plugin_metrics", pluginMetrics.c_str());
1188 }
1189 if (!mediametrics_selfRecord(item)) {
1190 ALOGE("Failed to self record framework metrics");
1191 }
1192 mediametrics_delete(item);
1193 return serializedMetrics;
1194}
1195
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +05301196DrmStatus DrmHalAidl::getSupportedSchemes(std::vector<uint8_t>& schemes) const {
Kyle Zhang2567a5e2022-03-17 23:36:26 +00001197 Mutex::Autolock autoLock(mLock);
1198
1199 if (mFactories.empty()) return UNKNOWN_ERROR;
1200 for (ssize_t i = mFactories.size() - 1; i >= 0; i--) {
1201 CryptoSchemes curSchemes{};
1202 auto err = mFactories[i]->getSupportedCryptoSchemes(&curSchemes);
1203 if (!err.isOk()) {
1204 continue;
1205 }
1206
1207 for (auto uuidObj : curSchemes.uuids) {
1208 schemes.insert(schemes.end(), uuidObj.uuid.begin(), uuidObj.uuid.end());
1209 }
1210 }
1211
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +05301212 return DrmStatus(OK);
Kyle Zhang2567a5e2022-03-17 23:36:26 +00001213}
1214
Kyle Zhang6605add2022-01-13 17:51:23 +00001215void DrmHalAidl::cleanup() {
1216 closeOpenSessions();
1217
1218 Mutex::Autolock autoLock(mLock);
Kyle Zhang4a7dd2c2023-03-01 21:13:29 +00001219 if (mInitCheck == OK) reportFrameworkMetrics(reportPluginMetrics());
Kyle Zhang6605add2022-01-13 17:51:23 +00001220
1221 setListener(NULL);
1222 mInitCheck = NO_INIT;
1223 if (mPlugin != NULL) {
1224 if (!mPlugin->setListener(NULL).isOk()) {
1225 mInitCheck = DEAD_OBJECT;
1226 }
1227 }
1228
1229 mPlugin.reset();
1230}
1231
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +05301232DrmStatus DrmHalAidl::destroyPlugin() {
Kyle Zhang6605add2022-01-13 17:51:23 +00001233 cleanup();
Sohail Nagaraj0cc3da82022-11-30 10:22:37 +05301234 return DrmStatus(OK);
Kyle Zhang6605add2022-01-13 17:51:23 +00001235}
1236
1237::ndk::ScopedAStatus DrmHalAidl::onEvent(EventTypeAidl eventTypeAidl,
1238 const std::vector<uint8_t>& sessionId,
1239 const std::vector<uint8_t>& data) {
Kyle Zhanga55209d2022-02-03 01:52:46 +00001240 return mListener->onEvent(eventTypeAidl, sessionId, data);
Kyle Zhang6605add2022-01-13 17:51:23 +00001241}
1242
1243::ndk::ScopedAStatus DrmHalAidl::onExpirationUpdate(const std::vector<uint8_t>& sessionId,
1244 int64_t expiryTimeInMS) {
Kyle Zhanga55209d2022-02-03 01:52:46 +00001245 return mListener->onExpirationUpdate(sessionId, expiryTimeInMS);
Kyle Zhang6605add2022-01-13 17:51:23 +00001246}
1247
1248::ndk::ScopedAStatus DrmHalAidl::onKeysChange(const std::vector<uint8_t>& sessionId,
1249 const std::vector<KeyStatus>& keyStatusListAidl,
1250 bool hasNewUsableKey) {
Kyle Zhanga55209d2022-02-03 01:52:46 +00001251 return mListener->onKeysChange(sessionId, keyStatusListAidl, hasNewUsableKey);
Kyle Zhang6605add2022-01-13 17:51:23 +00001252}
1253
1254::ndk::ScopedAStatus DrmHalAidl::onSessionLostState(const std::vector<uint8_t>& sessionId) {
Kyle Zhanga55209d2022-02-03 01:52:46 +00001255 return mListener->onSessionLostState(sessionId);
Kyle Zhang6605add2022-01-13 17:51:23 +00001256}
1257
1258} // namespace android