Added CDM support for production readiness reporting. am: cd5afa88a6

Original change: https://googleplex-android-review.googlesource.com/c/platform/vendor/widevine/+/18195696

Change-Id: I21f1bf89e4b9821f5b01ced5530a45763543947f
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>

libwvdrmengine/aidl_src/WVDrmFactory.cpp

@@ -238,6 +238,7 @@ void WVDrmFactory::printCdmProperties(int fd) {
       {"can disable analog output:",
        wvcdm::QUERY_KEY_CAN_DISABLE_ANALOG_OUTPUT},
       {"watermarking support:", wvcdm::QUERY_KEY_WATERMARKING_SUPPORT},
+      {"production ready:", wvcdm::QUERY_KEY_PRODUCTION_READY},
   };
 
   string value;

libwvdrmengine/cdm/core/include/crypto_session.h

@@ -221,6 +221,11 @@ class CryptoSession {
       RequestedSecurityLevel requested_security_level,
       CdmWatermarkingSupport* support);
 
+  virtual bool GetProductionReadiness(CdmProductionReadiness* readiness);
+  virtual bool GetProductionReadiness(
+      RequestedSecurityLevel requested_security_level,
+      CdmProductionReadiness* readiness);
+
   virtual bool GetMaximumUsageTableEntries(
       RequestedSecurityLevel security_level, size_t* number_of_entries);
 

libwvdrmengine/cdm/core/include/oemcrypto_adapter.h

@@ -72,6 +72,7 @@ OEMCryptoResult OEMCrypto_GetOEMPublicCertificate(uint8_t* public_cert,
                                                   RequestedSecurityLevel level);
 OEMCrypto_WatermarkingSupport OEMCrypto_GetWatermarkingSupport(
     RequestedSecurityLevel level);
