Add support for KEY_TYPE_RELEASE for clearkey plugin.

Test: android.media.cts.MediaDrmClearkeyTest#testReleaseOfflineLicense
Test: android.media.cts.MediaDrmClearkeyTest

bug: 117617857
Change-Id: I74b7db2824ca91f1301bba6404e4e900dde290d2

8 files changed, 74 insertions, 41 deletions

diff --git a/drm/mediadrm/plugins/clearkey/hidl/DeviceFiles.cpp b/drm/mediadrm/plugins/clearkey/hidl/DeviceFiles.cpp
index 8fafce21c2..e23502c224 100644
--- a/drm/mediadrm/plugins/clearkey/hidl/DeviceFiles.cpp
+++ b/drm/mediadrm/plugins/clearkey/hidl/DeviceFiles.cpp
@@ -57,6 +57,7 @@ bool DeviceFiles::StoreLicense(
             break;
         case kLicenseStateReleasing:
             license->set_state(License_LicenseState_RELEASING);
+            license->set_license(licenseResponse);
             break;
         default:
             ALOGW("StoreLicense: Unknown license state: %u", state);
@@ -106,8 +107,8 @@ bool DeviceFiles::StoreFileRaw(const std::string& fileName, const std::string& s
 
 bool DeviceFiles::RetrieveLicense(
     const std::string& keySetId, LicenseState* state, std::string* offlineLicense) {
-    OfflineFile file;
 
+    OfflineFile file;
     if (!RetrieveHashedFile(keySetId + kLicenseFileNameExt, &file)) {
         return false;
     }
@@ -128,7 +129,6 @@ bool DeviceFiles::RetrieveLicense(
     }
 
     License license = file.license();
-
     switch (license.state()) {
         case License_LicenseState_ACTIVE:
             *state = kLicenseStateActive;
@@ -142,11 +142,14 @@ bool DeviceFiles::RetrieveLicense(
             *state = kLicenseStateUnknown;
             break;
     }
-
     *offlineLicense = license.license();
     return true;
 }
 
+bool DeviceFiles::DeleteLicense(const std::string& keySetId) {
+    return mFileHandle.RemoveFile(keySetId + kLicenseFileNameExt);
+}
+
 bool DeviceFiles::DeleteAllLicenses() {
     return mFileHandle.RemoveAllFiles();
 }
diff --git a/drm/mediadrm/plugins/clearkey/hidl/DrmPlugin.cpp b/drm/mediadrm/plugins/clearkey/hidl/DrmPlugin.cpp
index 59dfb89aef..55cbcf9a35 100644
--- a/drm/mediadrm/plugins/clearkey/hidl/DrmPlugin.cpp
+++ b/drm/mediadrm/plugins/clearkey/hidl/DrmPlugin.cpp
@@ -70,6 +70,7 @@ DrmPlugin::DrmPlugin(SessionLibrary* sessionLibrary)
     mPlayPolicy.clear();
     initProperties();
     mSecureStops.clear();
+    mReleaseKeysMap.clear();
     std::srand(std::time(nullptr));
 }
 
@@ -155,7 +156,7 @@ Status DrmPlugin::getKeyRequestCommon(const hidl_vec<uint8_t>& scope,
     // GetKeyRequestOfflineKeyTypeNotSupported() in vts 1.0 and 1.1 expects
     // KeyType::OFFLINE to return ERROR_DRM_CANNOT_HANDLE in clearkey plugin.
     // Those tests pass in an empty initData, we use the empty initData to
-    // signal the specific use case.
+    // signal such specific use case.
     if (keyType == KeyType::OFFLINE && 0 == initData.size()) {
         return Status::ERROR_DRM_CANNOT_HANDLE;
     }
@@ -196,6 +197,14 @@ Status DrmPlugin::getKeyRequestCommon(const hidl_vec<uint8_t>& scope,
                 ALOGE("Problem releasing offline license");
                 return Status::ERROR_DRM_UNKNOWN;
             }
+            if (mReleaseKeysMap.find(keySetIdString) == mReleaseKeysMap.end()) {
+                sp<Session> session = mSessionLibrary->createSession();
+                mReleaseKeysMap[keySetIdString] = session->sessionId();
+            } else {
+                ALOGI("key is in use, ignore release request");
+            }
+        } else {
+            ALOGE("Offline license not found, nothing to release");
         }
         *keyRequestType = KeyRequestType::RELEASE;
     }
@@ -305,25 +314,35 @@ Return<void> DrmPlugin::provideKeyResponse(
     bool isRelease = (memcmp(scopeId.data(), kKeySetIdPrefix.data(), kKeySetIdPrefix.size()) == 0);
     if (isRelease) {
         keySetId.assign(scopeId.begin(), scopeId.end());
+
+        auto iter = mReleaseKeysMap.find(std::string(keySetId.begin(), keySetId.end()));
+        if (iter != mReleaseKeysMap.end()) {
+            sessionId.assign(iter->second.begin(), iter->second.end());
+        }
     } else {
         sessionId.assign(scopeId.begin(), scopeId.end());
-        sp<Session> session = mSessionLibrary->findSession(sessionId);
-        if (!session.get()) {
-            _hidl_cb(Status::ERROR_DRM_SESSION_NOT_OPENED, hidl_vec<uint8_t>());
-            return Void();
-        }
-
-        setPlayPolicy();
         // non offline license returns empty keySetId
         keySetId.clear();
+    }
 
-        status = session->provideKeyResponse(response);
-        if (status == Status::OK) {
-            if (isOfflineLicense) {
+    sp<Session> session = mSessionLibrary->findSession(sessionId);
+    if (!session.get()) {
+        _hidl_cb(Status::ERROR_DRM_SESSION_NOT_OPENED, hidl_vec<uint8_t>());
+        return Void();
+    }
+    setPlayPolicy();
+
+    status = session->provideKeyResponse(response);
+    if (status == Status::OK) {
+        if (isOfflineLicense) {
+            if (isRelease) {
+                mFileHandle.DeleteLicense(keySetId);
+            } else {
                 if (!makeKeySetId(&keySetId)) {
                     _hidl_cb(Status::ERROR_DRM_UNKNOWN, hidl_vec<uint8_t>());
                     return Void();
                 }
+
                 bool ok = mFileHandle.StoreLicense(
                         keySetId,
                         DeviceFiles::kLicenseStateActive,
@@ -332,32 +351,32 @@ Return<void> DrmPlugin::provideKeyResponse(
                     ALOGE("Failed to store offline license");
                 }
             }
+        }
 
-            // Test calling AMediaDrm listeners.
-            sendEvent(EventType::VENDOR_DEFINED, sessionId, sessionId);
+        // Test calling AMediaDrm listeners.
+        sendEvent(EventType::VENDOR_DEFINED, sessionId, sessionId);
 
-            sendExpirationUpdate(sessionId, 100);
+        sendExpirationUpdate(sessionId, 100);
 
-            std::vector<KeyStatus> keysStatus;
-            KeyStatus keyStatus;
+        std::vector<KeyStatus> keysStatus;
+        KeyStatus keyStatus;
 
-            std::vector<uint8_t> keyId1 = { 0xA, 0xB, 0xC };
-            keyStatus.keyId = keyId1;
-            keyStatus.type = V1_0::KeyStatusType::USABLE;
-            keysStatus.push_back(keyStatus);
+        std::vector<uint8_t> keyId1 = { 0xA, 0xB, 0xC };
+        keyStatus.keyId = keyId1;
+        keyStatus.type = V1_0::KeyStatusType::USABLE;
+        keysStatus.push_back(keyStatus);
 
-            std::vector<uint8_t> keyId2 = { 0xD, 0xE, 0xF };
-            keyStatus.keyId = keyId2;
-            keyStatus.type = V1_0::KeyStatusType::EXPIRED;
-            keysStatus.push_back(keyStatus);
+        std::vector<uint8_t> keyId2 = { 0xD, 0xE, 0xF };
+        keyStatus.keyId = keyId2;
+        keyStatus.type = V1_0::KeyStatusType::EXPIRED;
+        keysStatus.push_back(keyStatus);
 
-            sendKeysChange(sessionId, keysStatus, true);
+        sendKeysChange(sessionId, keysStatus, true);
 
-            installSecureStop(sessionId);
-        } else {
-            ALOGE("Failed to add key, error=%d", status);
-        }
-    } // keyType::STREAMING || keyType::OFFLINE
+        installSecureStop(sessionId);
+    } else {
+        ALOGE("provideKeyResponse returns error=%d", status);
+    }
 
     std::vector<uint8_t> keySetIdVec(keySetId.begin(), keySetId.end());
     _hidl_cb(status, toHidlVec(keySetIdVec));
@@ -371,10 +390,10 @@ Return<Status> DrmPlugin::restoreKeys(
         }
 
         DeviceFiles::LicenseState licenseState;
-        std::string keySetIdString(keySetId.begin(), keySetId.end());
         std::string offlineLicense;
         Status status = Status::OK;
-        if (!mFileHandle.RetrieveLicense(keySetIdString, &licenseState, &offlineLicense)) {
+        if (!mFileHandle.RetrieveLicense(std::string(keySetId.begin(), keySetId.end()),
+                &licenseState, &offlineLicense)) {
             ALOGE("Failed to restore offline license");
             return Status::ERROR_DRM_NO_LICENSE;
         }
diff --git a/drm/mediadrm/plugins/clearkey/hidl/InitDataParser.cpp b/drm/mediadrm/plugins/clearkey/hidl/InitDataParser.cpp
index dd1689fb1a..deb5d97e08 100644
--- a/drm/mediadrm/plugins/clearkey/hidl/InitDataParser.cpp
+++ b/drm/mediadrm/plugins/clearkey/hidl/InitDataParser.cpp
@@ -156,7 +156,8 @@ std::string InitDataParser::generateRequest(V1_0::KeyType keyType,
     }
     if (keyType == V1_0::KeyType::STREAMING) {
         request.append(kTemporarySession);
-    } else if (keyType == V1_0::KeyType::OFFLINE) {
+    } else if (keyType == V1_0::KeyType::OFFLINE ||
+                   keyType == V1_0::KeyType::RELEASE) {
             request.append(kPersistentSession);
     }
 
diff --git a/drm/mediadrm/plugins/clearkey/hidl/MemoryFileSystem.cpp b/drm/mediadrm/plugins/clearkey/hidl/MemoryFileSystem.cpp
index 47f188da18..43fecbbfc1 100644
--- a/drm/mediadrm/plugins/clearkey/hidl/MemoryFileSystem.cpp
+++ b/drm/mediadrm/plugins/clearkey/hidl/MemoryFileSystem.cpp
@@ -3,7 +3,6 @@
 // License Agreement.
 
 #include <utils/Log.h>
-
 #include <string>
 
 #include "MemoryFileSystem.h"
@@ -54,6 +53,10 @@ size_t MemoryFileSystem::Read(const std::string& path, std::string* buffer) {
 
 size_t MemoryFileSystem::Write(const std::string& path, const MemoryFile& memoryFile) {
     std::string key = GetFileName(path);
+    auto result = mMemoryFileSystem.find(key);
+    if (result != mMemoryFileSystem.end()) {
+        mMemoryFileSystem.erase(key);
+    }
     mMemoryFileSystem.insert(std::pair<std::string, MemoryFile>(key, memoryFile));
     return memoryFile.getFileSize();
 }
diff --git a/drm/mediadrm/plugins/clearkey/hidl/SessionLibrary.cpp b/drm/mediadrm/plugins/clearkey/hidl/SessionLibrary.cpp
index b4319e6a45..d26276371e 100644
--- a/drm/mediadrm/plugins/clearkey/hidl/SessionLibrary.cpp
+++ b/drm/mediadrm/plugins/clearkey/hidl/SessionLibrary.cpp
@@ -59,7 +59,8 @@ sp<Session> SessionLibrary::createSession() {
 
     mSessions.insert(std::pair<std::vector<uint8_t>,
             sp<Session> >(sessionId, new Session(sessionId)));
-    std::map<std::vector<uint8_t>, sp<Session> >::iterator itr = mSessions.find(sessionId);
+    std::map<std::vector<uint8_t>, sp<Session> >::iterator itr =
+            mSessions.find(sessionId);
     if (itr != mSessions.end()) {
         return itr->second;
     } else {
@@ -70,7 +71,8 @@ sp<Session> SessionLibrary::createSession() {
 sp<Session> SessionLibrary::findSession(
         const std::vector<uint8_t>& sessionId) {
     Mutex::Autolock lock(mSessionsLock);
-    std::map<std::vector<uint8_t>, sp<Session> >::iterator itr = mSessions.find(sessionId);
+    std::map<std::vector<uint8_t>, sp<Session> >::iterator itr =
+            mSessions.find(sessionId);
     if (itr != mSessions.end()) {
         return itr->second;
     } else {
diff --git a/drm/mediadrm/plugins/clearkey/hidl/include/DeviceFiles.h b/drm/mediadrm/plugins/clearkey/hidl/include/DeviceFiles.h
index a201e884ac..ac13d23295 100644
--- a/drm/mediadrm/plugins/clearkey/hidl/include/DeviceFiles.h
+++ b/drm/mediadrm/plugins/clearkey/hidl/include/DeviceFiles.h
@@ -26,9 +26,9 @@ namespace clearkey {
 class DeviceFiles {
  public:
     typedef enum {
+        kLicenseStateUnknown,
         kLicenseStateActive,
         kLicenseStateReleasing,
-        kLicenseStateUnknown,
     } LicenseState;
 
     DeviceFiles() {};
@@ -42,6 +42,8 @@ class DeviceFiles {
 
     virtual bool LicenseExists(const std::string& keySetId);
 
+    virtual bool DeleteLicense(const std::string& keySetId);
+
     virtual bool DeleteAllLicenses();
 
  private:
diff --git a/drm/mediadrm/plugins/clearkey/hidl/include/DrmPlugin.h b/drm/mediadrm/plugins/clearkey/hidl/include/DrmPlugin.h
index 12d8608a7f..8e6092f396 100644
--- a/drm/mediadrm/plugins/clearkey/hidl/include/DrmPlugin.h
+++ b/drm/mediadrm/plugins/clearkey/hidl/include/DrmPlugin.h
@@ -319,6 +319,7 @@ private:
     std::vector<KeyValue> mPlayPolicy;
     std::map<std::string, std::string> mStringProperties;
     std::map<std::string, std::vector<uint8_t> > mByteArrayProperties;
+    std::map<std::string, std::vector<uint8_t> > mReleaseKeysMap;
     std::map<std::vector<uint8_t>, SecurityLevel> mSecurityLevel;
     sp<IDrmPluginListener> mListener;
     SessionLibrary *mSessionLibrary;
diff --git a/drm/mediadrm/plugins/clearkey/hidl/include/MemoryFileSystem.h b/drm/mediadrm/plugins/clearkey/hidl/include/MemoryFileSystem.h
index db368d732e..22f8779315 100644
--- a/drm/mediadrm/plugins/clearkey/hidl/include/MemoryFileSystem.h
+++ b/drm/mediadrm/plugins/clearkey/hidl/include/MemoryFileSystem.h
@@ -32,7 +32,9 @@ class MemoryFileSystem {
         size_t getFileSize() const { return fileSize; }
         void setContent(const std::string& file) { content = file; }
         void setFileName(const std::string& name) { fileName = name; }
-        void setFileSize(size_t size) { fileSize = size; }
+        void setFileSize(size_t size) {
+            content.resize(size); fileSize = size;
+        }
     };
 
     MemoryFileSystem() {};