src/FMedia_CameraCoordinator.h

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file                        FMedia_CameraCoordinator.h
  20  * @brief                       This header file contains the declarations of the %_CameraCoordinator class.
  21  *
  22  */
  23
  24 #ifndef _FMEDIA_INTERNAL_CAMERA_COORDINATOR_H_
  25 #define _FMEDIA_INTERNAL_CAMERA_COORDINATOR_H_
  26
  27 #include <unique_ptr.h>
  28 #include <camera.h>
  29 #include <recorder.h>
  30 #include <FBaseColLinkedListT.h>
  31 #include <FBaseColHashMapT.h>
  32 #include <FMediaCameraTypes.h>
  33 #include <FMediaRecorderTypes.h>
  34 #include "FMedia_CameraTypes.h"
  35 #include "FMedia_RecorderTypes.h"
  36 #include "FMedia_CameraRefHelper.h"
  37 #include "FMedia_CamPtrUtil.h"
  38
  39 namespace Tizen { namespace Media
  40 {
  41 class _ICameraCoordinatorListener;
  42 class _CameraCoordinatorSafeHashMapT;
  43
  44 /**
  45  * @class       _CameraCoordinator
  46  * @brief       This class implements the _CameraCoordinator class.
  47  *
  48  */
  49 class _CameraCoordinator
  50         : public _CameraRefHelper
  51 {
  52 public:
  53         /**
  54         * Get the instance of _CameraCoordinator.
  55         *
  56         * @return               The _CameraCoordinator instance
  57         * @param[in]    cameraDevice                    The camera device id.
  58         * @exception    E_SUCCESS                               The method is successful.
  59         * @exception    E_SYSTEM                                A system error has occurred.
  60         * @exception    E_DEVICE_BUSY                   The device cannot be approached because of other operations.
  61         * @exception    E_DEVICE_UNAVAILABLE    The device is unavailable.
  62         */
  63         static _CameraCoordinator* AddInstance(_CameraDeviceType cameraDevice);
  64
  65         /**
  66         * Get the instance of _CameraCoordinator.
  67         *
  68         * @return               The _CameraCoordinator instance
  69         * @param[in]    recorderDevice                  The recorder device id.
  70         * @exception    E_SUCCESS                               The method is successful.
  71         * @exception    E_SYSTEM                                A system error has occurred.
  72         * @exception    E_DEVICE_BUSY                   The device cannot be approached because of other operations.
  73         * @exception    E_DEVICE_UNAVAILABLE    The device is unavailable.
  74         */
  75         static _CameraCoordinator* AddInstance(_RecorderDeviceType recorderDevice);
  76
  77         /**
  78         * Release the specific _CameraCoordinator.
  79         *
  80         * @param[in]    cameraDevice                    The camera device type
  81         */
  82         static void Release(_CameraDeviceType cameraDevice);
  83
  84         /**
  85         * Release the specific _CameraCoordinator.
  86         *
  87         * @param[in]    recorderDevice                  The recorder device type
  88         */
  89         static void Release(_RecorderDeviceType recorderDevice);
  90
  91         /**
  92         * Check whether it has the instance.
  93         *
  94         * @return               The _CameraCoordinator instance
  95         * @param[in]    cameraDevice                    The camera device id.
  96         * @exception    E_SUCCESS                               The method is successful.
  97         * @exception    E_SYSTEM                                A system error has occurred.
  98         * @exception    E_DEVICE_BUSY                   The device cannot be approached because of other operations.
  99         * @exception    E_DEVICE_UNAVAILABLE    The device is unavailable.
 100         */
 101         static _CameraCoordinator* HasInstance(_CameraDeviceType cameraDevice);
 102
 103         /**
 104         * Check whether it has the instance.
 105         *
 106         * @return               The _CameraCoordinator instance
 107         * @param[in]    recorderDevice                  The recorder device id.
 108         * @exception    E_SUCCESS                               The method is successful.
 109         * @exception    E_SYSTEM                                A system error has occurred.
 110         * @exception    E_DEVICE_BUSY                   The device cannot be approached because of other operations.
 111         * @exception    E_DEVICE_UNAVAILABLE    The device is unavailable.
 112         */
 113         static _CameraCoordinator* HasInstance(_RecorderDeviceType recorderDevice);
 114
 115         /**
 116          * This is the destructor for this class. @n
 117          * All allocated resources are deallocated by this method. This method should be called in the same thread
 118          * where the Construct() method is called.
 119          *
 120          * @see                 Construct()
 121          */
 122         virtual ~_CameraCoordinator(void);
 123
 124         /**
 125         * Adds the listener to this object. @n
 126         * Added listeners are called after this object's callbacks are called from the camera.
 127         *
 128         * @return               An error code
 129         * @param[in]    listener                                        A listener instance
 130         * @exception    E_SUCCESS                               The method is successful.
 131         * @exception    E_SYSTEM                                A system error has occurred.
 132         */
 133         result AddCameraCoordinatorListener(_ICameraCoordinatorListener& listener);
 134
 135         /**
 136         * Removes the listener from this object. @n
 137         *
 138         * @return               An error code
 139         * @param[in]    listener                                        A listener instance
 140         * @exception    E_SUCCESS                               The method is successful.
 141         * @exception    E_SYSTEM                                A system error has occurred.
 142         */
 143         result RemoveCameraCoordinatorListener(_ICameraCoordinatorListener& listener);
 144
 145         /**
 146         * Gets the mode.
 147         *
 148         * @return                  The camera mode
 149         */
 150         _CameraMode GetMode(void) const;
 151
 152         /**
 153         * Gets the camera device selection.
 154         *
 155         * @return                  The camera device selection
 156         */
 157         _CameraDeviceType GetCameraDevice(void) const;
 158
 159         /**
 160         * Gets the camera handle
 161         *
 162         * @return                  The camera handle
 163         */
 164         _CameraHandle GetCameraHandle(void) const;
 165
 166         /**
 167         * Gets the recorder handle
 168         *
 169         * @return                  The recorder handle
 170         */
 171         _RecorderHandle GetRecorderHandle(void) const;
 172
 173         /**
 174         * Notifies the mode changing status to _ICameraCoordinatorListener
 175         *
 176         * @return               An error code
 177         * @param[in]    mode                    camera mode
 178         * @remarks      This mtehod calls _ICameraCoordinatorListener::::OnCameraCoordinatorModeChangePrepared().
 179         *                       This method will call every _ICameraCoordinatorListener which are registered to _CameraCoordinator.
 180         */
 181         result NotifyModeChangePrepared(_CameraMode mode);
 182
 183         /**
 184         * Notifies the mode changed status to _ICameraCoordinatorListener
 185         *
 186         * @return               An error code
 187         * @param[in]    mode                    camera mode
 188         * @remarks      This mtehod calls _ICameraCoordinatorListener::::OnCameraCoordinatorModeChanged().
 189         *                       This method will call every _ICameraCoordinatorListener which are registered to _CameraCoordinator.
 190         */
 191         result NotifyModeChanged(_CameraMode mode);
 192
 193         /**
 194         * Start the preview.
 195         *
 196         * @return               An error code
 197         * @param[in]    mode                                            The mode to set
 198         * @exception    E_SUCCESS                                       The method is successful.
 199         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 200         */
 201         result StartMmPreview(void);
 202
 203         /**
 204         * Stop the preview.
 205         *
 206         * @return               An error code
 207         * @param[in]    mode                                            The mode to set
 208         * @exception    E_SUCCESS                                       The method is successful.
 209         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 210         */
 211         result StopMmPreview(void);
 212
 213         /**
 214         * Changes the camcorder mode.
 215         *
 216         * @return               An error code
 217         * @param[in]    mode                                            The mode to set
 218         * @param[in]    callback                                                The flag to call the callback
 219         * @exception    E_SUCCESS                                       The method is successful.
 220         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 221         * @exception    E_DEVICE_BUSY                           The device cannot be approached because of other operations.
 222         * @exception    E_DEVICE_UNAVAILABLE            The device is unavailable.
 223         * @exception    E_DEVICE_FAILED                         The device operation has failed.
 224         * @exception    E_UNSUPPORTED_OPERATION  This operation is not supported.
 225         */
 226         result ChangeMode(_CameraMode mode, bool callback);
 227
 228         /**
 229         * Check if the change mode can be calmly.
 230         *
 231         * @return               The flag of calm change mode
 232         * @param[in]    mode                                            The mode to set
 233         */
 234         bool IsCalmChangeMode(_CameraMode mode);
 235
 236         /**
 237         * Set source format.
 238         *
 239         * @return          An error code
 240         * @param[in]    pixelFormat                      camera's preview format
 241         */
 242         result SetCameraSourceFormat(camera_pixel_format_e pixelFormat);
 243
 244         /**
 245         * Get source format.
 246         *
 247         * @return          camera's preview format
 248         */
 249         camera_pixel_format_e GetCameraSourceFormat(void) const;
 250
 251         /**
 252         * Captures the current image data from the camera sensor.
 253         *
 254         * @return               An error code
 255         * @param[in]    capturingCb                                     The capture callback
 256         * @param[in]    completedCb                             The capture completed callback
 257         * @param[in]    pUserData                                       The user data
 258         * @exception    E_SUCCESS                                       The method is successful.
 259         * @exception    E_INVALID_STATE                         This instance is in an invalid state for this method.
 260         * @exception    E_DEVICE_BUSY                           The device cannot be approached because of other operations.
 261         * @exception    E_DEVICE_UNAVAILABLE            The device is unavailable.
 262         * @exception    E_DEVICE_FAILED                         The device operation has failed.
 263         * @exception    E_UNSUPPORTED_OPERATION  This operation is not supported.
 264         * @exception    E_OUT_OF_MEMORY                         The memory is insufficient.
 265         */
 266         result StartCapture(camera_capturing_cb capturingCb , camera_capture_completed_cb completedCb , void *pUserData);
 267
 268         /**
 269         * Start recording.
 270         *
 271         * @return               An error code
 272         */
 273         result StartRecord(void);
 274
 275         /**
 276         * Sets the orientation of the recorder.
 277         *
 278         * @return               An error code
 279         */
 280         void SetRecordingOrientation(RecordingRotation rotation);
 281
 282         /**
 283         * Sets the orientation of the camera.
 284         *
 285         * @return               An error code
 286         */
 287         void SetCameraOrientation(CameraExifOrientation orientation);
 288
 289 private:
 290         friend class _CameraCoordinatorSafeHashMapT;
 291         /**
 292          * This is the default constructor for this class.
 293          *
 294          * @remarks             After creating an instance of this class, the Construct() method must be called explicitly to
 295          * initialize this instance.
 296          * @see                 Construct()
 297          */
 298         _CameraCoordinator(void);
 299
 300         /**
 301         * Initializes this instance of _CameraCoordinator.
 302         *
 303         * @return               An error code
 304         * @param[in]    cameraDevice                    The camera device id.
 305         * @exception    E_SUCCESS                               The method is successful.
 306         * @exception    E_SYSTEM                                A system error has occurred.
 307         * @exception    E_DEVICE_BUSY                   The device cannot be approached because of other operations.
 308         * @exception    E_DEVICE_UNAVAILABLE    The device is unavailable.
 309         */
 310         result Construct(_CameraDeviceType cameraDevice);
 311
 312         /**
 313         * Add the recorder
 314         *
 315         * @return               An error code
 316         * @param[in]    recorderDevice                  The recorder device id.
 317         * @exception    E_SUCCESS                               The method is successful.
 318         * @exception    E_SYSTEM                                A system error has occurred.
 319         */
 320         result AddRecorder(_RecorderDeviceType recorderDevice);
 321
 322         /**
 323         * Remove the recorder
 324         *
 325         * @param[in]    recorderDevice                  The recorder device id.
 326         * @exception    E_SUCCESS                               The method is successful.
 327         * @exception    E_SYSTEM                                A system error has occurred.
 328         */
 329         void RemoveRecorder(_RecorderDeviceType recorderDevice);
 330
 331         /**
 332         * Converts the error from camera to Result.
 333         *
 334         * @return          An error code
 335         * @param[in]    err                      camera error
 336         */
 337         result ConvertResult(int err) const;
 338
 339         /**
 340         * Change the state.
 341         *
 342         * @return          An error code
 343         * @param[in]    destState                        camera's destinationed state
 344         * @remarks      This method makes the camera's state change. @n
 345         *                       Acccording to this, Camera's state is changed.
 346         */
 347         result ChangeCameraStateTo(camera_state_e destState);
 348
 349         /**
 350         * Gets the camera's state.
 351         *
 352         * @return                  The state
 353         */
 354         camera_state_e GetCameraState(void) const;
 355
 356         /**
 357         * Gets the recorder's state.
 358         *
 359         * @return                  The state
 360         */
 361         recorder_state_e GetRecorderState(void) const;
 362
 363         /**
 364         * Change the state.
 365         *
 366         * @return          An error code
 367         * @param[in]    destState                        recorder's destinationed state
 368         * @remarks      This method makes the camera's state change. @n
 369         *                       acccording to this, VideoRecorder and AudioRecorder's state is changed.
 370         */
 371         result ChangeRecorderStateTo(recorder_state_e destState);
 372
 373         /**
 374         * Sets the orientation of the recorder.
 375         *
 376         * @return               An error code
 377         * @param[in]    rotation                        The rotation of the recorder
 378         * @exception    E_SUCCESS                       The method is successful.
 379         * @exception    E_INVALID_STATE         This method is invalid for the current state of this instance.
 380         * @exception    E_INVALID_ARG           The specified @c rotation is not supported.
 381         */
 382         result SetRecordingOrientationAttr(RecordingRotation rotation);
 383
 384         /**
 385         * Sets the orientation of the camera.
 386         *
 387         * @return               An error code
 388         * @param[in]    orientation                     The orientation of the camera
 389         * @exception    E_SUCCESS                       The method is successful.
 390         * @exception    E_INVALID_STATE         This method is invalid for the current state of this instance.
 391         * @exception    E_INVALID_ARG           The specified @c rotation is not supported.
 392         */
 393         result SetCameraOrientationAttr(CameraExifOrientation orientation);
 394
 395         _CameraCoordinator(const _CameraCoordinator& rhs);
 396         _CameraCoordinator& operator =(const _CameraCoordinator& rhs);
 397
 398         _CameraDeviceType __cameraDevice;
 399         _CameraHandle __cameraHandle;
 400         _RecorderHandle __recorderHandle;
 401         _CameraMode __mode;
 402         std::unique_ptr<Tizen::Base::Collection::LinkedListT <_ICameraCoordinatorListener*>, _ListPtrUtil::Remover> __pListenerList;
 403         int __orientationFlag;
 404         CameraExifOrientation __cameraOrientation;
 405         RecordingRotation __recordingRotation;
 406
 407         static _CameraCoordinatorSafeHashMapT* __pMap;
 408 };
 409
 410 /**
 411 * @class        _CameraCoordinatorSafeHashMapT
 412 * @brief        This class is for handling safe HashMap.
 413 *
 414 */
 415 class _CameraCoordinatorSafeHashMapT
 416         : public Tizen::Base::Collection::HashMapT<_CameraDeviceType, _CameraCoordinator*>
 417         , public virtual Tizen::Base::Collection::ICollectionT <Tizen::Base::Collection::MapEntryT <_CameraDeviceType, _CameraCoordinator*> >
 418 {
 419 public:
 420         _CameraCoordinatorSafeHashMapT(void);
 421         virtual ~_CameraCoordinatorSafeHashMapT(void);
 422         void RemoveItems(void);
 423
 424 private:
 425         _CameraCoordinatorSafeHashMapT(const _CameraCoordinatorSafeHashMapT& rhs);
 426         _CameraCoordinatorSafeHashMapT& operator =(const _CameraCoordinatorSafeHashMapT& rhs);
 427 };
 428
 429 }}
 430 #endif