+OEMCryptoResult OEMCrypto_ProductionReady(RequestedSecurityLevel level);
 }  // namespace wvcdm
 
 /* The following functions are deprecated in OEMCrypto v13.  They are defined

libwvdrmengine/cdm/core/include/wv_cdm_constants.h

@@ -111,6 +111,7 @@ static const std::string QUERY_KEY_ANALOG_OUTPUT_CAPABILITIES =
 static const std::string QUERY_KEY_CAN_DISABLE_ANALOG_OUTPUT =
     "CanDisableAnalogOutput";
 static const std::string QUERY_KEY_WATERMARKING_SUPPORT = "WatermarkingSupport";
+static const std::string QUERY_KEY_PRODUCTION_READY = "ProductionReady";
 
 static const std::string QUERY_VALUE_TRUE = "True";
 static const std::string QUERY_VALUE_FALSE = "False";

libwvdrmengine/cdm/core/include/wv_cdm_types.h

@@ -599,6 +599,12 @@ enum CdmWatermarkingSupport : int32_t {
   kWatermarkingAlwaysOn
 };
 
+enum CdmProductionReadiness : int32_t {
+  kProductionReadinessUnknown,
+  kProductionReadinessTrue,
+  kProductionReadinessFalse,
+};
+
 class CdmKeyAllowedUsage {
  public:
   CdmKeyAllowedUsage() { Clear(); }
@@ -842,6 +848,7 @@ const char* CdmUsageEntryStorageTypeToString(CdmUsageEntryStorageType type);
 const char* RequestedSecurityLevelToString(
     RequestedSecurityLevel security_level);
 const char* CdmWatermarkingSupportToString(CdmWatermarkingSupport support);
+const char* CdmProductionReadinessToString(CdmProductionReadiness readiness);
 // Converts a generic, unknown enum value to a string representation
 // containing its numeric value.
 // The pointer returned from this function is thread_local.

libwvdrmengine/cdm/core/src/cdm_engine.cpp

@@ -817,6 +817,28 @@ CdmResponseType CdmEngine::QueryStatus(RequestedSecurityLevel security_level,
     }
     return NO_ERROR;
   }
+  if (query_token == QUERY_KEY_PRODUCTION_READY) {
+    CdmProductionReadiness readiness;
+    if (!crypto_session->GetProductionReadiness(security_level, &readiness)) {
+      LOGW("GetProductionReadiness failed");
+      return UNKNOWN_ERROR;
+    }
+    switch (readiness) {
+      case kProductionReadinessUnknown:
+        *query_response = QUERY_VALUE_UNKNOWN;
+        break;
+      case kProductionReadinessTrue:
+        *query_response = QUERY_VALUE_TRUE;
+        break;
+      case kProductionReadinessFalse:
+        *query_response = QUERY_VALUE_FALSE;
+        break;
+      default:
+        LOGW("Unknown readiness: %d", static_cast<int>(readiness));
+        return UNKNOWN_ERROR;
+    }
+    return NO_ERROR;
+  }
 
   CdmResponseType status;
   M_TIME(status = crypto_session->Open(security_level),

libwvdrmengine/cdm/core/src/crypto_session.cpp

@@ -2345,6 +2345,34 @@ bool CryptoSession::GetWatermarkingSupport(
   return true;
 }
 
+bool CryptoSession::GetProductionReadiness(CdmProductionReadiness* readiness) {
+  RETURN_IF_NOT_OPEN(false);
+  return GetProductionReadiness(requested_security_level_, readiness);
+}
+
+bool CryptoSession::GetProductionReadiness(
+    RequestedSecurityLevel security_level, CdmProductionReadiness* readiness) {
+  LOGV("security_level = %s", RequestedSecurityLevelToString(security_level));
+  RETURN_IF_UNINITIALIZED(false);
+  RETURN_IF_NULL(readiness, false);
+  const OEMCryptoResult result = WithOecReadLock("GetProductionReadiness", [&] {
+    return OEMCrypto_ProductionReady(security_level);
+  });
+  switch (result) {
+    case OEMCrypto_SUCCESS:
+      *readiness = kProductionReadinessTrue;
+      break;
+    case OEMCrypto_ERROR_NOT_IMPLEMENTED:
+      *readiness = kProductionReadinessUnknown;
+      break;
+    case OEMCrypto_ERROR_UNKNOWN_FAILURE:
+    default:  // Other vendor-defined codes indicate not production ready.
+      *readiness = kProductionReadinessFalse;
+      break;
+  }
+  return true;
+}
+
 bool CryptoSession::GetMaximumUsageTableEntries(
     RequestedSecurityLevel security_level, size_t* number_of_entries) {
   LOGV("Getting maximum usage table entries: security_level = %s",

libwvdrmengine/cdm/core/src/oemcrypto_adapter_dynamic.cpp

@@ -1912,6 +1912,15 @@ OEMCrypto_WatermarkingSupport OEMCrypto_GetWatermarkingSupport(
     return OEMCrypto_WatermarkingError;
   return fcn->GetWatermarkingSupport();
 }
+
+OEMCryptoResult OEMCrypto_ProductionReady(wvcdm::RequestedSecurityLevel level) {
+  if (!gAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
+  if (!fcn) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (fcn->version < 17) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (fcn->ProductionReady == nullptr) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  return fcn->ProductionReady();
+}
 }  // namespace wvcdm
 
 extern "C" OEMCryptoResult OEMCrypto_SetSandbox(const uint8_t* sandbox_id,
@@ -3310,15 +3319,6 @@ extern "C" OEMCryptoResult OEMCrypto_LoadCasECMKeys(
                              odd_key);
 }
 
-extern "C" OEMCryptoResult OEMCrypto_ProductionReady() {
-  if (!gAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(kLevelDefault);
-  if (!fcn) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
-  if (fcn->version < 17) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
-  if (fcn->ProductionReady == nullptr) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
-  return fcn->ProductionReady();
-}
-
 extern "C" OEMCryptoResult OEMCrypto_OPK_SerializationVersion(
     uint32_t* ree_major, uint32_t* ree_minor, uint32_t* tee_major,
     uint32_t* tee_minor) {
@@ -3423,3 +3423,7 @@ extern "C" OEMCrypto_WatermarkingSupport OEMCrypto_GetWatermarkingSupport(
     void) {
   return wvcdm::OEMCrypto_GetWatermarkingSupport(kLevelDefault);
 }
+
+extern "C" OEMCryptoResult OEMCrypto_ProductionReady(void) {
+  return wvcdm::OEMCrypto_ProductionReady(kLevelDefault);
+}

libwvdrmengine/cdm/core/src/wv_cdm_types.cpp

@@ -131,6 +131,18 @@ const char* CdmWatermarkingSupportToString(CdmWatermarkingSupport support) {
   return UnknownValueRep(support);
 }
 
+const char* CdmProductionReadinessToString(CdmProductionReadiness readiness) {
+  switch (readiness) {
+    case kProductionReadinessUnknown:
+      return QUERY_VALUE_UNKNOWN.c_str();
+    case kProductionReadinessTrue:
+      return QUERY_VALUE_TRUE.c_str();
+    case kProductionReadinessFalse:
+      return QUERY_VALUE_FALSE.c_str();
+  }
+  return UnknownValueRep(readiness);
+}
+
 const char* UnknownEnumValueToString(int value) {
   snprintf(tl_unknown_rep_buf, sizeof(tl_unknown_rep_buf), "<unknown(%d)>",
            value);

libwvdrmengine/cdm/test/request_license_test.cpp

@@ -5284,6 +5284,14 @@ TEST_F(WvCdmRequestLicenseTest, QueryStatus) {
               value == wvcdm::QUERY_VALUE_CONFIGURABLE ||
               value == wvcdm::QUERY_VALUE_ALWAYS_ON)
       << "Watermarking support";
+
+  EXPECT_EQ(wvcdm::NO_ERROR,
+            decryptor_->QueryStatus(kLevelDefault,
+                                    wvcdm::QUERY_KEY_PRODUCTION_READY, &value));
+  EXPECT_TRUE(value == wvcdm::QUERY_VALUE_TRUE ||
+              value == wvcdm::QUERY_VALUE_FALSE ||
+              value == wvcdm::QUERY_VALUE_UNKNOWN)
+      << "Production ready";
 }
 
 TEST_F(WvCdmRequestLicenseTest, QueryStatusL3) {
@@ -5427,11 +5435,19 @@ TEST_F(WvCdmRequestLicenseTest, QueryStatusL3) {
 
   EXPECT_EQ(wvcdm::NO_ERROR,
             decryptor_->QueryStatus(
-                kLevelDefault, wvcdm::QUERY_KEY_WATERMARKING_SUPPORT, &value));
+                kLevel3, wvcdm::QUERY_KEY_WATERMARKING_SUPPORT, &value));
   EXPECT_TRUE(value == wvcdm::QUERY_VALUE_NOT_SUPPORTED ||
               value == wvcdm::QUERY_VALUE_CONFIGURABLE ||
               value == wvcdm::QUERY_VALUE_ALWAYS_ON)
       << "Watermarking support";
+
+  EXPECT_EQ(wvcdm::NO_ERROR,
+            decryptor_->QueryStatus(kLevel3, wvcdm::QUERY_KEY_PRODUCTION_READY,
+                                    &value));
+  EXPECT_TRUE(value == wvcdm::QUERY_VALUE_TRUE ||
+              value == wvcdm::QUERY_VALUE_FALSE ||
+              value == wvcdm::QUERY_VALUE_UNKNOWN)
+      << "Production ready";
 }
 
 TEST_F(WvCdmRequestLicenseTest, QueryOemCryptoSessionId) {

libwvdrmengine/mediadrm/aidl_src/WVDrmPlugin.cpp

@@ -1152,6 +1152,8 @@ Status WVDrmPlugin::unprovisionDevice() {
     }
   } else if (name == "watermarkingSupport") {
     status = queryProperty(wvcdm::QUERY_KEY_WATERMARKING_SUPPORT, value);
+  } else if (name == "productionReady") {
+    status = queryProperty(wvcdm::QUERY_KEY_PRODUCTION_READY, value);
   } else {
     ALOGE("App requested unknown string property %s", name.c_str());
     *_aidl_return = value;

libwvdrmengine/mediadrm/src_hidl/WVDrmPlugin.cpp

@@ -1261,6 +1261,8 @@ Return<void> WVDrmPlugin::getPropertyString(const hidl_string& propertyName,
     }
   } else if (name == "watermarkingSupport") {
     status = queryProperty(wvcdm::QUERY_KEY_WATERMARKING_SUPPORT, value);
+  } else if (name == "productionReady") {
+    status = queryProperty(wvcdm::QUERY_KEY_PRODUCTION_READY, value);
   } else {
     ALOGE("App requested unknown string property %s", name.c_str());
     status = Status::ERROR_DRM_CANNOT_HANDLE;

libwvdrmengine/src_hidl/WVDrmFactory.cpp

@@ -217,6 +217,7 @@ void WVDrmFactory::printCdmProperties(FILE* out) {
       {"can disable analog output:",
        wvcdm::QUERY_KEY_CAN_DISABLE_ANALOG_OUTPUT},
       {"watermarking support:", wvcdm::QUERY_KEY_WATERMARKING_SUPPORT},
+      {"production ready:", wvcdm::QUERY_KEY_PRODUCTION_READY},
   };
 
   std::string value;