dom/camera/CameraPreferences.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "CameraPreferences.h"
   7 #include "CameraCommon.h"
   8 #include "mozilla/ArrayUtils.h"
   9 #include "mozilla/Monitor.h"
  10 #include "mozilla/StaticPtr.h"
  11 #include "mozilla/Preferences.h"
  12
  13 using namespace mozilla;
  14
  15 /* statics */
  16 static StaticAutoPtr<Monitor> sPrefMonitor;
  17
  18 StaticAutoPtr<nsCString> CameraPreferences::sPrefTestEnabled;
  19 StaticAutoPtr<nsCString> CameraPreferences::sPrefHardwareTest;
  20 StaticAutoPtr<nsCString> CameraPreferences::sPrefGonkParameters;
  21
  22 nsresult CameraPreferences::sPrefCameraControlMethodErrorOverride = NS_OK;
  23 nsresult CameraPreferences::sPrefCameraControlAsyncErrorOverride = NS_OK;
  24
  25 uint32_t CameraPreferences::sPrefCameraControlLowMemoryThresholdMB = 0;
  26
  27 bool CameraPreferences::sPrefCameraParametersIsLowMemory = false;
  28
  29 #ifdef CAMERAPREFERENCES_HAVE_SEPARATE_UINT32_AND_NSRESULT
  30 /* static */
  31 nsresult
  32 CameraPreferences::UpdatePref(const char* aPref, nsresult& aVal)
  33 {
  34   uint32_t val;
  35   nsresult rv = Preferences::GetUint(aPref, &val);
  36   if (NS_SUCCEEDED(rv)) {
  37     aVal = static_cast<nsresult>(val);
  38   }
  39   return rv;
  40 }
  41 #endif
  42
  43 /* static */
  44 nsresult
  45 CameraPreferences::UpdatePref(const char* aPref, uint32_t& aVal)
  46 {
  47   uint32_t val;
  48   nsresult rv = Preferences::GetUint(aPref, &val);
  49   if (NS_SUCCEEDED(rv)) {
  50     aVal = val;
  51   }
  52   return rv;
  53 }
  54
  55 /* static */
  56 nsresult
  57 CameraPreferences::UpdatePref(const char* aPref, nsACString& aVal)
  58 {
  59   nsCString val;
  60   nsresult rv = Preferences::GetCString(aPref, &val);
  61   if (NS_SUCCEEDED(rv)) {
  62     aVal = val;
  63   }
  64   return rv;
  65 }
  66
  67 /* static */
  68 nsresult
  69 CameraPreferences::UpdatePref(const char* aPref, bool& aVal)
  70 {
  71   bool val;
  72   nsresult rv = Preferences::GetBool(aPref, &val);
  73   if (NS_SUCCEEDED(rv)) {
  74     aVal = val;
  75   }
  76   return rv;
  77 }
  78
  79 /* static */
  80 CameraPreferences::Pref CameraPreferences::sPrefs[] = {
  81   {
  82     "camera.control.test.enabled",
  83     kPrefValueIsCString,
  84     { &sPrefTestEnabled }
  85   },
  86   {
  87     "camera.control.test.hardware",
  88     kPrefValueIsCString,
  89     { &sPrefHardwareTest }
  90   },
  91 #ifdef MOZ_B2G
  92   {
  93     "camera.control.test.hardware.gonk.parameters",
  94     kPrefValueIsCString,
  95     { &sPrefGonkParameters }
  96   },
  97 #endif
  98   {
  99     "camera.control.test.method.error",
 100     kPrefValueIsNsResult,
 101     { &sPrefCameraControlMethodErrorOverride }
 102   },
 103   {
 104     "camera.control.test.async.error",
 105     kPrefValueIsNsResult,
 106     { &sPrefCameraControlAsyncErrorOverride }
 107   },
 108   {
 109     "camera.control.test.is_low_memory",
 110     kPrefValueIsBoolean,
 111     { &sPrefCameraParametersIsLowMemory }
 112   },
 113   {
 114     "camera.control.low_memory_thresholdMB",
 115     kPrefValueIsUint32,
 116     { &sPrefCameraControlLowMemoryThresholdMB }
 117   },
 118 };
 119
 120 /* static */
 121 uint32_t
 122 CameraPreferences::PrefToIndex(const char* aPref)
 123 {
 124   for (uint32_t i = 0; i < ArrayLength(sPrefs); ++i) {
 125     if (strcmp(aPref, sPrefs[i].mPref) == 0) {
 126       return i;
 127     }
 128   }
 129   return kPrefNotFound;
 130 }
 131
 132 /* static */
 133 void
 134 CameraPreferences::PreferenceChanged(const char* aPref, void* aClosure)
 135 {
 136   MonitorAutoLock mon(*sPrefMonitor);
 137
 138   uint32_t i = PrefToIndex(aPref);
 139   if (i == kPrefNotFound) {
 140     DOM_CAMERA_LOGE("Preference '%s' is not tracked by CameraPreferences\n", aPref);
 141     return;
 142   }
 143
 144   Pref& p = sPrefs[i];
 145   nsresult rv;
 146   switch (p.mValueType) {
 147     case kPrefValueIsNsResult:
 148     #ifdef CAMERAPREFERENCES_HAVE_SEPARATE_UINT32_AND_NSRESULT
 149       {
 150         nsresult& v = *p.mValue.mAsNsResult;
 151         rv = UpdatePref(aPref, v);
 152         if (NS_SUCCEEDED(rv)) {
 153           DOM_CAMERA_LOGI("Preference '%s' has changed, 0x%x\n", aPref, v);
 154         }
 155       }
 156       break;
 157     #endif
 158
 159     case kPrefValueIsUint32:
 160       {
 161         uint32_t& v = *p.mValue.mAsUint32;
 162         rv = UpdatePref(aPref, v);
 163         if (NS_SUCCEEDED(rv)) {
 164           DOM_CAMERA_LOGI("Preference '%s' has changed, %u\n", aPref, v);
 165         }
 166       }
 167       break;
 168
 169     case kPrefValueIsCString:
 170       {
 171         nsCString& v = **p.mValue.mAsCString;
 172         rv = UpdatePref(aPref, v);
 173         if (NS_SUCCEEDED(rv)) {
 174           DOM_CAMERA_LOGI("Preference '%s' has changed, '%s'\n", aPref, v.get());
 175         }
 176       }
 177       break;
 178
 179     case kPrefValueIsBoolean:
 180       {
 181         bool& v = *p.mValue.mAsBoolean;
 182         rv = UpdatePref(aPref, v);
 183         if (NS_SUCCEEDED(rv)) {
 184           DOM_CAMERA_LOGI("Preference '%s' has changed, %s\n",
 185             aPref, v ? "true" : "false");
 186         }
 187       }
 188       break;
 189
 190     default:
 191       MOZ_ASSERT_UNREACHABLE("Unhandled preference value type!");
 192       return;
 193   }
 194
 195   if (NS_FAILED(rv)) {
 196     DOM_CAMERA_LOGE("Failed to get pref '%s' (0x%x)\n", aPref, rv);
 197   }
 198 }
 199
 200 /* static */
 201 bool
 202 CameraPreferences::Initialize()
 203 {
 204   DOM_CAMERA_LOGI("Initializing camera preference callbacks\n");
 205
 206   nsresult rv;
 207
 208   sPrefMonitor = new Monitor("CameraPreferences.sPrefMonitor");
 209
 210   sPrefTestEnabled = new nsCString();
 211   sPrefHardwareTest = new nsCString();
 212   sPrefGonkParameters = new nsCString();
 213
 214   for (uint32_t i = 0; i < ArrayLength(sPrefs); ++i) {
 215     rv = Preferences::RegisterCallbackAndCall(CameraPreferences::PreferenceChanged,
 216                                               sPrefs[i].mPref);
 217     if (NS_WARN_IF(NS_FAILED(rv))) {
 218       return false;
 219     }
 220   }
 221
 222   DOM_CAMERA_LOGI("Camera preferences initialized\n");
 223   return true;
 224 }
 225
 226 /* static */
 227 void
 228 CameraPreferences::Shutdown()
 229 {
 230   DOM_CAMERA_LOGI("Shutting down camera preference callbacks\n");
 231
 232   for (uint32_t i = 0; i < ArrayLength(sPrefs); ++i) {
 233     Preferences::UnregisterCallback(CameraPreferences::PreferenceChanged,
 234                                     sPrefs[i].mPref);
 235   }
 236
 237   sPrefTestEnabled = nullptr;
 238   sPrefHardwareTest = nullptr;
 239   sPrefGonkParameters = nullptr;
 240   sPrefMonitor = nullptr;
 241
 242   DOM_CAMERA_LOGI("Camera preferences shut down\n");
 243 }
 244
 245 /* static */
 246 bool
 247 CameraPreferences::GetPref(const char* aPref, nsACString& aVal)
 248 {
 249   MOZ_ASSERT(sPrefMonitor, "sPrefMonitor missing in CameraPreferences::GetPref()");
 250   MonitorAutoLock mon(*sPrefMonitor);
 251
 252   uint32_t i = PrefToIndex(aPref);
 253   if (i == kPrefNotFound || i >= ArrayLength(sPrefs)) {
 254     DOM_CAMERA_LOGW("Preference '%s' is not tracked by CameraPreferences\n", aPref);
 255     return false;
 256   }
 257   if (sPrefs[i].mValueType != kPrefValueIsCString) {
 258     DOM_CAMERA_LOGW("Preference '%s' is not a string type\n", aPref);
 259     return false;
 260   }
 261
 262   StaticAutoPtr<nsCString>* s = sPrefs[i].mValue.mAsCString;
 263   if (!*s) {
 264     DOM_CAMERA_LOGE("Preference '%s' cache is not initialized\n", aPref);
 265     return false;
 266   }
 267   if ((*s)->IsEmpty()) {
 268     DOM_CAMERA_LOGI("Preference '%s' is not set\n", aPref);
 269     return false;
 270   }
 271
 272   DOM_CAMERA_LOGI("Preference '%s', got '%s'\n", aPref, (*s)->get());
 273   aVal = **s;
 274   return true;
 275 }
 276
 277 #ifdef CAMERAPREFERENCES_HAVE_SEPARATE_UINT32_AND_NSRESULT
 278 /* static */
 279 bool
 280 CameraPreferences::GetPref(const char* aPref, nsresult& aVal)
 281 {
 282   MOZ_ASSERT(sPrefMonitor, "sPrefMonitor missing in CameraPreferences::GetPref()");
 283   MonitorAutoLock mon(*sPrefMonitor);
 284
 285   uint32_t i = PrefToIndex(aPref);
 286   if (i == kPrefNotFound || i >= ArrayLength(sPrefs)) {
 287     DOM_CAMERA_LOGW("Preference '%s' is not tracked by CameraPreferences\n", aPref);
 288     return false;
 289   }
 290   if (sPrefs[i].mValueType != kPrefValueIsNsResult) {
 291     DOM_CAMERA_LOGW("Preference '%s' is not an nsresult type\n", aPref);
 292     return false;
 293   }
 294
 295   nsresult v = *sPrefs[i].mValue.mAsNsResult;
 296   if (v == NS_OK) {
 297     DOM_CAMERA_LOGW("Preference '%s' is not set\n", aPref);
 298     return false;
 299   }
 300
 301   DOM_CAMERA_LOGI("Preference '%s', got 0x%x\n", aPref, v);
 302   aVal = v;
 303   return true;
 304 }
 305 #endif
 306
 307 /* static */
 308 bool
 309 CameraPreferences::GetPref(const char* aPref, uint32_t& aVal)
 310 {
 311   MOZ_ASSERT(sPrefMonitor, "sPrefMonitor missing in CameraPreferences::GetPref()");
 312   MonitorAutoLock mon(*sPrefMonitor);
 313
 314   uint32_t i = PrefToIndex(aPref);
 315   if (i == kPrefNotFound || i >= ArrayLength(sPrefs)) {
 316     DOM_CAMERA_LOGW("Preference '%s' is not tracked by CameraPreferences\n", aPref);
 317     return false;
 318   }
 319   if (sPrefs[i].mValueType != kPrefValueIsUint32) {
 320     DOM_CAMERA_LOGW("Preference '%s' is not a uint32_t type\n", aPref);
 321     return false;
 322   }
 323
 324   uint32_t v = *sPrefs[i].mValue.mAsUint32;
 325   DOM_CAMERA_LOGI("Preference '%s', got %u\n", aPref, v);
 326   aVal = v;
 327   return true;
 328 }
 329
 330 /* static */
 331 bool
 332 CameraPreferences::GetPref(const char* aPref, bool& aVal)
 333 {
 334   MOZ_ASSERT(sPrefMonitor, "sPrefMonitor missing in CameraPreferences::GetPref()");
 335   MonitorAutoLock mon(*sPrefMonitor);
 336
 337   uint32_t i = PrefToIndex(aPref);
 338   if (i == kPrefNotFound || i >= ArrayLength(sPrefs)) {
 339     DOM_CAMERA_LOGW("Preference '%s' is not tracked by CameraPreferences\n", aPref);
 340     return false;
 341   }
 342   if (sPrefs[i].mValueType != kPrefValueIsBoolean) {
 343     DOM_CAMERA_LOGW("Preference '%s' is not a boolean type\n", aPref);
 344     return false;
 345   }
 346
 347   bool v = *sPrefs[i].mValue.mAsBoolean;
 348   DOM_CAMERA_LOGI("Preference '%s', got %s\n", aPref, v ? "true" : "false");
 349   aVal = v;
 350   return true;
 351 }