Implement MediaDrm offline license support in Widevine hidl service.

Merged from http://go/wvgerrit/69723.

The new APIs are getOfflineLicenseIds, getOfflineLicenseState and
removeOfflineLicense. These methods are currently stubbed out in
Widevine hidl service. This CL completes the implementation.

Test: unit tests - libwvdrmdrmplugin_hidl_test

Test: GTS
  --test com.google.android.media.gts.MediaDrmTest#testWidevineApi29

bug: 117570686
Change-Id: I96ffb75f453e36e931effefd3664b5faa8d69d30

libwvdrmengine/mediadrm/src_hidl/WVDrmPlugin.cpp

@@ -55,6 +55,7 @@ using wvcdm::CdmProvisioningRequest;
 using wvcdm::CdmProvisioningResponse;
 using wvcdm::CdmQueryMap;
 using wvcdm::CdmSecureStopId;
+using wvcdm::CdmSecurityLevel;
 using wvcdm::CdmUsageInfo;
 using wvcdm::CdmUsageInfoReleaseMessage;
 using wvcdm::KeyId;
@@ -132,7 +133,7 @@ KeyStatusType ConvertFromCdmKeyStatus(CdmKeyStatus keyStatus) {
   }
 }
 
-HdcpLevel mapHdcpLevel(const std::string level) {
+HdcpLevel mapHdcpLevel(const std::string& level) {
   if (level == wvcdm::QUERY_VALUE_HDCP_V1)
     return HdcpLevel::HDCP_V1;
   else if (level == wvcdm::QUERY_VALUE_HDCP_V2_0)
@@ -1048,20 +1049,91 @@ Return<void> WVDrmPlugin::getSecurityLevel(
 
 Return<void> WVDrmPlugin::getOfflineLicenseKeySetIds(
     getOfflineLicenseKeySetIds_cb _hidl_cb) {
-  std::vector<KeySetId> keySetIds;
+  std::vector<std::vector<uint8_t> > keySetIds;
+  std::vector<KeySetId> keySetIdsVec;
 
-  _hidl_cb(Status::ERROR_DRM_CANNOT_HANDLE, keySetIds);
+  CdmIdentifier identifier;
+  Status status = mCdmIdentifierBuilder.getCdmIdentifier(&identifier);
+  if (status != Status::OK) {
+    _hidl_cb(status, toHidlVec(keySetIdsVec));
+    return Void();
+  }
+
+  std::vector<CdmSecurityLevel> levels = {
+      wvcdm::kSecurityLevelL1, wvcdm::kSecurityLevelL3 };
+
+  CdmResponseType res = wvcdm::UNKNOWN_ERROR;
+
+  for (auto level : levels) {
+    std::vector<CdmKeySetId> cdmKeySetIds;
+    res = mCDM->ListStoredLicenses(level, identifier, &cdmKeySetIds);
+
+    if (isCdmResponseTypeSuccess(res)) {
+      keySetIds.clear();
+      for (auto id : cdmKeySetIds) {
+        keySetIds.push_back(StrToVector(id));
+      }
+      for (auto id : keySetIds) {
+        keySetIdsVec.push_back(id);
+      }
+    }
+  }
+  _hidl_cb(mapCdmResponseType(res), toHidlVec(keySetIdsVec));
   return Void();
 }
 
 Return<void> WVDrmPlugin::getOfflineLicenseState(const KeySetId &keySetId,
     getOfflineLicenseState_cb _hidl_cb) {
+    OfflineLicenseState licenseState = OfflineLicenseState::UNKNOWN;
+
   if (!keySetId.size()) {
-    _hidl_cb(Status::BAD_VALUE, OfflineLicenseState::UNKNOWN);
+    _hidl_cb(Status::BAD_VALUE, licenseState);
     return Void();
   }
 
-  _hidl_cb(Status::ERROR_DRM_CANNOT_HANDLE, OfflineLicenseState::UNKNOWN);
+  CdmIdentifier identifier;
+  Status status = mCdmIdentifierBuilder.getCdmIdentifier(&identifier);
+  if (status != Status::OK) {
+    _hidl_cb(status, licenseState);
+    return Void();
+  }
+
+  CdmResponseType res = wvcdm::UNKNOWN_ERROR;
+  CdmKeySetId keySetIdStr(keySetId.begin(), keySetId.end());
+
+  wvcdm::CdmOfflineLicenseState state = wvcdm::kLicenseStateUnknown;
+  res = mCDM->GetOfflineLicenseState(
+      keySetIdStr,
+      wvcdm::kSecurityLevelL1,
+      identifier,
+      &state);
+  if (!isCdmResponseTypeSuccess(res)) {
+    // try L3
+    res = mCDM->GetOfflineLicenseState(
+        keySetIdStr,
+        wvcdm::kSecurityLevelL3,
+        identifier,
+        &state);
+    if (!isCdmResponseTypeSuccess(res)) {
+      _hidl_cb(Status::BAD_VALUE, licenseState);
+      return Void();
+    }
+  }
+
+  switch(state) {
+    case wvcdm::kLicenseStateActive:
+      licenseState = OfflineLicenseState::USABLE;
+      break;
+    case wvcdm::kLicenseStateReleasing:
+      licenseState = OfflineLicenseState::INACTIVE;
+      break;
+    default:
+      licenseState = OfflineLicenseState::UNKNOWN;
+      ALOGE("Return unknown offline license state for %s", keySetIdStr.c_str());
+      break;
+  }
+
+  _hidl_cb(mapCdmResponseType(res), licenseState);
   return Void();
 }
 
@@ -1070,7 +1142,31 @@ Return<Status> WVDrmPlugin::removeOfflineLicense(const KeySetId &keySetId) {
     return Status::BAD_VALUE;
   }
 
-  return Status::ERROR_DRM_CANNOT_HANDLE;
+  CdmIdentifier identifier;
+  Status status = mCdmIdentifierBuilder.getCdmIdentifier(&identifier);
+  if (status != Status::OK) {
+    return status;
+  }
+
+  CdmResponseType res = wvcdm::UNKNOWN_ERROR;
+
+  res = mCDM->RemoveOfflineLicense(
+      std::string(keySetId.begin(), keySetId.end()),
+      wvcdm::kSecurityLevelL1,
+      identifier);
+  if (!isCdmResponseTypeSuccess(res)) {
+    CdmResponseType res = mCDM->RemoveOfflineLicense(
+        std::string(keySetId.begin(), keySetId.end()),
+        wvcdm::kSecurityLevelL3,
+        identifier);
+    if (isCdmResponseTypeSuccess(res)) {
+      status = Status::OK;
+    } else {
+      status = Status::ERROR_DRM_INVALID_STATE;
+    }
+  }
+
+  return status;
 }
 
 Return<void> WVDrmPlugin::getPropertyString(const hidl_string& propertyName,