/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this file,

 * You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "DOMCameraControl.h"

#include "base/basictypes.h"

#include "nsCOMPtr.h"

#include "nsDOMClassInfo.h"

#include "nsHashPropertyBag.h"

#include "nsThread.h"

#include "DeviceStorage.h"

#include "DeviceStorageFileDescriptor.h"

#include "mozilla/dom/File.h"

#include "mozilla/dom/TabChild.h"

#include "mozilla/ipc/FileDescriptorUtils.h"

#include "mozilla/MediaManager.h"

#include "mozilla/Services.h"

#include "mozilla/unused.h"

#include "nsIAppsService.h"

#include "nsIObserverService.h"

#include "nsIDOMEventListener.h"

#include "nsIScriptSecurityManager.h"

#include "Navigator.h"

#include "nsXULAppAPI.h"

#include "DOMCameraManager.h"

#include "DOMCameraCapabilities.h"

#include "CameraCommon.h"

#include "nsGlobalWindow.h"

#include "CameraPreviewMediaStream.h"

#include "mozilla/dom/CameraUtilBinding.h"

#include "mozilla/dom/CameraControlBinding.h"

#include "mozilla/dom/CameraManagerBinding.h"

#include "mozilla/dom/CameraCapabilitiesBinding.h"

#include "mozilla/dom/CameraConfigurationEvent.h"

#include "mozilla/dom/CameraConfigurationEventBinding.h"

#include "mozilla/dom/CameraFacesDetectedEvent.h"

#include "mozilla/dom/CameraFacesDetectedEventBinding.h"

#include "mozilla/dom/CameraStateChangeEvent.h"

#include "mozilla/dom/CameraClosedEvent.h"

#include "mozilla/dom/BlobEvent.h"

#include "DOMCameraDetectedFace.h"

#include "mozilla/dom/BindingUtils.h"

#include "nsPrintfCString.h"

using namespace mozilla;

using namespace mozilla::dom;

using namespace mozilla::ipc;

#ifdef MOZ_WIDGET_GONK

StaticRefPtr<ICameraControl> nsDOMCameraControl::sCachedCameraControl;

/* static */ nsresult nsDOMCameraControl::sCachedCameraControlStartResult = NS_OK;

/* static */ nsCOMPtr<nsITimer> nsDOMCameraControl::sDiscardCachedCameraControlTimer;

#endif

NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(nsDOMCameraControl)

  NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)

  // nsISupports is an ambiguous base of nsDOMCameraControl

  // so we have to work around that.

  if ( aIID.Equals(NS_GET_IID(nsDOMCameraControl)) )

    foundInterface = static_cast<nsISupports*>(static_cast<void*>(this));

  else

NS_INTERFACE_MAP_END_INHERITING(DOMMediaStream)

NS_IMPL_ADDREF_INHERITED(nsDOMCameraControl, DOMMediaStream)

NS_IMPL_RELEASE_INHERITED(nsDOMCameraControl, DOMMediaStream)

NS_IMPL_CYCLE_COLLECTION_INHERITED(nsDOMCameraControl, DOMMediaStream,

                                   mAudioChannelAgent,

                                   mCapabilities,

                                   mWindow,

                                   mGetCameraPromise,

                                   mAutoFocusPromise,

                                   mTakePicturePromise,

                                   mStartRecordingPromise,

                                   mReleasePromise,

                                   mSetConfigurationPromise)

/* static */

bool

nsDOMCameraControl::HasSupport(JSContext* aCx, JSObject* aGlobal)

{

  return Navigator::HasCameraSupport(aCx, aGlobal);

}

static nsresult

RegisterStorageRequestEvents(DOMRequest* aRequest, nsIDOMEventListener* aListener)

{

  EventListenerManager* elm = aRequest->GetOrCreateListenerManager();

  if (NS_WARN_IF(!elm)) {

    return NS_ERROR_UNEXPECTED;

  }

  elm->AddEventListener(NS_LITERAL_STRING("success"), aListener, false, false);

  elm->AddEventListener(NS_LITERAL_STRING("error"), aListener, false, false);

  return NS_OK;

}

class mozilla::StartRecordingHelper : public nsIDOMEventListener

{

public:

  NS_DECL_ISUPPORTS

  NS_DECL_NSIDOMEVENTLISTENER

  explicit StartRecordingHelper(nsDOMCameraControl* aDOMCameraControl)

    : mDOMCameraControl(aDOMCameraControl)

    , mState(false)

  {

    MOZ_COUNT_CTOR(StartRecordingHelper);

  }

protected:

  virtual ~StartRecordingHelper()

  {

    MOZ_COUNT_DTOR(StartRecordingHelper);

    mDOMCameraControl->OnCreatedFileDescriptor(mState);

  }

protected:

  RefPtr<nsDOMCameraControl> mDOMCameraControl;

  bool mState;

};

NS_IMETHODIMP

StartRecordingHelper::HandleEvent(nsIDOMEvent* aEvent)

{

  nsString eventType;

  aEvent->GetType(eventType);

  mState = eventType.EqualsLiteral("success");

  return NS_OK;

}

NS_IMPL_ISUPPORTS(mozilla::StartRecordingHelper, nsIDOMEventListener)

nsDOMCameraControl::DOMCameraConfiguration::DOMCameraConfiguration()

  : CameraConfiguration()

  , mMaxFocusAreas(0)

  , mMaxMeteringAreas(0)

{

  MOZ_COUNT_CTOR(nsDOMCameraControl::DOMCameraConfiguration);

}

nsDOMCameraControl::DOMCameraConfiguration::DOMCameraConfiguration(const CameraConfiguration& aConfiguration)

  : CameraConfiguration(aConfiguration)

  , mMaxFocusAreas(0)

  , mMaxMeteringAreas(0)

{

  MOZ_COUNT_CTOR(nsDOMCameraControl::DOMCameraConfiguration);

}

nsDOMCameraControl::DOMCameraConfiguration::~DOMCameraConfiguration()

{

  MOZ_COUNT_DTOR(nsDOMCameraControl::DOMCameraConfiguration);

}

#ifdef MOZ_WIDGET_GONK

// This should be long enough for even our slowest platforms.

static const unsigned long kCachedCameraTimeoutMs = 3500;

// Open the battery-door-facing camera by default.

static const uint32_t kDefaultCameraId = 0;

/* static */ void

nsDOMCameraControl::PreinitCameraHardware()

{

  // Assume a default, minimal configuration. This should initialize the

  // hardware, but won't (can't) start the preview.

  RefPtr<ICameraControl> cameraControl = ICameraControl::Create(kDefaultCameraId);

  if (NS_WARN_IF(!cameraControl)) {

    return;

  }

  sCachedCameraControlStartResult = cameraControl->Start();

  if (NS_WARN_IF(NS_FAILED(sCachedCameraControlStartResult))) {

    return;

  }

  sCachedCameraControl = cameraControl;

  nsCOMPtr<nsITimer> timer = do_CreateInstance(NS_TIMER_CONTRACTID);

  if (NS_WARN_IF(!timer)) {

    return;

  }

  nsresult rv = timer->InitWithFuncCallback(DiscardCachedCameraInstance,

                                            nullptr,

                                            kCachedCameraTimeoutMs,

                                            nsITimer::TYPE_ONE_SHOT);

  if (NS_WARN_IF(NS_FAILED(rv))) {

    // If we can't start the timer, it's possible for an app to never grab the

    // camera, leaving the hardware tied up indefinitely. Better to take the

    // performance hit.

    sCachedCameraControl = nullptr;

    return;

  }

  sDiscardCachedCameraControlTimer = timer;

}

/* static */ void

nsDOMCameraControl::DiscardCachedCameraInstance(nsITimer* aTimer, void* aClosure)

{

  MOZ_ASSERT(NS_IsMainThread());

  sDiscardCachedCameraControlTimer = nullptr;

  sCachedCameraControl = nullptr;

}

#endif

nsDOMCameraControl::nsDOMCameraControl(uint32_t aCameraId,

                                       const CameraConfiguration& aInitialConfig,

                                       Promise* aPromise,

                                       nsPIDOMWindow* aWindow)

  : DOMMediaStream()

  , mCameraControl(nullptr)

  , mAudioChannelAgent(nullptr)

  , mGetCameraPromise(aPromise)

  , mWindow(aWindow)

  , mPreviewState(CameraControlListener::kPreviewStopped)

  , mRecording(false)

  , mRecordingStoppedDeferred(false)

  , mSetInitialConfig(false)

{

  DOM_CAMERA_LOGT("%s:%d : this=%p\n", __func__, __LINE__, this);

  mInput = new CameraPreviewMediaStream(this);

  BindToOwner(aWindow);

  RefPtr<DOMCameraConfiguration> initialConfig =

    new DOMCameraConfiguration(aInitialConfig);

  // Create and initialize the underlying camera.

  ICameraControl::Configuration config;

  bool haveInitialConfig = false;

  nsresult rv;

  switch (aInitialConfig.mMode) {

    case CameraMode::Picture:

      config.mMode = ICameraControl::kPictureMode;

      haveInitialConfig = true;

      break;

    case CameraMode::Video:

      config.mMode = ICameraControl::kVideoMode;

      haveInitialConfig = true;

      break;

    case CameraMode::Unspecified:

      break;

    default:

      MOZ_ASSERT_UNREACHABLE("Unanticipated camera mode!");

      break;

  }

  if (haveInitialConfig) {

    rv = SelectPreviewSize(aInitialConfig.mPreviewSize, config.mPreviewSize);

    if (NS_FAILED(rv)) {

      mListener->OnUserError(DOMCameraControlListener::kInStartCamera, rv);

      return;

    }

    config.mPictureSize.width = aInitialConfig.mPictureSize.mWidth;

    config.mPictureSize.height = aInitialConfig.mPictureSize.mHeight;

    config.mRecorderProfile = aInitialConfig.mRecorderProfile;

  }

#ifdef MOZ_WIDGET_GONK

  bool gotCached = false;

  if (sCachedCameraControl && aCameraId == kDefaultCameraId) {

    mCameraControl = sCachedCameraControl;

    sCachedCameraControl = nullptr;

    gotCached = true;

  } else {

    sCachedCameraControl = nullptr;

#endif

    mCameraControl = ICameraControl::Create(aCameraId);

#ifdef MOZ_WIDGET_GONK

  }

#endif

  mCurrentConfiguration = initialConfig.forget();

  // Register the playback listener directly on the camera input stream.

  // We want as low latency as possible for the camera, thus avoiding

  // MediaStreamGraph altogether. Don't do the regular InitStreamCommon()

  // to avoid initializing the Owned and Playback streams. This is OK since

  // we are not user/DOM facing anyway.

  CreateAndAddPlaybackStreamListener(mInput);

  MOZ_ASSERT(mWindow, "Shouldn't be created with a null window!");

  if (mWindow->GetExtantDoc()) {

    CombineWithPrincipal(mWindow->GetExtantDoc()->NodePrincipal());

  }

  // Register a listener for camera events.

  mListener = new DOMCameraControlListener(this, mInput);

  mCameraControl->AddListener(mListener);

#ifdef MOZ_WIDGET_GONK

  if (!gotCached || NS_FAILED(sCachedCameraControlStartResult)) {

#endif

    // Start the camera...

    if (haveInitialConfig) {

      rv = mCameraControl->Start(&config);

      if (NS_SUCCEEDED(rv)) {

        mSetInitialConfig = true;

      }

    } else {

      rv = mCameraControl->Start();

    }

#ifdef MOZ_WIDGET_GONK

  } else {

    if (haveInitialConfig) {

      rv = mCameraControl->SetConfiguration(config);

      if (NS_SUCCEEDED(rv)) {

        mSetInitialConfig = true;

      }

    } else {

      rv = NS_OK;

    }

  }

#endif

  if (NS_FAILED(rv)) {

    mListener->OnUserError(DOMCameraControlListener::kInStartCamera, rv);

  }

}

nsDOMCameraControl::~nsDOMCameraControl()

{

  DOM_CAMERA_LOGT("%s:%d : this=%p\n", __func__, __LINE__, this);

  /*invoke DOMMediaStream destroy*/

  Destroy();

  if (mInput) {

    mInput->Destroy();

    mInput = nullptr;

  }

}

JSObject*

nsDOMCameraControl::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)

{

  return CameraControlBinding::Wrap(aCx, this, aGivenProto);

}

bool

nsDOMCameraControl::IsWindowStillActive()

{

  return nsDOMCameraManager::IsWindowStillActive(mWindow->WindowID());

}

nsresult

nsDOMCameraControl::SelectPreviewSize(const CameraSize& aRequestedPreviewSize, ICameraControl::Size& aSelectedPreviewSize)

{

  if (aRequestedPreviewSize.mWidth && aRequestedPreviewSize.mHeight) {

    aSelectedPreviewSize.width = aRequestedPreviewSize.mWidth;

    aSelectedPreviewSize.height = aRequestedPreviewSize.mHeight;

  } else {

    /* Use the window width and height if no preview size is provided.

       Note that the width and height are actually reversed from the

       camera perspective. */

    int32_t width = 0;

    int32_t height = 0;

    float ratio = 0.0;

    nsresult rv;

    rv = mWindow->GetDevicePixelRatio(&ratio);

    if (NS_WARN_IF(NS_FAILED(rv))) {

      return rv;

    }

    rv = mWindow->GetInnerWidth(&height);

    if (NS_WARN_IF(NS_FAILED(rv))) {

      return rv;

    }

    rv = mWindow->GetInnerHeight(&width);

    if (NS_WARN_IF(NS_FAILED(rv))) {

      return rv;

    }

    MOZ_ASSERT(width > 0);