Home | History | Annotate | Download | only in drm 
      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 
     22 namespace 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  */
     31 class DrmConstraints {
     32 public:
     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 
     66 public:
     67     /**
     68      * Iterator for key
     69      */
     70     class KeyIterator {
     71         friend class DrmConstraints;
     72     private:
     73         explicit 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         explicit 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 
    113 public:
    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     }
    128 public:
    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();
    173 private:
    174     const char* getValue(const String8* key) const;
    175 private:
    176     typedef KeyedVector<String8, const char*> DrmConstraintsMap;
    177     DrmConstraintsMap mConstraintMap;
    178 };
    179 
    180 };
    181 
    182 #endif /* __DRM_CONSTRAINTS_H__ */
    183 
    184