The Tor Browser / file comparison

comparison: dom/camera/GonkCameraParameters.h

dom/camera/GonkCameraParameters.h

branch
TOR_BUG_9701
changeset 8
97036ab72558
equal deleted inserted replaced
-1:000000000000 0:1184ea121209
1 /*
2 * Copyright (C) 2013-2014 Mozilla Foundation
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 DOM_CAMERA_GONKCAMERAPARAMETERS_H
18 #define DOM_CAMERA_GONKCAMERAPARAMETERS_H
19
20 #include <math.h>
21 #include "camera/CameraParameters.h"
22 #include "nsTArray.h"
23 #include "nsString.h"
24 #include "AutoRwLock.h"
25 #include "nsPrintfCString.h"
26 #include "ICameraControl.h"
27
28 namespace mozilla {
29
30 class GonkCameraParameters
31 {
32 public:
33 GonkCameraParameters();
34 virtual ~GonkCameraParameters();
35
36 // IMPORTANT: This class is read and written by multiple threads --
37 // ALL public methods must hold mLock, for either reading or writing,
38 // for the life of their operation. Not doing so was the cause of
39 // bug 928856, which was -painful- to track down.
40 template<class T> nsresult
41 Set(uint32_t aKey, const T& aValue)
42 {
43 RwLockAutoEnterWrite lock(mLock);
44 nsresult rv = SetTranslated(aKey, aValue);
45 mDirty = mDirty || NS_SUCCEEDED(rv);
46 return rv;
47 }
48
49 template<class T> nsresult
50 Get(uint32_t aKey, T& aValue)
51 {
52 RwLockAutoEnterRead lock(mLock);
53 return GetTranslated(aKey, aValue);
54 }
55
56 bool
57 TestAndClearDirtyFlag()
58 {
59 bool dirty;
60
61 RwLockAutoEnterWrite lock(mLock);
62 dirty = mDirty;
63 mDirty = false;
64 return dirty;
65 }
66
67 android::String8
68 Flatten() const
69 {
70 RwLockAutoEnterRead lock(mLock);
71 return mParams.flatten();
72 }
73
74 nsresult
75 Unflatten(const android::String8& aFlatParameters)
76 {
77 RwLockAutoEnterWrite lock(mLock);
78 mParams.unflatten(aFlatParameters);
79 if (mInitialized) {
80 return NS_OK;
81 }
82
83 // We call Initialize() once when the parameter set is first loaded,
84 // to set up any constant values this class requires internally,
85 // e.g. the exposure compensation step and limits.
86 return Initialize();
87 }
88
89 protected:
90 PRRWLock* mLock;
91 bool mDirty;
92 bool mInitialized;
93
94 // Required internal properties
95 double mExposureCompensationMin;
96 double mExposureCompensationStep;
97 nsTArray<int> mZoomRatios;
98 nsTArray<nsString> mIsoModes;
99
100 // This subclass of android::CameraParameters just gives
101 // all of the AOSP getters and setters the same signature.
102 class Parameters : public android::CameraParameters
103 {
104 public:
105 using android::CameraParameters::set;
106 using android::CameraParameters::get;
107 using android::CameraParameters::TRUE;
108 using android::CameraParameters::FALSE;
109
110 void set(const char* aKey, float aValue) { setFloat(aKey, aValue); }
111 void set(const char* aKey, double aValue) { setFloat(aKey, aValue); }
112 void set(const char* aKey, bool aValue) { set(aKey, aValue ? TRUE : FALSE); }
113 void get(const char* aKey, float& aRet) { aRet = getFloat(aKey); }
114 void get(const char* aKey, double& aRet) { aRet = getFloat(aKey); }
115 void get(const char* aKey, const char*& aRet) { aRet = get(aKey); }
116 void get(const char* aKey, int& aRet) { aRet = getInt(aKey); }
117 void get(const char* aKey, bool& aRet) { aRet = strcmp(get(aKey), FALSE); }
118
119 static const char* GetTextKey(uint32_t aKey);
120 };
121
122 Parameters mParams;
123
124 // The *Impl() templates handle converting the parameter keys from
125 // their enum values to string types, if necessary. These are the
126 // bottom layer accessors to mParams.
127 template<typename T> nsresult
128 SetImpl(uint32_t aKey, const T& aValue)
129 {
130 const char* key = Parameters::GetTextKey(aKey);
131 NS_ENSURE_TRUE(key, NS_ERROR_NOT_AVAILABLE);
132
133 mParams.set(key, aValue);
134 return NS_OK;
135 }
136
137 template<typename T> nsresult
138 GetImpl(uint32_t aKey, T& aValue)
139 {
140 const char* key = Parameters::GetTextKey(aKey);
141 NS_ENSURE_TRUE(key, NS_ERROR_NOT_AVAILABLE);
142
143 mParams.get(key, aValue);
144 return NS_OK;
145 }
146
147 template<class T> nsresult
148 SetImpl(const char* aKey, const T& aValue)
149 {
150 mParams.set(aKey, aValue);
151 return NS_OK;
152 }
153
154 template<class T> nsresult
155 GetImpl(const char* aKey, T& aValue)
156 {
157 mParams.get(aKey, aValue);
158 return NS_OK;
159 }
160
161 // The *Translated() functions allow us to handle special cases;
162 // for example, where the thumbnail size setting is exposed as an
163 // ICameraControl::Size object, but is handled by the AOSP layer
164 // as two separate parameters.
165 nsresult SetTranslated(uint32_t aKey, const nsAString& aValue);
166 nsresult GetTranslated(uint32_t aKey, nsAString& aValue);
167 nsresult SetTranslated(uint32_t aKey, const ICameraControl::Size& aSize);
168 nsresult GetTranslated(uint32_t aKey, ICameraControl::Size& aSize);
169 nsresult GetTranslated(uint32_t aKey, nsTArray<ICameraControl::Size>& aSizes);
170 nsresult SetTranslated(uint32_t aKey, const nsTArray<ICameraControl::Region>& aRegions);
171 nsresult GetTranslated(uint32_t aKey, nsTArray<ICameraControl::Region>& aRegions);
172 nsresult SetTranslated(uint32_t aKey, const ICameraControl::Position& aPosition);
173 nsresult SetTranslated(uint32_t aKey, const int64_t& aValue);
174 nsresult GetTranslated(uint32_t aKey, int64_t& aValue);
175 nsresult SetTranslated(uint32_t aKey, const double& aValue);
176 nsresult GetTranslated(uint32_t aKey, double& aValue);
177 nsresult SetTranslated(uint32_t aKey, const int& aValue);
178 nsresult GetTranslated(uint32_t aKey, int& aValue);
179 nsresult SetTranslated(uint32_t aKey, const uint32_t& aValue);
180 nsresult GetTranslated(uint32_t aKey, uint32_t& aValue);
181 nsresult SetTranslated(uint32_t aKey, const bool& aValue);
182 nsresult GetTranslated(uint32_t aKey, bool& aValue);
183 nsresult GetTranslated(uint32_t aKey, nsTArray<nsString>& aValues);
184 nsresult GetTranslated(uint32_t aKey, nsTArray<double>& aValues);
185
186 template<class T> nsresult GetListAsArray(uint32_t aKey, nsTArray<T>& aArray);
187 nsresult MapIsoToGonk(const nsAString& aIso, nsACString& aIsoOut);
188 nsresult MapIsoFromGonk(const char* aIso, nsAString& aIsoOut);
189
190 nsresult Initialize();
191 };
192
193 } // namespace mozilla
194
195 #endif // DOM_CAMERA_GONKCAMERAPARAMETERS_H

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial