1/*
2 * Copyright (C) 2014 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#ifndef CLEARKEY_DRM_PLUGIN_H_
18#define CLEARKEY_DRM_PLUGIN_H_
19
20#include <media/drm/DrmAPI.h>
21#include <media/stagefright/foundation/ABase.h>
22#include <media/stagefright/MediaErrors.h>
23#include <utils/Errors.h>
24#include <utils/KeyedVector.h>
25#include <utils/List.h>
26#include <utils/String8.h>
27#include <utils/Vector.h>
28
29#include "SessionLibrary.h"
30#include "Utils.h"
31
32namespace clearkeydrm {
33
34using android::KeyedVector;
35using android::List;
36using android::status_t;
37using android::String8;
38using android::Vector;
39
40class DrmPlugin : public android::DrmPlugin {
41public:
42    DrmPlugin(SessionLibrary* sessionLibrary)
43            : mSessionLibrary(sessionLibrary) {}
44    virtual ~DrmPlugin() {}
45
46    virtual status_t openSession(Vector<uint8_t>& sessionId);
47
48    virtual status_t closeSession(const Vector<uint8_t>& sessionId);
49
50    virtual status_t getKeyRequest(
51            const Vector<uint8_t>& scope,
52            const Vector<uint8_t>& mimeType,
53            const String8& initDataType,
54            KeyType keyType,
55            const KeyedVector<String8, String8>& optionalParameters,
56            Vector<uint8_t>& request,
57            String8& defaultUrl,
58            DrmPlugin::KeyRequestType *keyRequestType);
59
60    virtual status_t provideKeyResponse(
61            const Vector<uint8_t>& scope,
62            const Vector<uint8_t>& response,
63            Vector<uint8_t>& keySetId);
64
65    virtual status_t removeKeys(const Vector<uint8_t>& sessionId) {
66        UNUSED(sessionId);
67        return android::ERROR_DRM_CANNOT_HANDLE;
68    }
69
70    virtual status_t restoreKeys(
71            const Vector<uint8_t>& sessionId,
72            const Vector<uint8_t>& keySetId) {
73        UNUSED(sessionId);
74        UNUSED(keySetId);
75        return android::ERROR_DRM_CANNOT_HANDLE;
76    }
77
78    virtual status_t queryKeyStatus(
79            const Vector<uint8_t>& sessionId,
80            KeyedVector<String8, String8>& infoMap) const {
81        UNUSED(sessionId);
82        UNUSED(infoMap);
83        return android::ERROR_DRM_CANNOT_HANDLE;
84    }
85
86    virtual status_t getProvisionRequest(
87            const String8& cert_type,
88            const String8& cert_authority,
89            Vector<uint8_t>& request,
90            String8& defaultUrl) {
91        UNUSED(cert_type);
92        UNUSED(cert_authority);
93        UNUSED(request);
94        UNUSED(defaultUrl);
95        return android::ERROR_DRM_CANNOT_HANDLE;
96    }
97
98    virtual status_t provideProvisionResponse(
99            const Vector<uint8_t>& response,
100            Vector<uint8_t>& certificate,
101            Vector<uint8_t>& wrappedKey) {
102        UNUSED(response);
103        UNUSED(certificate);
104        UNUSED(wrappedKey);
105        return android::ERROR_DRM_CANNOT_HANDLE;
106    }
107
108    virtual status_t getSecureStops(List<Vector<uint8_t> >& secureStops) {
109        UNUSED(secureStops);
110        return android::ERROR_DRM_CANNOT_HANDLE;
111    }
112
113    virtual status_t getSecureStop(Vector<uint8_t> const &ssid, Vector<uint8_t> &secureStop) {
114        UNUSED(ssid);
115        UNUSED(secureStop);
116        return android::ERROR_DRM_CANNOT_HANDLE;
117    }
118
119    virtual status_t releaseSecureStops(const Vector<uint8_t>& ssRelease) {
120        UNUSED(ssRelease);
121        return android::ERROR_DRM_CANNOT_HANDLE;
122    }
123
124    virtual status_t releaseAllSecureStops() {
125        return android::ERROR_DRM_CANNOT_HANDLE;
126    }
127
128    virtual status_t getPropertyString(
129            const String8& name, String8& value) const;
130
131    virtual status_t getPropertyByteArray(
132            const String8& name, Vector<uint8_t>& value) const {
133        UNUSED(name);
134        UNUSED(value);
135        return android::ERROR_DRM_CANNOT_HANDLE;
136    }
137
138    virtual status_t setPropertyString(
139            const String8& name, const String8& value) {
140        UNUSED(name);
141        UNUSED(value);
142        return android::ERROR_DRM_CANNOT_HANDLE;
143    }
144
145    virtual status_t setPropertyByteArray(
146            const String8& name, const Vector<uint8_t>& value) {
147        UNUSED(name);
148        UNUSED(value);
149        return android::ERROR_DRM_CANNOT_HANDLE;
150    }
151
152    virtual status_t setCipherAlgorithm(
153            const Vector<uint8_t>& sessionId, const String8& algorithm) {
154        UNUSED(sessionId);
155        UNUSED(algorithm);
156        return android::ERROR_DRM_CANNOT_HANDLE;
157    }
158
159    virtual status_t setMacAlgorithm(
160            const Vector<uint8_t>& sessionId, const String8& algorithm) {
161        UNUSED(sessionId);
162        UNUSED(algorithm);
163        return android::ERROR_DRM_CANNOT_HANDLE;
164    }
165
166    virtual status_t encrypt(
167            const Vector<uint8_t>& sessionId,
168            const Vector<uint8_t>& keyId,
169            const Vector<uint8_t>& input,
170            const Vector<uint8_t>& iv,
171            Vector<uint8_t>& output) {
172        UNUSED(sessionId);
173        UNUSED(keyId);
174        UNUSED(input);
175        UNUSED(iv);
176        UNUSED(output);
177        return android::ERROR_DRM_CANNOT_HANDLE;
178    }
179
180    virtual status_t decrypt(
181            const Vector<uint8_t>& sessionId,
182            const Vector<uint8_t>& keyId,
183            const Vector<uint8_t>& input,
184            const Vector<uint8_t>& iv,
185            Vector<uint8_t>& output) {
186        UNUSED(sessionId);
187        UNUSED(keyId);
188        UNUSED(input);
189        UNUSED(iv);
190        UNUSED(output);
191        return android::ERROR_DRM_CANNOT_HANDLE;
192    }
193
194    virtual status_t sign(
195            const Vector<uint8_t>& sessionId,
196            const Vector<uint8_t>& keyId,
197            const Vector<uint8_t>& message,
198            Vector<uint8_t>& signature) {
199        UNUSED(sessionId);
200        UNUSED(keyId);
201        UNUSED(message);
202        UNUSED(signature);
203        return android::ERROR_DRM_CANNOT_HANDLE;
204    }
205
206    virtual status_t verify(
207            const Vector<uint8_t>& sessionId,
208            const Vector<uint8_t>& keyId,
209            const Vector<uint8_t>& message,
210            const Vector<uint8_t>& signature, bool& match) {
211        UNUSED(sessionId);
212        UNUSED(keyId);
213        UNUSED(message);
214        UNUSED(signature);
215        UNUSED(match);
216        return android::ERROR_DRM_CANNOT_HANDLE;
217    }
218
219    virtual status_t signRSA(
220            const Vector<uint8_t>& sessionId,
221            const String8& algorithm,
222            const Vector<uint8_t>& message,
223            const Vector<uint8_t>& wrappedKey,
224            Vector<uint8_t>& signature) {
225        UNUSED(sessionId);
226        UNUSED(algorithm);
227        UNUSED(message);
228        UNUSED(wrappedKey);
229        UNUSED(signature);
230        return android::ERROR_DRM_CANNOT_HANDLE;
231    }
232
233private:
234    DISALLOW_EVIL_CONSTRUCTORS(DrmPlugin);
235
236    SessionLibrary* mSessionLibrary;
237};
238
239} // namespace clearkeydrm
240
241#endif // CLEARKEY_DRM_PLUGIN_H_
242