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 "DOMCameraManager.h"
   9 #include "mozilla/ArrayUtils.h"
  10 #include "mozilla/Monitor.h"
  11 #include "mozilla/StaticPtr.h"
  12 #include "mozilla/Preferences.h"
  13 #ifdef MOZ_WIDGET_GONK
  14 #include "mozilla/Services.h"
  15 #include "nsIObserverService.h"
  16 #endif
  17
  18 using namespace mozilla;
  19
  20 /* statics */
  21 static StaticAutoPtr<Monitor> sPrefMonitor;
  22
  23 StaticAutoPtr<nsCString> CameraPreferences::sPrefTestEnabled;
  24 StaticAutoPtr<nsCString> CameraPreferences::sPrefHardwareTest;
  25 StaticAutoPtr<nsCString> CameraPreferences::sPrefGonkParameters;
  26
  27 nsresult CameraPreferences::sPrefCameraControlMethodErrorOverride = NS_OK;
  28 nsresult CameraPreferences::sPrefCameraControlAsyncErrorOverride = NS_OK;
  29
  30 uint32_t CameraPreferences::sPrefCameraControlLowMemoryThresholdMB = 0;
  31
  32 bool CameraPreferences::sPrefCameraParametersIsLowMemory = false;
  33
  34 #ifdef MOZ_WIDGET_GONK
  35 StaticRefPtr<CameraPreferences> CameraPreferences::sObserver;
  36
  37 NS_IMPL_ISUPPORTS(CameraPreferences, nsIObserver);
  38 #endif
  39
  40 #ifdef CAMERAPREFERENCES_HAVE_SEPARATE_UINT32_AND_NSRESULT
  41 /* static */
  42 nsresult
  43 CameraPreferences::UpdatePref(const char* aPref, nsresult& aVal)
  44 {
  45   uint32_t val;
  46   nsresult rv = Preferences::GetUint(aPref, &val);
  47   if (NS_SUCCEEDED(rv)) {
  48     aVal = static_cast<nsresult>(val);
  49   }
  50   return rv;
  51 }
  52 #endif
  53
  54 /* static */
  55 nsresult
  56 CameraPreferences::UpdatePref(const char* aPref, uint32_t& aVal)
  57 {
  58   uint32_t val;
  59   nsresult rv = Preferences::GetUint(aPref, &val);
  60   if (NS_SUCCEEDED(rv)) {
  61     aVal = val;
  62   }
  63   return rv;
  64 }
  65
  66 /* static */
  67 nsresult
  68 CameraPreferences::UpdatePref(const char* aPref, nsACString& aVal)
  69 {
  70   nsCString val;
  71   nsresult rv = Preferences::GetCString(aPref, &val);
  72   if (NS_SUCCEEDED(rv)) {
  73     aVal = val;
  74   }
  75   return rv;
  76 }
  77
  78 /* static */
  79 nsresult
  80 CameraPreferences::UpdatePref(const char* aPref, bool& aVal)
  81 {
  82   bool val;
  83   nsresult rv = Preferences::GetBool(aPref, &val);
  84   if (NS_SUCCEEDED(rv)) {
  85     aVal = val;
  86   }
  87   return rv;
  88 }
  89
  90 /* static */
  91 CameraPreferences::Pref CameraPreferences::sPrefs[] = {
  92   {
  93     "camera.control.test.enabled",
  94     kPrefValueIsCString,
  95     { &sPrefTestEnabled }
  96   },
  97   {
  98     "camera.control.test.hardware",
  99     kPrefValueIsCString,
 100     { &sPrefHardwareTest }
 101   },
 102 #ifdef MOZ_B2G
 103   {
 104     "camera.control.test.hardware.gonk.parameters",
 105     kPrefValueIsCString,
 106     { &sPrefGonkParameters }
 107   },
 108 #endif
 109   {
 110     "camera.control.test.method.error",
 111     kPrefValueIsNsResult,
 112     { &sPrefCameraControlMethodErrorOverride }
 113   },
 114   {
 115     "camera.control.test.async.error",
 116     kPrefValueIsNsResult,
 117     { &sPrefCameraControlAsyncErrorOverride }
 118   },
 119   {
 120     "camera.control.test.is_low_memory",
 121     kPrefValueIsBoolean,
 122     { &sPrefCameraParametersIsLowMemory }
 123   },
 124   {
 125     "camera.control.low_memory_thresholdMB",
 126     kPrefValueIsUint32,
 127     { &sPrefCameraControlLowMemoryThresholdMB }
 128   },
 129 };
 130
 131 /* static */
 132 uint32_t
 133 CameraPreferences::PrefToIndex(const char* aPref)
 134 {
 135   for (uint32_t i = 0; i < ArrayLength(sPrefs); ++i) {
 136     if (strcmp(aPref, sPrefs[i].mPref) == 0) {
 137       return i;
 138     }
 139   }
 140   return kPrefNotFound;
 141 }
 142
 143 /* static */
 144 void
 145 CameraPreferences::PreferenceChanged(const char* aPref, void* aClosure)
 146 {
 147   MonitorAutoLock mon(*sPrefMonitor);
 148
 149   uint32_t i = PrefToIndex(aPref);
 150   if (i == kPrefNotFound) {
 151     DOM_CAMERA_LOGE("Preference '%s' is not tracked by CameraPreferences\n", aPref);
 152     return;
 153   }
 154
 155   Pref& p = sPrefs[i];
 156   nsresult rv;
 157   switch (p.mValueType) {
 158     case kPrefValueIsNsResult:
 159     #ifdef CAMERAPREFERENCES_HAVE_SEPARATE_UINT32_AND_NSRESULT
 160       {
 161         nsresult& v = *p.mValue.mAsNsResult;
 162         rv = UpdatePref(aPref, v);
 163         if (NS_SUCCEEDED(rv)) {
 164           DOM_CAMERA_LOGI("Preference '%s' has changed, 0x%x\n", aPref, v);
 165         }
 166       }
 167       break;
 168     #endif
 169
 170     case kPrefValueIsUint32:
 171       {
 172         uint32_t& v = *p.mValue.mAsUint32;
 173         rv = UpdatePref(aPref, v);
 174         if (NS_SUCCEEDED(rv)) {
 175           DOM_CAMERA_LOGI("Preference '%s' has changed, %u\n", aPref, v);
 176         }
 177       }
 178       break;
 179
 180     case kPrefValueIsCString:
 181       {
 182         nsCString& v = **p.mValue.mAsCString;
 183         rv = UpdatePref(aPref, v);
 184         if (NS_SUCCEEDED(rv)) {
 185           DOM_CAMERA_LOGI("Preference '%s' has changed, '%s'\n", aPref, v.get());
 186         }
 187       }
 188       break;
 189
 190     case kPrefValueIsBoolean:
 191       {
 192         bool& v = *p.mValue.mAsBoolean;
 193         rv = UpdatePref(aPref, v);
 194         if (NS_SUCCEEDED(rv)) {
 195           DOM_CAMERA_LOGI("Preference '%s' has changed, %s\n",
 196             aPref, v ? "true" : "false");
 197         }
 198       }
 199       break;
 200
 201     default:
 202       MOZ_ASSERT_UNREACHABLE("Unhandled preference value type!");
 203       return;
 204   }
 205
 206   if (NS_FAILED(rv)) {
 207     DOM_CAMERA_LOGE("Failed to get pref '%s' (0x%x)\n", aPref, rv);
 208   }
 209 }
 210
 211 /* static */
 212 bool
 213 CameraPreferences::Initialize()
 214 {
 215   DOM_CAMERA_LOGI("Initializing camera preference callbacks\n");
 216
 217   nsresult rv;
 218
 219 #ifdef MOZ_WIDGET_GONK
 220   nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
 221   if (obs) {
 222     sObserver = new CameraPreferences();
 223     rv = obs->AddObserver(sObserver, "init-camera-hw", false);
 224     if (NS_WARN_IF(NS_FAILED(rv))) {
 225       sObserver = nullptr;
 226     }
 227   } else {
 228     DOM_CAMERA_LOGE("Could not get observer service\n");
 229   }
 230 #endif
 231
 232   sPrefMonitor = new Monitor("CameraPreferences.sPrefMonitor");
 233
 234   sPrefTestEnabled = new nsCString();
 235   sPrefHardwareTest = new nsCString();
 236   sPrefGonkParameters = new nsCString();
 237
 238   for (uint32_t i = 0; i < ArrayLength(sPrefs); ++i) {
 239     rv = Preferences::RegisterCallbackAndCall(CameraPreferences::PreferenceChanged,
 240                                               sPrefs[i].mPref);
 241     if (NS_WARN_IF(NS_FAILED(rv))) {
 242       return false;
 243     }
 244   }
 245
 246   DOM_CAMERA_LOGI("Camera preferences initialized\n");
 247   return true;
 248 }
 249
 250 /* static */
 251 void
 252 CameraPreferences::Shutdown()
 253 {
 254   DOM_CAMERA_LOGI("Shutting down camera preference callbacks\n");
 255
 256   for (uint32_t i = 0; i < ArrayLength(sPrefs); ++i) {
 257     Preferences::UnregisterCallback(CameraPreferences::PreferenceChanged,
 258                                     sPrefs[i].mPref);
 259   }
 260
 261   sPrefTestEnabled = nullptr;
 262   sPrefHardwareTest = nullptr;
 263   sPrefGonkParameters = nullptr;
 264   sPrefMonitor = nullptr;
 265
 266 #ifdef MOZ_WIDGET_GONK
 267   nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
 268   if (obs) {
 269     nsresult rv = obs->RemoveObserver(sObserver , "init-camera-hw");
 270     if (NS_FAILED(rv)) {
 271       DOM_CAMERA_LOGE("Failed to remove CameraPreferences observer (0x%x)\n", rv);
 272     }
 273     sObserver = nullptr;
 274   } else {
 275     DOM_CAMERA_LOGE("Could not get observer service\n");
 276   }
 277 #endif
 278
 279   DOM_CAMERA_LOGI("Camera preferences shut down\n");
 280 }
 281
 282 #ifdef MOZ_WIDGET_GONK
 283 nsresult
 284 CameraPreferences::PreinitCameraHardware()
 285 {
 286   nsDOMCameraManager::PreinitCameraHardware();
 287   return NS_OK;
 288 }
 289
 290 NS_IMETHODIMP
 291 CameraPreferences::Observe(nsISupports* aSubject, const char* aTopic, const char16_t* aData)
 292 {
 293   if (strcmp(aTopic, "init-camera-hw") == 0) {
 294     return PreinitCameraHardware();
 295   }
 296
 297   DOM_CAMERA_LOGE("Got unhandled topic '%s'\n", aTopic);
 298   return NS_OK;
 299 }
 300 #endif
 301
 302 /* static */
 303 bool
 304 CameraPreferences::GetPref(const char* aPref, nsACString& aVal)
 305 {
 306   MOZ_ASSERT(sPrefMonitor, "sPrefMonitor missing in CameraPreferences::GetPref()");
 307   MonitorAutoLock mon(*sPrefMonitor);
 308
 309   uint32_t i = PrefToIndex(aPref);
 310   if (i == kPrefNotFound || i >= ArrayLength(sPrefs)) {
 311     DOM_CAMERA_LOGW("Preference '%s' is not tracked by CameraPreferences\n", aPref);
 312     return false;
 313   }
 314   if (sPrefs[i].mValueType != kPrefValueIsCString) {
 315     DOM_CAMERA_LOGW("Preference '%s' is not a string type\n", aPref);
 316     return false;
 317   }
 318
 319   StaticAutoPtr<nsCString>* s = sPrefs[i].mValue.mAsCString;
 320   if (!*s) {
 321     DOM_CAMERA_LOGE("Preference '%s' cache is not initialized\n", aPref);
 322     return false;
 323   }
 324   if ((*s)->IsEmpty()) {
 325     DOM_CAMERA_LOGI("Preference '%s' is not set\n", aPref);
 326     return false;
 327   }
 328
 329   DOM_CAMERA_LOGI("Preference '%s', got '%s'\n", aPref, (*s)->get());
 330   aVal = **s;
 331   return true;
 332 }
 333
 334 #ifdef CAMERAPREFERENCES_HAVE_SEPARATE_UINT32_AND_NSRESULT
 335 /* static */
 336 bool
 337 CameraPreferences::GetPref(const char* aPref, nsresult& aVal)
 338 {
 339   MOZ_ASSERT(sPrefMonitor, "sPrefMonitor missing in CameraPreferences::GetPref()");
 340   MonitorAutoLock mon(*sPrefMonitor);
 341
 342   uint32_t i = PrefToIndex(aPref);
 343   if (i == kPrefNotFound || i >= ArrayLength(sPrefs)) {
 344     DOM_CAMERA_LOGW("Preference '%s' is not tracked by CameraPreferences\n", aPref);
 345     return false;
 346   }
 347   if (sPrefs[i].mValueType != kPrefValueIsNsResult) {
 348     DOM_CAMERA_LOGW("Preference '%s' is not an nsresult type\n", aPref);
 349     return false;
 350   }
 351
 352   nsresult v = *sPrefs[i].mValue.mAsNsResult;
 353   if (v == NS_OK) {
 354     DOM_CAMERA_LOGW("Preference '%s' is not set\n", aPref);
 355     return false;
 356   }
 357
 358   DOM_CAMERA_LOGI("Preference '%s', got 0x%x\n", aPref, v);
 359   aVal = v;
 360   return true;
 361 }
 362 #endif
 363
 364 /* static */
 365 bool
 366 CameraPreferences::GetPref(const char* aPref, uint32_t& aVal)
 367 {
 368   MOZ_ASSERT(sPrefMonitor, "sPrefMonitor missing in CameraPreferences::GetPref()");
 369   MonitorAutoLock mon(*sPrefMonitor);
 370
 371   uint32_t i = PrefToIndex(aPref);
 372   if (i == kPrefNotFound || i >= ArrayLength(sPrefs)) {
 373     DOM_CAMERA_LOGW("Preference '%s' is not tracked by CameraPreferences\n", aPref);
 374     return false;
 375   }
 376   if (sPrefs[i].mValueType != kPrefValueIsUint32) {
 377     DOM_CAMERA_LOGW("Preference '%s' is not a uint32_t type\n", aPref);
 378     return false;
 379   }
 380
 381   uint32_t v = *sPrefs[i].mValue.mAsUint32;
 382   DOM_CAMERA_LOGI("Preference '%s', got %u\n", aPref, v);
 383   aVal = v;
 384   return true;
 385 }
 386
 387 /* static */
 388 bool
 389 CameraPreferences::GetPref(const char* aPref, bool& aVal)
 390 {
 391   MOZ_ASSERT(sPrefMonitor, "sPrefMonitor missing in CameraPreferences::GetPref()");
 392   MonitorAutoLock mon(*sPrefMonitor);
 393
 394   uint32_t i = PrefToIndex(aPref);
 395   if (i == kPrefNotFound || i >= ArrayLength(sPrefs)) {
 396     DOM_CAMERA_LOGW("Preference '%s' is not tracked by CameraPreferences\n", aPref);
 397     return false;
 398   }
 399   if (sPrefs[i].mValueType != kPrefValueIsBoolean) {
 400     DOM_CAMERA_LOGW("Preference '%s' is not a boolean type\n", aPref);
 401     return false;
 402   }
 403
 404   bool v = *sPrefs[i].mValue.mAsBoolean;
 405   DOM_CAMERA_LOGI("Preference '%s', got %s\n", aPref, v ? "true" : "false");
 406   aVal = v;
 407   return true;
 408 }