[Camera] Add internal constructor (#3489)

* [Camera] Add internal constructor and code clean

diff --git a/src/Tizen.Multimedia.Camera/Camera/Camera.cs b/src/Tizen.Multimedia.Camera/Camera/Camera.cs
index 9b14096..2f26aae 100644 (file)
--- a/src/Tizen.Multimedia.Camera/Camera/Camera.cs
+++ b/src/Tizen.Multimedia.Camera/Camera/Camera.cs
@@ -59,8 +59,26 @@ namespace Tizen.Multimedia
         {
             ValidationUtil.ValidateEnum(typeof(CameraDevice), device, nameof(device));
 
-            Create(device);
+            CreateCameraDevice(device);
 
+            Initialize();
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Camera"/> class.
+        /// </summary>
+        /// <remarks>CameraDevice and Type will be selected internally by CameraDeviceManager.</remarks>
+        /// <exception cref="InvalidOperationException">In case of any invalid operations.</exception>
+        /// <exception cref="NotSupportedException">The camera feature is not supported.</exception>
+        /// <since_tizen> 9 </since_tizen>
+        /// <feature> http://tizen.org/feature/camera </feature>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public Camera() : this(CameraDevice.Default)
+        {
+        }
+
+        private void Initialize()
+        {
             Capabilities = new CameraCapabilities(this);
             Settings = new CameraSettings(this);
             DisplaySettings = new CameraDisplaySettings(this);
@@ -70,39 +88,46 @@ namespace Tizen.Multimedia
             SetState(CameraState.Created);
         }
 
-        private void Create(CameraDevice device)
+        private void CreateCameraDevice(CameraDevice device)
         {
             CameraDeviceType cameraDeviceType = CameraDeviceType.BuiltIn;
+            CameraDevice cameraDevice = device;
 
-            try
+            if (device == CameraDevice.Default || CameraDeviceManager.IsSupported)
             {
-                using (var cameraDeviceManager = new CameraDeviceManager())
+                var deviceInfo = GetDeviceInformation();
+                if (!deviceInfo.Any())
                 {
-                    var deviceInfo = cameraDeviceManager.GetDeviceInformation();
-                    if (!deviceInfo.Any())
-                    {
-                        throw new InvalidOperationException("There's no available camera device.");
-                    }
-
-                    cameraDeviceType = deviceInfo.First().Type;
+                    throw new InvalidOperationException("CDM is supported but, there's no available camera device.");
                 }
+
+                cameraDeviceType = deviceInfo.First().Type;
+                cameraDevice = deviceInfo.First().Device;
+                Log.Debug(CameraLog.Tag, $"Type:[{cameraDeviceType}], Device:[{cameraDevice}]");
             }
-            catch (NotSupportedException e)
+
+            CreateNativeCameraDevice(cameraDeviceType, cameraDevice);
+        }
+
+        private IEnumerable<CameraDeviceInformation> GetDeviceInformation()
+        {
+            using (var cameraDeviceManager = new CameraDeviceManager())
             {
-                Log.Info(CameraLog.Tag,
-                    $"CameraDeviceManager is not supported. {e.Message}. Not error.");
+                return cameraDeviceManager.GetDeviceInformation();
             }
+        }
 
-            if (cameraDeviceType == CameraDeviceType.BuiltIn ||
-                cameraDeviceType == CameraDeviceType.Usb)
+        private void CreateNativeCameraDevice(CameraDeviceType type, CameraDevice device)
+        {
+            if (type == CameraDeviceType.BuiltIn || type == CameraDeviceType.Usb)
             {
                 Native.Create(device, out _handle).
-                    ThrowIfFailed($"Failed to create {cameraDeviceType.ToString()} camera");
+                    ThrowIfFailed($"Failed to create {type} camera");
             }
             else
             {
                 Native.CreateNetworkCamera(device, out _handle).
-                    ThrowIfFailed($"Failed to create {cameraDeviceType.ToString()} camera");
+                    ThrowIfFailed($"Failed to create {type} camera");
             }
         }
 

diff --git a/src/Tizen.Multimedia.Camera/Camera/CameraDeviceManager.cs b/src/Tizen.Multimedia.Camera/Camera/CameraDeviceManager.cs
index 995ef03..c087f51 100644 (file)
--- a/src/Tizen.Multimedia.Camera/Camera/CameraDeviceManager.cs
+++ b/src/Tizen.Multimedia.Camera/Camera/CameraDeviceManager.cs
@@ -83,6 +83,26 @@ namespace Tizen.Multimedia
             return GetDeviceInformation(deviceList);
         }
 
+        internal static bool IsSupported
+        {
+            get
+            {
+                try
+                {
+                    using (var cameraDeviceManager = new CameraDeviceManager())
+                    {
+                        return true;
+                    }
+                }
+                catch (NotSupportedException)
+                {
+                    Log.Info(CameraLog.Tag,
+                        $"CameraDeviceManager is not supported. Not error.");
+                }
+                return false;
+            }
+        }
+
         internal static IEnumerable<CameraDeviceInformation> GetDeviceInformation(Native.CameraDeviceListStruct list)
         {
             if (list.count == 0)

diff --git a/src/Tizen.Multimedia.Camera/Camera/CameraEnums.cs b/src/Tizen.Multimedia.Camera/Camera/CameraEnums.cs
index ca5a5b0..9c505bb 100644 (file)
--- a/src/Tizen.Multimedia.Camera/Camera/CameraEnums.cs
+++ b/src/Tizen.Multimedia.Camera/Camera/CameraEnums.cs
@@ -26,9 +26,15 @@ namespace Tizen.Multimedia
     public enum CameraDevice
     {
         /// <summary>
+        /// The CameraDevice will be decided internally by target policy.
+        /// </summary>
+        /// <since_tizen> 9 </since_tizen>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        Default = -1,
+        /// <summary>
         /// The rear camera device.
         /// </summary>
-        Rear,
+        Rear = 0,
         /// <summary>
         /// The front camera device.
         /// </summary>