1/*
2 * Copyright (C) 2010 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 __DRM_CONSTRAINTS_H__
18#define __DRM_CONSTRAINTS_H__
19
20#include "drm_framework_common.h"
21
22namespace android {
23
24/**
25 * This is an utility class which contains the constraints information.
26 *
27 * As a result of DrmManagerClient::getConstraints(const String8*, const int)
28 * an instance of DrmConstraints would be returned.
29 *
30 */
31class DrmConstraints {
32public:
33    /**
34     * The following variables are replica of android.drm.DrmStore.ConstraintsColumns
35     * Any changes should also be incorporated with Java Layer as well
36     */
37    /**
38     * The max repeat count
39     */
40    static const String8 MAX_REPEAT_COUNT;
41    /**
42     * The remaining repeat count
43     */
44    static const String8 REMAINING_REPEAT_COUNT;
45
46    /**
47     * The time before which the protected file can not be played/viewed
48     */
49    static const String8 LICENSE_START_TIME;
50
51    /**
52     * The time after which the protected file can not be played/viewed
53     */
54    static const String8 LICENSE_EXPIRY_TIME;
55
56    /**
57     * The available time for license
58     */
59    static const String8 LICENSE_AVAILABLE_TIME;
60
61    /**
62     * The data stream for extended metadata
63     */
64    static const String8 EXTENDED_METADATA;
65
66public:
67    /**
68     * Iterator for key
69     */
70    class KeyIterator {
71        friend class DrmConstraints;
72    private:
73        KeyIterator(DrmConstraints* drmConstraints)
74            : mDrmConstraints(drmConstraints), mIndex(0) {}
75
76    public:
77        KeyIterator(const KeyIterator& keyIterator);
78        KeyIterator& operator=(const KeyIterator& keyIterator);
79        virtual ~KeyIterator() {}
80
81    public:
82        bool hasNext();
83        const String8& next();
84
85    private:
86        DrmConstraints* mDrmConstraints;
87        unsigned int mIndex;
88    };
89
90    /**
91     * Iterator for constraints
92     */
93    class Iterator {
94        friend class DrmConstraints;
95    private:
96        Iterator(DrmConstraints* drmConstraints)
97            : mDrmConstraints(drmConstraints), mIndex(0) {}
98
99    public:
100        Iterator(const Iterator& iterator);
101        Iterator& operator=(const Iterator& iterator);
102        virtual ~Iterator() {}
103
104    public:
105        bool hasNext();
106        String8 next();
107
108    private:
109        DrmConstraints* mDrmConstraints;
110        unsigned int mIndex;
111    };
112
113public:
114    DrmConstraints() {}
115    virtual ~DrmConstraints() {
116        DrmConstraints::KeyIterator keyIt = this->keyIterator();
117
118        while (keyIt.hasNext()) {
119            String8 key = keyIt.next();
120                const char* value = this->getAsByteArray(&key);
121                if (NULL != value) {
122                    delete[] value;
123                    value = NULL;
124                }
125        }
126        mConstraintMap.clear();
127    }
128public:
129    /**
130     * Returns the number of constraints contained in this instance
131     *
132     * @return Number of constraints
133     */
134    int getCount(void) const;
135
136    /**
137     * Adds constraint information as <key, value> pair to this instance
138     *
139     * @param[in] key Key to add
140     * @param[in] value Value to add
141     * @return Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
142     */
143    status_t put(const String8* key, const char* value);
144
145    /**
146     * Retrieves the value of given key
147     *
148     * @param key Key whose value to be retrieved
149     * @return The value
150     */
151    String8 get(const String8& key) const;
152
153     /**
154     * Retrieves the value as byte array of given key
155     * @param key Key whose value to be retrieved as byte array
156     * @return The byte array value
157     */
158    const char* getAsByteArray(const String8* key) const;
159
160    /**
161     * Returns KeyIterator object to walk through the keys associated with this instance
162     *
163     * @return KeyIterator object
164     */
165    KeyIterator keyIterator();
166
167    /**
168     * Returns Iterator object to walk through the values associated with this instance
169     *
170     * @return Iterator object
171     */
172    Iterator iterator();
173private:
174    const char* getValue(const String8* key) const;
175private:
176    typedef KeyedVector<String8, const char*> DrmConstraintsMap;
177    DrmConstraintsMap mConstraintMap;
178};
179
180};
181
182#endif /* __DRM_CONSTRAINTS_H__ */
183
184