dom/camera/CameraControlImpl.cpp

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   3  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #include "base/basictypes.h"
   6 #include "mozilla/Assertions.h"
   7 #include "DOMCameraPreview.h"
   8 #include "CameraRecorderProfiles.h"
   9 #include "CameraControlImpl.h"
  10 #include "CameraCommon.h"
  11 #include "nsGlobalWindow.h"
  12
  13 using namespace mozilla;
  14 using namespace mozilla::dom;
  15 using namespace mozilla::idl;
  16
  17 CameraControlImpl::CameraControlImpl(uint32_t aCameraId, nsIThread* aCameraThread, uint64_t aWindowId)
  18   : mCameraId(aCameraId)
  19   , mCameraThread(aCameraThread)
  20   , mWindowId(aWindowId)
  21   , mFileFormat()
  22   , mMaxMeteringAreas(0)
  23   , mMaxFocusAreas(0)
  24   , mPreviewState(PREVIEW_STOPPED)
  25   , mDOMPreview(nullptr)
  26   , mAutoFocusOnSuccessCb(nullptr)
  27   , mAutoFocusOnErrorCb(nullptr)
  28   , mTakePictureOnSuccessCb(nullptr)
  29   , mTakePictureOnErrorCb(nullptr)
  30   , mOnShutterCb(nullptr)
  31   , mOnClosedCb(nullptr)
  32   , mOnRecorderStateChangeCb(nullptr)
  33   , mOnPreviewStateChangeCb(nullptr)
  34 {
  35   DOM_CAMERA_LOGT("%s:%d : this=%p\n", __func__, __LINE__, this);
  36 }
  37
  38 CameraControlImpl::~CameraControlImpl()
  39 {
  40   DOM_CAMERA_LOGT("%s:%d : this=%p\n", __func__, __LINE__, this);
  41 }
  42
  43 // Helpers for string properties.
  44 nsresult
  45 CameraControlImpl::Set(uint32_t aKey, const nsAString& aValue)
  46 {
  47   SetParameter(aKey, NS_ConvertUTF16toUTF8(aValue).get());
  48   return NS_OK;
  49 }
  50
  51 nsresult
  52 CameraControlImpl::Get(uint32_t aKey, nsAString& aValue)
  53 {
  54   const char* value = GetParameterConstChar(aKey);
  55   if (!value) {
  56     return NS_ERROR_FAILURE;
  57   }
  58
  59   aValue.AssignASCII(value);
  60   return NS_OK;
  61 }
  62
  63 // Helpers for doubles.
  64 nsresult
  65 CameraControlImpl::Set(uint32_t aKey, double aValue)
  66 {
  67   SetParameter(aKey, aValue);
  68   return NS_OK;
  69 }
  70
  71 nsresult
  72 CameraControlImpl::Get(uint32_t aKey, double* aValue)
  73 {
  74   MOZ_ASSERT(aValue);
  75   *aValue = GetParameterDouble(aKey);
  76   return NS_OK;
  77 }
  78
  79 // Helper for weighted regions.
  80 nsresult
  81 CameraControlImpl::Set(JSContext* aCx, uint32_t aKey, const JS::Value& aValue, uint32_t aLimit)
  82 {
  83   if (aLimit == 0) {
  84     DOM_CAMERA_LOGI("%s:%d : aLimit = 0, nothing to do\n", __func__, __LINE__);
  85     return NS_OK;
  86   }
  87
  88   if (!aValue.isObject()) {
  89     return NS_ERROR_INVALID_ARG;
  90   }
  91
  92   uint32_t length = 0;
  93
  94   JS::Rooted<JSObject*> regions(aCx, &aValue.toObject());
  95   if (!JS_GetArrayLength(aCx, regions, &length)) {
  96     return NS_ERROR_FAILURE;
  97   }
  98
  99   DOM_CAMERA_LOGI("%s:%d : got %d regions (limited to %d)\n", __func__, __LINE__, length, aLimit);
 100   if (length > aLimit) {
 101     length = aLimit;
 102   }
 103
 104   nsTArray<CameraRegion> regionArray;
 105   regionArray.SetCapacity(length);
 106
 107   for (uint32_t i = 0; i < length; ++i) {
 108     JS::Rooted<JS::Value> v(aCx);
 109
 110     if (!JS_GetElement(aCx, regions, i, &v)) {
 111       return NS_ERROR_FAILURE;
 112     }
 113
 114     CameraRegion* r = regionArray.AppendElement();
 115     /**
 116      * These are the default values.  We can remove these when the xpidl
 117      * dictionary parser gains the ability to grok default values.
 118      */
 119     r->top = -1000;
 120     r->left = -1000;
 121     r->bottom = 1000;
 122     r->right = 1000;
 123     r->weight = 1000;
 124
 125     nsresult rv = r->Init(aCx, v.address());
 126     NS_ENSURE_SUCCESS(rv, rv);
 127
 128     DOM_CAMERA_LOGI("region %d: top=%d, left=%d, bottom=%d, right=%d, weight=%d\n",
 129       i,
 130       r->top,
 131       r->left,
 132       r->bottom,
 133       r->right,
 134       r->weight
 135     );
 136   }
 137   SetParameter(aKey, regionArray);
 138   return NS_OK;
 139 }
 140
 141 nsresult
 142 CameraControlImpl::Get(JSContext* aCx, uint32_t aKey, JS::Value* aValue)
 143 {
 144   nsTArray<CameraRegion> regionArray;
 145
 146   GetParameter(aKey, regionArray);
 147
 148   JS::Rooted<JSObject*> array(aCx, JS_NewArrayObject(aCx, 0, nullptr));
 149   if (!array) {
 150     return NS_ERROR_OUT_OF_MEMORY;
 151   }
 152
 153   uint32_t length = regionArray.Length();
 154   DOM_CAMERA_LOGI("%s:%d : got %d regions\n", __func__, __LINE__, length);
 155
 156   for (uint32_t i = 0; i < length; ++i) {
 157     CameraRegion* r = &regionArray[i];
 158     JS::Rooted<JS::Value> v(aCx);
 159
 160     JS::Rooted<JSObject*> o(aCx, JS_NewObject(aCx, nullptr, nullptr, nullptr));
 161     if (!o) {
 162       return NS_ERROR_OUT_OF_MEMORY;
 163     }
 164
 165     DOM_CAMERA_LOGI("top=%d\n", r->top);
 166     v = INT_TO_JSVAL(r->top);
 167     if (!JS_SetProperty(aCx, o, "top", v)) {
 168       return NS_ERROR_FAILURE;
 169     }
 170     DOM_CAMERA_LOGI("left=%d\n", r->left);
 171     v = INT_TO_JSVAL(r->left);
 172     if (!JS_SetProperty(aCx, o, "left", v)) {
 173       return NS_ERROR_FAILURE;
 174     }
 175     DOM_CAMERA_LOGI("bottom=%d\n", r->bottom);
 176     v = INT_TO_JSVAL(r->bottom);
 177     if (!JS_SetProperty(aCx, o, "bottom", v)) {
 178       return NS_ERROR_FAILURE;
 179     }
 180     DOM_CAMERA_LOGI("right=%d\n", r->right);
 181     v = INT_TO_JSVAL(r->right);
 182     if (!JS_SetProperty(aCx, o, "right", v)) {
 183       return NS_ERROR_FAILURE;
 184     }
 185     DOM_CAMERA_LOGI("weight=%d\n", r->weight);
 186     v = INT_TO_JSVAL(r->weight);
 187     if (!JS_SetProperty(aCx, o, "weight", v)) {
 188       return NS_ERROR_FAILURE;
 189     }
 190
 191     v = OBJECT_TO_JSVAL(o);
 192     if (!JS_SetElement(aCx, array, i, &v)) {
 193       return NS_ERROR_FAILURE;
 194     }
 195   }
 196
 197   *aValue = JS::ObjectValue(*array);
 198   return NS_OK;
 199 }
 200
 201 nsresult
 202 CameraControlImpl::Set(nsICameraShutterCallback* aOnShutter)
 203 {
 204   mOnShutterCb = new nsMainThreadPtrHolder<nsICameraShutterCallback>(aOnShutter);
 205   return NS_OK;
 206 }
 207
 208 nsresult
 209 CameraControlImpl::Get(nsICameraShutterCallback** aOnShutter)
 210 {
 211   *aOnShutter = mOnShutterCb;
 212   return NS_OK;
 213 }
 214
 215 nsresult
 216 CameraControlImpl::Set(nsICameraClosedCallback* aOnClosed)
 217 {
 218   mOnClosedCb = new nsMainThreadPtrHolder<nsICameraClosedCallback>(aOnClosed);
 219   return NS_OK;
 220 }
 221
 222 nsresult
 223 CameraControlImpl::Get(nsICameraClosedCallback** aOnClosed)
 224 {
 225   *aOnClosed = mOnClosedCb;
 226   return NS_OK;
 227 }
 228
 229 nsresult
 230 CameraControlImpl::Set(nsICameraRecorderStateChange* aOnRecorderStateChange)
 231 {
 232   mOnRecorderStateChangeCb = new nsMainThreadPtrHolder<nsICameraRecorderStateChange>(aOnRecorderStateChange);
 233   return NS_OK;
 234 }
 235
 236 nsresult
 237 CameraControlImpl::Get(nsICameraRecorderStateChange** aOnRecorderStateChange)
 238 {
 239   *aOnRecorderStateChange = mOnRecorderStateChangeCb;
 240   return NS_OK;
 241 }
 242
 243 nsresult
 244 CameraControlImpl::Set(nsICameraPreviewStateChange* aOnPreviewStateChange)
 245 {
 246   mOnPreviewStateChangeCb = new nsMainThreadPtrHolder<nsICameraPreviewStateChange>(aOnPreviewStateChange);
 247   return NS_OK;
 248 }
 249
 250 nsresult
 251 CameraControlImpl::Get(nsICameraPreviewStateChange** aOnPreviewStateChange)
 252 {
 253   *aOnPreviewStateChange = mOnPreviewStateChangeCb;
 254   return NS_OK;
 255 }
 256
 257 nsresult
 258 CameraControlImpl::Set(uint32_t aKey, const idl::CameraSize& aSize)
 259 {
 260   SetParameter(aKey, aSize);
 261   return NS_OK;
 262 }
 263
 264 nsresult
 265 CameraControlImpl::Get(uint32_t aKey, idl::CameraSize& aSize)
 266 {
 267   GetParameter(aKey, aSize);
 268   return NS_OK;
 269 }
 270
 271 nsresult
 272 CameraControlImpl::Get(uint32_t aKey, int32_t* aValue)
 273 {
 274   MOZ_ASSERT(aValue);
 275   *aValue = GetParameterInt32(aKey);
 276   return NS_OK;
 277 }
 278
 279 already_AddRefed<RecorderProfileManager>
 280 CameraControlImpl::GetRecorderProfileManager()
 281 {
 282   return GetRecorderProfileManagerImpl();
 283 }
 284
 285 void
 286 CameraControlImpl::Shutdown()
 287 {
 288   DOM_CAMERA_LOGT("%s:%d\n", __func__, __LINE__);
 289   mAutoFocusOnSuccessCb = nullptr;
 290   mAutoFocusOnErrorCb = nullptr;
 291   mTakePictureOnSuccessCb = nullptr;
 292   mTakePictureOnErrorCb = nullptr;
 293   mOnShutterCb = nullptr;
 294   mOnClosedCb = nullptr;
 295   mOnRecorderStateChangeCb = nullptr;
 296   mOnPreviewStateChangeCb = nullptr;
 297 }
 298
 299 void
 300 CameraControlImpl::OnShutterInternal()
 301 {
 302   DOM_CAMERA_LOGI("** SNAP **\n");
 303   if (mOnShutterCb.get()) {
 304     mOnShutterCb->HandleEvent();
 305   }
 306 }
 307
 308 void
 309 CameraControlImpl::OnShutter()
 310 {
 311   nsCOMPtr<nsIRunnable> onShutter = NS_NewRunnableMethod(this, &CameraControlImpl::OnShutterInternal);
 312   nsresult rv = NS_DispatchToMainThread(onShutter);
 313   if (NS_FAILED(rv)) {
 314     DOM_CAMERA_LOGW("Failed to dispatch onShutter event to main thread (%d)\n", rv);
 315   }
 316 }
 317
 318 class OnClosedTask : public nsRunnable
 319 {
 320 public:
 321   OnClosedTask(nsMainThreadPtrHandle<nsICameraClosedCallback> onClosed, uint64_t aWindowId)
 322     : mOnClosedCb(onClosed)
 323     , mWindowId(aWindowId)
 324   {
 325     DOM_CAMERA_LOGT("%s:%d : this=%p\n", __func__, __LINE__, this);
 326   }
 327
 328   virtual ~OnClosedTask()
 329   {
 330     DOM_CAMERA_LOGT("%s:%d : this=%p\n", __func__, __LINE__, this);
 331   }
 332
 333   NS_IMETHOD Run()
 334   {
 335     MOZ_ASSERT(NS_IsMainThread());
 336
 337     if (mOnClosedCb.get() && nsDOMCameraManager::IsWindowStillActive(mWindowId)) {
 338       mOnClosedCb->HandleEvent();
 339     }
 340     return NS_OK;
 341   }
 342
 343 protected:
 344   nsMainThreadPtrHandle<nsICameraClosedCallback> mOnClosedCb;
 345   uint64_t mWindowId;
 346 };
 347
 348 void
 349 CameraControlImpl::OnClosed()
 350 {
 351   nsCOMPtr<nsIRunnable> onClosed = new OnClosedTask(mOnClosedCb, mWindowId);
 352   nsresult rv = NS_DispatchToMainThread(onClosed);
 353   if (NS_FAILED(rv)) {
 354     DOM_CAMERA_LOGW("Failed to dispatch onClosed event to main thread (%d)\n", rv);
 355   }
 356 }
 357
 358 void
 359 CameraControlImpl::OnRecorderStateChange(const nsString& aStateMsg, int32_t aStatus, int32_t aTrackNumber)
 360 {
 361   DOM_CAMERA_LOGI("OnRecorderStateChange: '%s'\n", NS_ConvertUTF16toUTF8(aStateMsg).get());
 362
 363   nsCOMPtr<nsIRunnable> onRecorderStateChange = new CameraRecorderStateChange(mOnRecorderStateChangeCb, aStateMsg, aStatus, aTrackNumber, mWindowId);
 364   nsresult rv = NS_DispatchToMainThread(onRecorderStateChange);
 365   if (NS_FAILED(rv)) {
 366     DOM_CAMERA_LOGE("Failed to dispatch onRecorderStateChange event to main thread (%d)\n", rv);
 367   }
 368 }
 369
 370 void
 371 CameraControlImpl::OnPreviewStateChange(PreviewState aNewState)
 372 {
 373   if (aNewState == mPreviewState) {
 374     DOM_CAMERA_LOGI("OnPreviewStateChange: state did not change from %d\n", mPreviewState);
 375     return;
 376   }
 377
 378   nsString msg;
 379   switch (aNewState) {
 380     case PREVIEW_STOPPED:
 381       msg = NS_LITERAL_STRING("stopped");
 382       break;
 383
 384     case PREVIEW_STARTED:
 385       msg = NS_LITERAL_STRING("started");
 386       break;
 387
 388     default:
 389       MOZ_ASSUME_UNREACHABLE("Preview state can only be PREVIEW_STOPPED or _STARTED!");
 390   }
 391
 392   // const nsString& aStateMsg)
 393   DOM_CAMERA_LOGI("OnPreviewStateChange: '%s'\n", NS_ConvertUTF16toUTF8(msg).get());
 394   mPreviewState = aNewState;
 395
 396   nsCOMPtr<nsIRunnable> onPreviewStateChange = new CameraPreviewStateChange(mOnPreviewStateChangeCb, msg, mWindowId);
 397   nsresult rv = NS_DispatchToMainThread(onPreviewStateChange);
 398   if (NS_FAILED(rv)) {
 399     DOM_CAMERA_LOGE("Failed to dispatch onPreviewStateChange event to main thread (%d)\n", rv);
 400   }
 401 }
 402
 403 nsresult
 404 CameraControlImpl::GetPreviewStream(CameraSize aSize, nsICameraPreviewStreamCallback* onSuccess, nsICameraErrorCallback* onError)
 405 {
 406   nsCOMPtr<nsIRunnable> getPreviewStreamTask = new GetPreviewStreamTask(this, aSize, onSuccess, onError);
 407   return mCameraThread->Dispatch(getPreviewStreamTask, NS_DISPATCH_NORMAL);
 408 }
 409
 410 nsresult
 411 CameraControlImpl::AutoFocus(nsICameraAutoFocusCallback* onSuccess, nsICameraErrorCallback* onError)
 412 {
 413   MOZ_ASSERT(NS_IsMainThread());
 414   bool cancel = false;
 415
 416   nsCOMPtr<nsICameraAutoFocusCallback> cb = mAutoFocusOnSuccessCb.get();
 417   if (cb) {
 418     /**
 419      * We already have a callback, so someone has already
 420      * called autoFocus() -- cancel it.
 421      */
 422     mAutoFocusOnSuccessCb = nullptr;
 423     mAutoFocusOnErrorCb = nullptr;
 424     cancel = true;
 425   }
 426
 427   nsCOMPtr<nsIRunnable> autoFocusTask = new AutoFocusTask(this, cancel, onSuccess, onError);
 428   return mCameraThread->Dispatch(autoFocusTask, NS_DISPATCH_NORMAL);
 429 }
 430
 431 nsresult
 432 CameraControlImpl::TakePicture(const CameraSize& aSize, int32_t aRotation, const nsAString& aFileFormat, CameraPosition aPosition, uint64_t aDateTime, nsICameraTakePictureCallback* onSuccess, nsICameraErrorCallback* onError)
 433 {
 434   MOZ_ASSERT(NS_IsMainThread());
 435   bool cancel = false;
 436
 437   nsCOMPtr<nsICameraTakePictureCallback> cb = mTakePictureOnSuccessCb.get();
 438   if (cb) {
 439     /**
 440      * We already have a callback, so someone has already
 441      * called takePicture() -- cancel it.
 442      */
 443     mTakePictureOnSuccessCb = nullptr;
 444     mTakePictureOnErrorCb = nullptr;
 445     cancel = true;
 446   }
 447
 448   nsCOMPtr<nsIRunnable> takePictureTask = new TakePictureTask(this, cancel, aSize, aRotation, aFileFormat, aPosition, aDateTime, onSuccess, onError);
 449   return mCameraThread->Dispatch(takePictureTask, NS_DISPATCH_NORMAL);
 450 }
 451
 452 nsresult
 453 CameraControlImpl::StartRecording(CameraStartRecordingOptions* aOptions, nsIFile* aFolder, const nsAString& aFilename, nsICameraStartRecordingCallback* onSuccess, nsICameraErrorCallback* onError)
 454 {
 455   nsCOMPtr<nsIFile> clone;
 456   aFolder->Clone(getter_AddRefs(clone));
 457
 458   nsCOMPtr<nsIRunnable> startRecordingTask = new StartRecordingTask(this, *aOptions, clone, aFilename, onSuccess, onError, mWindowId);
 459   return mCameraThread->Dispatch(startRecordingTask, NS_DISPATCH_NORMAL);
 460 }
 461
 462 nsresult
 463 CameraControlImpl::StopRecording()
 464 {
 465   nsCOMPtr<nsIRunnable> stopRecordingTask = new StopRecordingTask(this);
 466   return mCameraThread->Dispatch(stopRecordingTask, NS_DISPATCH_NORMAL);
 467 }
 468
 469 nsresult
 470 CameraControlImpl::StartPreview(DOMCameraPreview* aDOMPreview)
 471 {
 472   nsCOMPtr<nsIRunnable> startPreviewTask = new StartPreviewTask(this, aDOMPreview);
 473   return mCameraThread->Dispatch(startPreviewTask, NS_DISPATCH_NORMAL);
 474 }
 475
 476 void
 477 CameraControlImpl::StopPreview()
 478 {
 479   nsCOMPtr<nsIRunnable> stopPreviewTask = new StopPreviewTask(this);
 480   mCameraThread->Dispatch(stopPreviewTask, NS_DISPATCH_NORMAL);
 481 }
 482
 483 nsresult
 484 CameraControlImpl::GetPreviewStreamVideoMode(CameraRecorderOptions* aOptions, nsICameraPreviewStreamCallback* onSuccess, nsICameraErrorCallback* onError)
 485 {
 486   nsCOMPtr<nsIRunnable> getPreviewStreamVideoModeTask = new GetPreviewStreamVideoModeTask(this, *aOptions, onSuccess, onError);
 487   return mCameraThread->Dispatch(getPreviewStreamVideoModeTask, NS_DISPATCH_NORMAL);
 488 }
 489
 490 nsresult
 491 CameraControlImpl::ReleaseHardware(nsICameraReleaseCallback* onSuccess, nsICameraErrorCallback* onError)
 492 {
 493   nsCOMPtr<nsIRunnable> releaseHardwareTask = new ReleaseHardwareTask(this, onSuccess, onError);
 494   return mCameraThread->Dispatch(releaseHardwareTask, NS_DISPATCH_NORMAL);
 495 }
 496
 497 bool
 498 CameraControlImpl::ReceiveFrame(void* aBuffer, ImageFormat aFormat, FrameBuilder aBuilder)
 499 {
 500   if (!mDOMPreview) {
 501     return false;
 502   }
 503
 504   return mDOMPreview->ReceiveFrame(aBuffer, aFormat, aBuilder);
 505 }
 506
 507 NS_IMETHODIMP
 508 GetPreviewStreamResult::Run()
 509 {
 510   /**
 511    * The camera preview stream object is DOM-facing, and as such
 512    * must be a cycle-collection participant created on the main
 513    * thread.
 514    */
 515   MOZ_ASSERT(NS_IsMainThread());
 516
 517   nsCOMPtr<nsICameraPreviewStreamCallback> onSuccess = mOnSuccessCb.get();
 518   nsGlobalWindow* window = nsGlobalWindow::GetInnerWindowWithId(mWindowId);
 519   if (onSuccess && nsDOMCameraManager::IsWindowStillActive(mWindowId) && window) {
 520     nsCOMPtr<nsIDOMMediaStream> stream =
 521       new DOMCameraPreview(window, mCameraControl, mWidth, mHeight,
 522                                  mFramesPerSecond);
 523     onSuccess->HandleEvent(stream);
 524   }
 525   return NS_OK;
 526 }