--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+using System;
+
+namespace Tizen.Multimedia
+{
+ /// <summary>
+ /// The class containing area of the display.
+ /// </summary>
+ public class Area
+ {
+ /// <summary>
+ /// Constructor for area class.
+ /// </summary>
+ /// <param name="x">X coordinate</param>
+ /// <param name="y">Y coordinate</param>
+ /// <param name="width">Width of area</param>
+ /// <param name="height">Height of area</param>
+ public Area(int x, int y, int width, int height)
+ {
+ X = x;
+ Y = y;
+ Width = width;
+ Height = height;
+ }
+
+ /// <summary>
+ /// X coordinate of the area.
+ /// </summary>
+ public int X
+ {
+ get;
+ }
+
+ /// <summary>
+ /// Y coordinate of the area.
+ /// </summary>
+ public int Y
+ {
+ get;
+ }
+
+ /// <summary>
+ /// Width of area.
+ /// </summary>
+ public int Width
+ {
+ get;
+ }
+
+ /// <summary>
+ /// Height of area.
+ /// </summary>
+ public int Height
+ {
+ get;
+ }
+ }
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using Tizen.Internals.Errors;
+using Tizen.Multimedia;
+using System.IO;
+
+namespace Tizen.Multimedia
+{
+ static internal class CameraLog
+ {
+ internal const string Tag = "Tizen.Multimedia.Camera";
+ }
+
+ /// <summary>
+ /// The camera class provides methods to capture photos and support setting up notifications
+ /// for state changes of capturing, previewing, focusing, information about resolution and binary format
+ /// and functions for picture manipulations like sepia negative and many more.
+ /// It also notifies you when a significant picture parameter changes e.g. focus.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ public class Camera : IDisposable
+ {
+ private IntPtr _handle;
+ private bool _disposed = false;
+ private Interop.Camera.CapturingCallback _capturingCallback;
+ private Interop.Camera.CaptureCompletedCallback _captureCompletedCallback;
+ private Interop.Camera.FaceDetectedCallback _faceDetectedCallback;
+ private EventHandler<CameraErrorOccurredEventArgs> _cameraErrorOccurred;
+ private EventHandler<CameraStateChangedEventArgs> _cameraStateChanged;
+ private EventHandler<PreviewEventArgs> _preview;
+ private EventHandler<CameraFocusChangedEventArgs> _cameraFocusChanged;
+ private EventHandler<CameraInterruptedEventArgs> _cameraInterrupted;
+ private EventHandler<HdrCaptureProgressEventArgs> _hdrProgress;
+ private EventHandler<MediaPacketPreviewEventArgs> _mediaPacketPreview;
+ private readonly CameraFeature _cameraFeature;
+ private readonly CameraSetting _cameraSetting;
+ private readonly CameraDisplay _cameraDisplay;
+ private readonly List<FaceDetectedData> _faces = new List<FaceDetectedData>();
+
+ /// <summary>
+ /// Initializes a new instance of the <see cref="Tizen.Multimedia.Camera"/> Class.
+ /// </summary>
+ /// <param name="device">Device.</param>
+ public Camera(CameraDevice device)
+ {
+ int ret = Interop.Camera.Create((int)device, out _handle);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to create camera instance");
+ }
+
+ _cameraFeature = new CameraFeature(_handle);
+ _cameraSetting = new CameraSetting(_handle);
+ _cameraDisplay = new CameraDisplay(_handle);
+ }
+
+ /// <summary>
+ /// Destructor of the camera class.
+ /// </summary>
+ ~Camera()
+ {
+ Dispose(false);
+ }
+
+ /// <summary>
+ /// Event that occurs when there is change in HDR capture progress.
+ /// </summary>
+ public event EventHandler<HdrCaptureProgressEventArgs> HdrCaptureProgress
+ {
+ add
+ {
+ if (_hdrProgress == null)
+ {
+ Interop.Camera.HdrCaptureProgressCallback _hdrProgressCallback = (int percent, IntPtr userData) =>
+ {
+ HdrCaptureProgressEventArgs eventArgs = new HdrCaptureProgressEventArgs(percent);
+ _hdrProgress?.Invoke(this, eventArgs);
+ };
+ int ret = Interop.Camera.SetHdrCaptureProgressCallback(_handle, _hdrProgressCallback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Setting hdr progress callback failed");
+ }
+ }
+
+ _hdrProgress += value;
+ }
+
+ remove
+ {
+ _hdrProgress -= value;
+ if (_hdrProgress == null)
+ {
+ int ret = Interop.Camera.UnsetHdrCaptureProgressCallback(_handle);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Unsetting hdr progress callback failed");
+ }
+ }
+ }
+ }
+
+ /// <summary>
+ /// Event that occurs during capture of image.
+ /// </summary>
+ public event EventHandler<CapturingEventArgs> Capturing;
+
+ /// <summary>
+ /// Event that occurs after the capture of the image.
+ /// </summary>
+ public event EventHandler<EventArgs> CaptureCompleted;
+
+ /// <summary>
+ /// Event that occurs when camera state is changed.
+ /// </summary>
+ public event EventHandler<CameraStateChangedEventArgs> CameraStateChanged
+ {
+ add
+ {
+ if (_cameraStateChanged == null)
+ {
+ Interop.Camera.StateChangedCallback _stateChangedCallback = (CameraState previous, CameraState current, bool byPolicy, IntPtr userData) =>
+ {
+ CameraStateChangedEventArgs eventArgs = new CameraStateChangedEventArgs(previous, current, byPolicy);
+ _cameraStateChanged?.Invoke(this, eventArgs);
+ };
+ int ret = Interop.Camera.SetStateChangedCallback(_handle, _stateChangedCallback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Setting state changed callback failed");
+ }
+ }
+
+ _cameraStateChanged += value;
+ }
+
+ remove
+ {
+ _cameraStateChanged -= value;
+ if (_cameraStateChanged == null)
+ {
+ int ret = Interop.Camera.UnsetStateChangedCallback(_handle);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Unsetting state changed callback failed");
+ }
+ }
+ }
+ }
+
+ /// <summary>
+ /// Event that occurs when the auto-focus state of camera changes.
+ /// </summary>
+ public event EventHandler<CameraFocusChangedEventArgs> CameraFocusChanged
+ {
+ add
+ {
+ if (_cameraFocusChanged == null)
+ {
+ Interop.Camera.FocusChangedCallback _focusCallback = (CameraFocusState state, IntPtr userData) =>
+ {
+ CameraFocusChangedEventArgs eventArgs = new CameraFocusChangedEventArgs(state);
+ _cameraFocusChanged?.Invoke(this, eventArgs);
+ };
+ int ret = Interop.Camera.SetFocusChangedCallback(_handle, _focusCallback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Setting focus changed callback failed");
+ }
+ }
+
+ _cameraFocusChanged += value;
+ }
+
+ remove
+ {
+ _cameraFocusChanged -= value;
+ if (_cameraFocusChanged == null)
+ {
+ int ret = Interop.Camera.UnsetFocusChangedCallback(_handle);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Unsetting focus changed callback failed");
+ }
+ }
+ }
+ }
+
+ /// <summary>
+ /// Event that occurs when an camera is interrupted by policy.
+ /// </summary>
+ public event EventHandler<CameraInterruptedEventArgs> CameraInterrupted
+ {
+ add
+ {
+ if (_cameraInterrupted == null)
+ {
+ Interop.Camera.InterruptedCallback _interruptedCallback = (CameraPolicy policy, CameraState previous, CameraState current, IntPtr userData) =>
+ {
+ CameraInterruptedEventArgs eventArgs = new CameraInterruptedEventArgs(policy, previous, current);
+ _cameraInterrupted?.Invoke(this, eventArgs);
+ };
+ int ret = Interop.Camera.SetInterruptedCallback(_handle, _interruptedCallback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Setting interrupt callback failed");
+ }
+ }
+
+ _cameraInterrupted += value;
+ }
+
+ remove
+ {
+ _cameraInterrupted -= value;
+ if (_cameraInterrupted == null)
+ {
+ int ret = Interop.Camera.UnsetInterruptedCallback(_handle);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Unsetting interrupt callback failed");
+ }
+ }
+ }
+ }
+
+ /// <summary>
+ /// Event that occurs when there is an asynchronous error.
+ /// </summary>
+ public event EventHandler<CameraErrorOccurredEventArgs> CameraErrorOccurred
+ {
+ add
+ {
+ if (_cameraErrorOccurred == null)
+ {
+ Interop.Camera.ErrorCallback _errorCallback = (CameraErrorCode error, CameraState current, IntPtr userData) =>
+ {
+ CameraErrorOccurredEventArgs eventArgs = new CameraErrorOccurredEventArgs(error, current);
+ _cameraErrorOccurred?.Invoke(this, eventArgs);
+ };
+ int ret = Interop.Camera.SetErrorCallback(_handle, _errorCallback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Setting error callback failed");
+ }
+ }
+
+ _cameraErrorOccurred += value;
+ }
+
+ remove
+ {
+ _cameraErrorOccurred -= value;
+ if (_cameraErrorOccurred == null)
+ {
+ int ret = Interop.Camera.UnsetErrorCallback(_handle);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Unsetting error callback failed");
+ }
+ }
+ }
+ }
+
+ /// <summary>
+ /// Event that occurs when a face is detected in preview frame.
+ /// </summary>
+ public event EventHandler<FaceDetectedEventArgs> FaceDetected;
+
+ /// <summary>
+ /// Event that occurs once per frame when previewing.
+ /// </summary>
+ public event EventHandler<PreviewEventArgs> Preview
+ {
+ add
+ {
+ if (_preview == null)
+ {
+ CreatePreviewCallback();
+ }
+
+ _preview += value;
+ }
+
+ remove
+ {
+ _preview -= value;
+ if (_preview == null)
+ {
+ int ret = Interop.Camera.UnsetPreviewCallback(_handle);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Unsetting preview callback failed");
+ }
+ }
+ }
+ }
+
+ /// <summary>
+ /// Event that occurs once per frame when previewing.
+ /// </summary>
+ public event EventHandler<MediaPacketPreviewEventArgs> MediaPacketPreview
+ {
+ add
+ {
+ if (_mediaPacketPreview == null)
+ {
+ CreateMediaPacketPreviewCallback();
+ }
+
+ _mediaPacketPreview += value;
+ }
+
+ remove
+ {
+ _mediaPacketPreview -= value;
+ if (_mediaPacketPreview == null)
+ {
+ int ret = Interop.Camera.UnsetMediaPacketPreviewCallback(_handle);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Unsetting media packet preview callback failed");
+ }
+ }
+ }
+ }
+
+ /// <summary>
+ /// Get/Set the various camera settings.
+ /// </summary>
+ public CameraSetting Setting
+ {
+ get
+ {
+ return _cameraSetting;
+ }
+ }
+
+ /// <summary>
+ /// Gets the various camera features.
+ /// </summary>
+ public CameraFeature Feature
+ {
+ get
+ {
+ return _cameraFeature;
+ }
+ }
+
+ /// <summary>
+ /// Get/set various camera display properties.
+ /// </summary>
+ public CameraDisplay Display
+ {
+ get
+ {
+ return _cameraDisplay;
+ }
+ }
+
+ /// <summary>
+ /// Gets the state of the camera.
+ /// </summary>
+ public CameraState State
+ {
+ get
+ {
+ int val = 0;
+
+ int ret = Interop.Camera.GetState(_handle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera state, " + (CameraError)ret);
+ }
+
+ return (CameraState)val;
+ }
+ }
+
+ /// <summary>
+ /// The hint for display reuse.
+ /// If the hint is set to true, the display will be reused when the camera device is changed with
+ /// ChangeDevice method.
+ /// </summary>
+ /// <exception cref="ArgumentException">In case of invalid parameters</exception>
+ public bool DisplayReuseHint
+ {
+ get
+ {
+ bool val = false;
+
+ int ret = Interop.Camera.GetDisplayReuseHint(_handle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera display reuse hint, " + (CameraError)ret);
+ }
+
+ return val;
+ }
+
+ set
+ {
+ int ret = Interop.Camera.SetDisplayReuseHint(_handle, value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set display reuse hint, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set display reuse hint.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// Resolution of the preview.
+ /// </summary>
+ /// <remarks>
+ /// This should be called before StartPreview Method
+ /// </remarks>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ /// <exception cref="ArgumentException">In case of invalid parameters</exception>
+ public CameraResolution PreviewResolution
+ {
+ get
+ {
+ int width = 0;
+ int height = 0;
+ int ret = Interop.Camera.GetPreviewResolution(_handle, out width, out height);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera preview resolution, " + (CameraError)ret);
+ }
+
+ CameraResolution res = new CameraResolution(width, height);
+ return res;
+ }
+
+ set
+ {
+ CameraResolution res = value;
+ int ret = Interop.Camera.SetPreviewResolution(_handle, res.Width, res.Height);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set preview resolution, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set preview resolution.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// Gets the recommended preview resolution.
+ /// </summary>
+ /// <remarks>
+ /// Depending on the capture resolution aspect ratio and display resolution,
+ /// the recommended preview resolution is determined.
+ /// </remarks>
+ public CameraResolution RecommendedPreviewResolution
+ {
+ get
+ {
+ int width = 0;
+ int height = 0;
+ int ret = Interop.Camera.GetRecommendedPreviewResolution(_handle, out width, out height);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get recommended preview resolution, " + (CameraError)ret);
+ }
+
+ CameraResolution res = new CameraResolution(width, height);
+ return res;
+ }
+ }
+
+ /// <summary>
+ /// Resolution of the captured image.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ /// <exception cref="ArgumentException">In case of invalid parameters</exception>
+ public CameraResolution CaptureResolution
+ {
+ get
+ {
+ int width = 0;
+ int height = 0;
+ int ret = Interop.Camera.GetCaptureResolution(_handle, out width, out height);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera capture resolution, " + (CameraError)ret);
+ }
+
+ CameraResolution res = new CameraResolution(width, height);
+ return res;
+ }
+
+ set
+ {
+ CameraResolution res = value;
+ int ret = Interop.Camera.SetCaptureResolution(_handle, res.Width, res.Height);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set capture resolution, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set capture resolution.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// Format of an image to be captured.
+ /// </summary>
+ /// <exception cref="ArgumentException">In case of invalid parameters</exception>
+ public CameraPixelFormat CaptureFormat
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.Camera.GetCaptureFormat(_handle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera capture format, " + (CameraError)ret);
+ }
+
+ return (CameraPixelFormat)val;
+ }
+
+ set
+ {
+ int ret = Interop.Camera.SetCaptureFormat(_handle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set capture format, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set capture format.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The preview data format.
+ /// </summary>
+ /// <exception cref="ArgumentException">In case of invalid parameters</exception>
+ public CameraPixelFormat PreviewFormat
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.Camera.GetPreviewFormat(_handle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get preview format, " + (CameraError)ret);
+ }
+
+ return (CameraPixelFormat)val;
+ }
+
+ set
+ {
+ int ret = Interop.Camera.SetPreviewFormat(_handle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set preview format, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set preview format.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// Gets the facing direction of camera module.
+ /// </summary>
+ public CameraFacingDirection Direction
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.Camera.GetFacingDirection(_handle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera direction, " + (CameraError)ret);
+ }
+
+ return (CameraFacingDirection)val;
+ }
+ }
+
+ /// <summary>
+ /// Gets the camera's flash state.
+ /// </summary>
+ public CameraFlashState FlashState
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.Camera.GetFlashState(_handle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera flash state, " + (CameraError)ret);
+ }
+
+ return (CameraFlashState)val;
+ }
+ }
+
+ /// <summary>
+ /// Gets the camera device count.
+ /// </summary>
+ /// <remarks>
+ /// If the device supports primary and secondary camera, this returns 2.
+ /// If 1 is returned, the device only supports primary camera.
+ /// </remarks>
+ public int CameraCount
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.Camera.GetDeviceCount(_handle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera device count, " + (CameraError)ret);
+ }
+
+ return val;
+ }
+ }
+
+ /// <summary>
+ /// Changes the camera device.
+ /// </summary>
+ /// <param name="device">The hardware camera to access.</param>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ /// <remarks>
+ /// This method can be used to change camera device without using destory and create method.
+ /// If display reuse is set using <see cref="Tizen.Multimedia.Camera.DisplayReuseHint"/>
+ /// before stopping the preview, display handle will be reused and last frame on display
+ /// can be kept even though cameradevice is changed.
+ /// </remarks>
+ /// <exception cref="ArgumentException">In case of invalid parameters</exception>
+ /// <exception cref="InvalidOperationException">In case of any invalid operations</exception>
+ /// <exception cref="NotSupportedException">In case of ChangeDevice feature is not supported</exception>
+ public void ChangeDevice(CameraDevice device)
+ {
+ int ret = Interop.Camera.ChangeDevice(_handle, (int)device);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to change the camera device");
+ }
+ }
+
+ /// <summary>
+ /// Gets the device state.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ /// <param name="device">The device to get state.</param>
+ /// <returns>Returns the camera's horizontal position</returns>
+ /// <exception cref="ArgumentException">In case of invalid parameters</exception>
+ /// <exception cref="InvalidOperationException">In case of any invalid operations</exception>
+ /// <exception cref="NotSupportedException">In case of this feature is not supported</exception>
+ public CameraDeviceState GetDeviceState(CameraDevice device)
+ {
+ int val = 0;
+ int ret = Interop.Camera.GetDeviceState(device, out val);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to get the camera device state.");
+ }
+
+ return (CameraDeviceState)ret;
+ }
+
+ /// <summary>
+ /// Starts capturing and drawing preview frames on the screen.
+ /// The display handle must be set using <see cref="Tizen.Multimedia.Camera.SetDisplay"/>
+ /// before using this method.
+ /// If needed set fps <see cref="Tizen.Multimedia.CameraSetting.PreviewFps"/>, preview resolution
+ /// <see cref="Tizen.Multimedia.Camera.PreviewResolution"/>, or preview format <see cref="Tizen.Multimedia.Camera.PreviewFormat"/>
+ /// before using this method.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ /// <exception cref="ArgumentException">In case of invalid parameters</exception>
+ /// <exception cref="InvalidOperationException">In case of any invalid operations</exception>
+ /// <exception cref="NotSupportedException">In case of this feature is not supported</exception>
+ /// <exception cref="UnauthorizedAccessException">In case of access to the resources cannot be granted</exception>
+ public void StartPreview()
+ {
+ int ret = Interop.Camera.StartPreview(_handle);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to start the camera preview.");
+ }
+ }
+
+ /// <summary>
+ /// Stops capturing and drawing preview frames on the screen.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ /// <exception cref="ArgumentException">In case of invalid parameters</exception>
+ /// <exception cref="InvalidOperationException">In case of any invalid operations</exception>
+ /// <exception cref="NotSupportedException">In case of this feature is not supported</exception>
+ /// <exception cref="UnauthorizedAccessException">In case of access to the resources cannot be granted</exception>
+ public void StopPreview()
+ {
+ int ret = Interop.Camera.StopPreview(_handle);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to stop the camera preview.");
+ }
+ }
+
+ /// <summary>
+ /// Starts capturing of still images.
+ /// EventHandler must be set for capturing using <see cref="Tizen.Multimedia.Camera.Capturing"/>
+ /// and for completed using <see cref="Tizen.Multimedia.Camera.CaptureCompleted"/> before
+ /// calling this method.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ /// <remarks>
+ /// This function causes the transition of the camera state from Capturing to Captured
+ /// automatically and the corresponding EventHandlers will be invoked.
+ /// The camera's preview should be restarted by calling <see cref="Tizen.Multimedia.Camera.StartPreview"/>
+ /// method.
+ /// </remarks>
+ /// <exception cref="ArgumentException">In case of invalid parameters</exception>
+ /// <exception cref="InvalidOperationException">In case of any invalid operations</exception>
+ /// <exception cref="NotSupportedException">In case of this feature is not supported</exception>
+ /// <exception cref="UnauthorizedAccessException">In case of access to the resources cannot be granted</exception>
+ public void StartCapture()
+ {
+ _capturingCallback = (IntPtr image, IntPtr postview, IntPtr thumbnail, IntPtr userData) =>
+ {
+ Interop.Camera.ImageDataStruct _img = Interop.Camera.IntPtrToImageDataStruct(image);
+ Interop.Camera.ImageDataStruct _post = Interop.Camera.IntPtrToImageDataStruct(postview);
+ Interop.Camera.ImageDataStruct _thumb = Interop.Camera.IntPtrToImageDataStruct(thumbnail);
+ ImageData img = new ImageData();
+ ImageData post = new ImageData();
+ ImageData thumb = new ImageData();
+ CopyImageData(img, _img);
+ CopyImageData(img, _post);
+ CopyImageData(thumb, _thumb);
+
+ CapturingEventArgs eventArgs = new CapturingEventArgs(img, post, thumb);
+ Capturing?.Invoke(this, eventArgs);
+ };
+
+ _captureCompletedCallback = (IntPtr userData) =>
+ {
+ EventArgs eventArgs = new EventArgs();
+ CaptureCompleted?.Invoke(this, eventArgs);
+ };
+
+ int ret = Interop.Camera.StartCapture(_handle, _capturingCallback, _captureCompletedCallback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to start the camera capture.");
+ }
+ }
+
+ /// <summary>
+ /// Aborts continuous capturing.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ /// <exception cref="ArgumentException">In case of invalid parameters</exception>
+ /// <exception cref="InvalidOperationException">In case of any invalid operations</exception>
+ /// <exception cref="NotSupportedException">In case of this feature is not supported</exception>
+ /// <exception cref="UnauthorizedAccessException">In case of access to the resources cannot be granted</exception>
+ public void StopContinuousCapture()
+ {
+ int ret = Interop.Camera.StopContinuousCapture(_handle);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to stop the continuous capture.");
+ }
+ }
+
+ /// <summary>
+ /// Starts continuously capturing still images.
+ /// EventHandler must be set for capturing using <see cref="Tizen.Multimedia.Camera.Capturing"/>
+ /// and for completed using <see cref="Tizen.Multimedia.Camera.CaptureCompleted"/> before
+ /// calling this method.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ /// <param name="count">The number of still images.</param>
+ /// <param name="interval">The interval of the capture(milliseconds).</param>
+ /// <remarks>
+ /// If this is not supported zero shutter lag occurs. The capture resolution could be
+ /// changed to the preview resolution. This function causes the transition of the camera state
+ /// from Capturing to Captured automatically and the corresponding Eventhandlers will be invoked.
+ /// Each captured image will be delivered through Eventhandler set using <see cref="Tizen.Multimedia.Camera.Capturing"/> event.
+ /// The camera's preview should be restarted by calling <see cref="Tizen.Multimedia.Camera.StartPreview"/> method.
+ /// </remarks>
+ /// <exception cref="ArgumentException">In case of invalid parameters</exception>
+ /// <exception cref="InvalidOperationException">In case of any invalid operations</exception>
+ /// <exception cref="NotSupportedException">In case of this feature is not supported</exception>
+ /// <exception cref="UnauthorizedAccessException">In case of access to the resources cannot be granted</exception>
+ public void StartContinuousCapture(int count, int interval)
+ {
+ _capturingCallback = (IntPtr image, IntPtr postview, IntPtr thumbnail, IntPtr userData) =>
+ {
+ Interop.Camera.ImageDataStruct _img = Interop.Camera.IntPtrToImageDataStruct(image);
+ Interop.Camera.ImageDataStruct _post = Interop.Camera.IntPtrToImageDataStruct(postview);
+ Interop.Camera.ImageDataStruct _thumb = Interop.Camera.IntPtrToImageDataStruct(thumbnail);
+ ImageData img = new ImageData();
+ ImageData post = new ImageData();
+ ImageData thumb = new ImageData();
+ CopyImageData(img, _img);
+ CopyImageData(img, _post);
+ CopyImageData(thumb, _thumb);
+
+ CapturingEventArgs eventArgs = new CapturingEventArgs(img, post, thumb);
+ Capturing?.Invoke(this, eventArgs);
+ };
+
+ _captureCompletedCallback = (IntPtr userData) =>
+ {
+ EventArgs eventArgs = new EventArgs();
+ CaptureCompleted?.Invoke(this, eventArgs);
+ };
+
+ int ret = Interop.Camera.StartContinuousCapture(_handle, count, interval, _capturingCallback, _captureCompletedCallback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to start the continuous capture.");
+ }
+ }
+
+ /// <summary>
+ /// Sets the display handle to show preview images.
+ /// </summary>
+ /// <param name="displayType">Display type.</param>
+ /// <param name="preview">MediaView object to display preview.</param>
+ /// <remarks>
+ /// This method must be called before StartPreview() method.
+ /// In Custom ROI display mode, DisplayRoiArea property must be set before calling this method.
+ /// </remarks>
+ /// <exception cref="ArgumentException">In case of invalid parameters</exception>
+ /// <exception cref="InvalidOperationException">In case of any invalid operations</exception>
+ /// <exception cref="NotSupportedException">In case of this feature is not supported</exception>
+ /// <exception cref="UnauthorizedAccessException">In case of access to the resources cannot be granted</exception>
+ public void SetDisplay(CameraDisplayType displayType, MediaView preview)
+ {
+ int ret = Interop.Camera.SetDisplay(_handle, (int)displayType, preview);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to set the camera display.");
+ }
+ }
+
+ /// <summary>
+ /// Starts camera auto-focusing, asynchronously.
+ /// </summary>
+ /// <param name="continuous">Continuous.</param>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ /// <remarks>
+ /// If continuous status is true, the camera continuously tries to focus.
+ /// </remarks>
+ /// <exception cref="ArgumentException">In case of invalid parameters</exception>
+ /// <exception cref="InvalidOperationException">In case of any invalid operations</exception>
+ /// <exception cref="NotSupportedException">In case of this feature is not supported</exception>
+ /// <exception cref="UnauthorizedAccessException">In case of access to the resources cannot be granted</exception>
+ public void StartFocusing(bool continuous)
+ {
+ int ret = Interop.Camera.StartFocusing(_handle, continuous);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to cancel the camera focus.");
+ }
+ }
+
+ /// <summary>
+ /// Stops camera auto focusing.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ /// <exception cref="ArgumentException">In case of invalid parameters</exception>
+ /// <exception cref="InvalidOperationException">In case of any invalid operations</exception>
+ /// <exception cref="NotSupportedException">In case of this feature is not supported</exception>
+ /// <exception cref="UnauthorizedAccessException">In case of access to the resources cannot be granted</exception>
+ public void CancelFocusing()
+ {
+ int ret = Interop.Camera.CancelFocusing(_handle);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to cancel the camera focus.");
+ }
+ }
+
+ /// <summary>
+ /// Starts face detection.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ /// <remarks>
+ /// This should be called after <see cref="Tizen.Multimedia.Camera.StartPreview"/> is started.
+ /// The Eventhandler set using <see cref="Tizen.Multimedia.Camera.FaceDetected"/> invoked when the face is detected in preview frame.
+ /// Internally it starts continuous focus and focusing on the detected face.
+ /// </remarks>
+ /// <exception cref="ArgumentException">In case of invalid parameters</exception>
+ /// <exception cref="InvalidOperationException">In case of any invalid operations</exception>
+ /// <exception cref="NotSupportedException">In case of this feature is not supported</exception>
+ /// <exception cref="UnauthorizedAccessException">In case of access to the resources cannot be granted</exception>
+ public void StartFaceDetection()
+ {
+ _faceDetectedCallback = (IntPtr faces, int count, IntPtr userData) =>
+ {
+ Interop.Camera.DetectedFaceStruct[] faceStruct = new Interop.Camera.DetectedFaceStruct[count];
+ IntPtr current = faces;
+ for (int i = 0; i < count; i++)
+ {
+ Marshal.PtrToStructure(current, faceStruct[i]);
+ FaceDetectedData face = new FaceDetectedData(faceStruct[i].id, faceStruct[i].score, faceStruct[i].x, faceStruct[i].y, faceStruct[i].width, faceStruct[i].height);
+ _faces.Add(face);
+ current = (IntPtr)((long)current + Marshal.SizeOf(faceStruct[i]));
+ }
+
+ FaceDetectedEventArgs eventArgs = new FaceDetectedEventArgs(_faces);
+ FaceDetected?.Invoke(this, eventArgs);
+ };
+
+ int ret = Interop.Camera.StartFaceDetection(_handle, _faceDetectedCallback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to start the face detection.");
+ }
+ }
+
+ /// <summary>
+ /// Stops face detection.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ /// <exception cref="ArgumentException">In case of invalid parameters</exception>
+ /// <exception cref="InvalidOperationException">In case of any invalid operations</exception>
+ /// <exception cref="NotSupportedException">In case of this feature is not supported</exception>
+ /// <exception cref="UnauthorizedAccessException">In case of access to the resources cannot be granted</exception>
+ public void StopFaceDetection()
+ {
+ int ret = Interop.Camera.StopFaceDetection(_handle);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to stop the face detection.");
+ }
+ }
+
+ /// <summary>
+ /// DeviceChangedCallback delegate.
+ /// </summary>
+ public delegate void DeviceChangedCallback(CameraDevice device, CameraDeviceState state, IntPtr userData);
+
+ /// <summary>
+ /// set the DeviceStateChanged Callback.
+ /// </summary>
+ /// <param name="callback">Callback of type <see cref="Tizen.Multimedia.Camera.DeviceChangedCallback"/>.</param>
+ /// <param name="callbackId">The Id of registered callback.</param>
+ /// <exception cref="InvalidOperationException">In case of any invalid operations</exception>
+ /// <exception cref="NotSupportedException">In case of this feature is not supported</exception>
+ /// <exception cref="ArgumentException">In case of invalid parameters</exception>
+ public static void SetDeviceStateChangedCallback(DeviceChangedCallback callback, out int callbackId)
+ {
+ int ret = Camera.AddDeviceChangedCallback(callback, IntPtr.Zero, out callbackId);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Setting device state changed callback failed");
+ }
+ }
+
+ /// <summary>
+ /// Unset the DeviceStateChanged Callback.
+ /// </summary>
+ /// <param name="callbackId">Registered callbackId to be deleted.</param>
+ /// <exception cref="InvalidOperationException">In case of any invalid operations</exception>
+ /// <exception cref="NotSupportedException">In case of this feature is not supported</exception>
+ /// <exception cref="ArgumentException">In case of invalid parameters</exception>
+ public static void UnsetDeviceStateChangedCallback(int callbackId)
+ {
+ int ret = Interop.Camera.UnsetDeviceStateChangedCallback(callbackId);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Unsetting device state changed callback failed");
+ }
+ }
+
+ /// <summary>
+ /// Release any unmanaged resources used by this object.
+ /// </summary>
+ public void Dispose()
+ {
+ Dispose(true);
+ GC.SuppressFinalize(this);
+ }
+
+ protected virtual void Dispose(bool disposing)
+ {
+ if (!_disposed)
+ {
+ if (disposing)
+ {
+ // to be used if there are any other disposable objects
+ }
+
+ if (_handle != IntPtr.Zero)
+ {
+ Interop.Camera.Destroy(_handle);
+ _handle = IntPtr.Zero;
+ }
+
+ _disposed = true;
+ }
+ }
+
+ [DllImport(Interop.Libraries.Camera, EntryPoint = "camera_add_device_state_changed_cb")]
+ internal static extern int AddDeviceChangedCallback(DeviceChangedCallback callback, IntPtr userData, out int callbackId);
+
+ internal static void CopyImageData(ImageData image, Interop.Camera.ImageDataStruct img)
+ {
+ image._data = new byte[img.size];
+ Marshal.Copy(img.data, image._data, 0, (int)img.size);
+ image._width = img.width;
+ image._height = img.height;
+ image._format = img.format;
+ image._exif = new byte[img.exifSize];
+ Marshal.Copy(img.exif, image._exif, 0, (int)img.exifSize);
+ }
+
+ internal static PreviewData CopyPreviewData(Interop.Camera.CameraPreviewDataStruct previewStruct, PlaneType type)
+ {
+ if (type == PlaneType.SinglePlane)
+ {
+ SinglePlaneData singleData = new SinglePlaneData();
+ singleData.Format = previewStruct.format;
+ singleData.Height = previewStruct.height;
+ singleData.TimeStamp = previewStruct.timestamp;
+ singleData.Width = previewStruct.width;
+ Interop.Camera.SinglePlane singlePlane = previewStruct.frameData.singlePlane;
+ singleData.YUVData = new byte[singlePlane.yuvsize];
+ Marshal.Copy(singlePlane.yuv, singleData.YUVData, 0, (int)singlePlane.yuvsize);
+ return singleData;
+ }
+ else if (type == PlaneType.DoublePlane)
+ {
+ DoublePlaneData doubleData = new DoublePlaneData();
+ doubleData.Format = previewStruct.format;
+ doubleData.Height = previewStruct.height;
+ doubleData.TimeStamp = previewStruct.timestamp;
+ doubleData.Width = previewStruct.width;
+ Interop.Camera.DoublePlane doublePlane = previewStruct.frameData.doublePlane;
+ doubleData.YData = new byte[doublePlane.ysize];
+ doubleData.UVData = new byte[doublePlane.uvsize];
+ Marshal.Copy(doublePlane.y, doubleData.YData, 0, (int)doublePlane.ysize);
+ Marshal.Copy(doublePlane.uv, doubleData.UVData, (int)doublePlane.ysize, (int)doublePlane.uvsize);
+ return doubleData;
+ }
+ else if (type == PlaneType.TriplePlane)
+ {
+ TriplePlaneData tripleData = new TriplePlaneData();
+ tripleData.Format = previewStruct.format;
+ tripleData.Height = previewStruct.height;
+ tripleData.TimeStamp = previewStruct.timestamp;
+ tripleData.Width = previewStruct.width;
+ Interop.Camera.TriplePlane triplePlane = previewStruct.frameData.triplePlane;
+ tripleData.YData = new byte[triplePlane.ysize];
+ tripleData.UData = new byte[triplePlane.usize];
+ tripleData.VData = new byte[triplePlane.vsize];
+ Marshal.Copy(triplePlane.y, tripleData.YData, 0, (int)triplePlane.ysize);
+ Marshal.Copy(triplePlane.u, tripleData.UData, (int)triplePlane.ysize, (int)triplePlane.usize);
+ Marshal.Copy(triplePlane.v, tripleData.VData, (int)(triplePlane.ysize + triplePlane.usize), (int)triplePlane.vsize);
+ return tripleData;
+ }
+ else
+ {
+ EncodedPlaneData encodedData = new EncodedPlaneData();
+ encodedData.Format = previewStruct.format;
+ encodedData.Height = previewStruct.height;
+ encodedData.TimeStamp = previewStruct.timestamp;
+ encodedData.Width = previewStruct.width;
+ Interop.Camera.EncodedPlane encodedPlane = previewStruct.frameData.encodedPlane;
+ encodedData.Data = new byte[encodedPlane.size];
+ Marshal.Copy(encodedPlane.data, encodedData.Data, 0, (int)encodedPlane.size);
+ return encodedData;
+ }
+ }
+
+ private void CreatePreviewCallback()
+ {
+ Interop.Camera.PreviewCallback _previewCallback = (IntPtr frame, IntPtr userData) =>
+ {
+ Interop.Camera.CameraPreviewDataStruct _previewStruct = Interop.Camera.IntPtrToCameraPreviewDataStruct(frame);
+ PlaneType _type = PlaneType.SinglePlane;
+ PreviewData _previewData = new PreviewData();
+
+ if (_previewStruct.format == CameraPixelFormat.H264 || _previewStruct.format == CameraPixelFormat.Jpeg)
+ {
+ _type = PlaneType.EncodedPlane;
+ _previewData = CopyPreviewData(_previewStruct, _type);
+ }
+ else
+ {
+ if (_previewStruct.numOfPlanes == 1)
+ {
+ _type = PlaneType.SinglePlane;
+ _previewData = CopyPreviewData(_previewStruct, _type);
+ }
+ else if (_previewStruct.numOfPlanes == 2)
+ {
+ _type = PlaneType.DoublePlane;
+ _previewData = CopyPreviewData(_previewStruct, _type);
+ }
+ else if (_previewStruct.numOfPlanes == 3)
+ {
+ _type = PlaneType.TriplePlane;
+ _previewData = CopyPreviewData(_previewStruct, _type);
+ }
+ }
+
+ PreviewEventArgs eventArgs = new PreviewEventArgs(_previewData, _type);
+ _preview?.Invoke(this, eventArgs);
+ };
+
+ int ret = Interop.Camera.SetPreviewCallback(_handle, _previewCallback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Setting preview callback failed");
+ }
+ }
+
+ private void CreateMediaPacketPreviewCallback()
+ {
+ Interop.Camera.MediaPacketPreviewCallback _mediaPacketCallback = (IntPtr mediaPacket, IntPtr userData) =>
+ {
+ MediaPacket packet = MediaPacket.From(mediaPacket);
+
+ MediaPacketPreviewEventArgs eventArgs = new MediaPacketPreviewEventArgs(packet);
+ _mediaPacketPreview?.Invoke(this, eventArgs);
+ };
+
+ int ret = Interop.Camera.SetMediaPacketPreviewCallback(_handle, _mediaPacketCallback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Setting media packet preview callback failed");
+ }
+ }
+ }
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+using System;
+
+namespace Tizen.Multimedia
+{
+ /// <summary>
+ /// The CameraDisplay class allows you to manage display for the camera.
+ /// It allows to set and get various display properties such as
+ /// rotation, display visibility and display mode.
+ /// </summary>
+ public class CameraDisplay
+ {
+ internal readonly IntPtr _displayHandle;
+
+ internal CameraDisplay(IntPtr handle)
+ {
+ _displayHandle = handle;
+ }
+
+ /// <summary>
+ /// The display rotation.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera.
+ /// </privilege>
+ public CameraRotation Rotation
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.CameraDisplay.GetDisplayRotation(_displayHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get display rotation " + (CameraError)ret);
+ }
+
+ return (CameraRotation)val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraDisplay.SetDisplayRotation(_displayHandle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set display rotation, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set display rotation.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The display flip.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera.
+ /// </privilege>
+ public CameraFlip Flip
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.CameraDisplay.GetDisplayFlip(_displayHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get display flip, " + (CameraError)ret);
+ }
+
+ return (CameraFlip)val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraDisplay.SetDisplayFlip(_displayHandle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set display flip, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set display flip.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The display mode.
+ /// </summary>
+ public CameraDisplayMode Mode
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.CameraDisplay.GetDisplayMode(_displayHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera display mode, " + (CameraError)ret);
+ }
+
+ return (CameraDisplayMode)val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraDisplay.SetDisplayMode(_displayHandle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set camera display mode, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set camera display mode.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The display visibility.
+ /// True if camera display visible, otherwise false.
+ /// </summary>
+ public bool Visible
+ {
+ get
+ {
+ bool val = false;
+ int ret = Interop.CameraDisplay.GetDisplayVisible(_displayHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get visible value, " + (CameraError)ret);
+ }
+
+ return val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraDisplay.SetDisplayVisible(_displayHandle, (bool)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set display visible, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set display visible.");
+ }
+ }
+ }
+ }
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+using System;
+
+namespace Tizen.Multimedia
+{
+ /// <summary>
+ /// Enumeration for Camera device.
+ /// </summary>
+ public enum CameraDevice
+ {
+ /// <summary>
+ /// Rear Camera device.
+ /// </summary>
+ Rear,
+ /// <summary>
+ /// Front Camera device.
+ /// </summary>
+ Front
+ }
+
+ /// <summary>
+ /// Enumeration for Camera device state.
+ /// </summary>
+ public enum CameraDeviceState
+ {
+ /// <summary>
+ /// Not opened.
+ /// </summary>
+ Null,
+ /// <summary>
+ /// Opened.
+ /// </summary>
+ Opened,
+ /// <summary>
+ /// Now previewing or capturing or is being used for video recording.
+ /// </summary>
+ Working
+ }
+
+ /// <summary>
+ /// Enumeration for Camera display type.
+ /// </summary>
+ public enum CameraDisplayType
+ {
+ /// <summary>
+ /// Overlay surface display.
+ /// </summary>
+ Overlay,
+ /// <summary>
+ /// Evas object surface display.
+ /// </summary>
+ Evas,
+ /// <summary>
+ /// This disposes off buffers.
+ /// </summary>
+ None
+ }
+
+ /// <summary>
+ /// Enumeration for the facing direction of camera module .
+ /// </summary>
+ public enum CameraFacingDirection
+ {
+ /// <summary>
+ /// Rear direction.
+ /// </summary>
+ RearDirection,
+ /// <summary>
+ /// Front direction
+ /// </summary>
+ FrontDirection
+ }
+
+ /// <summary>
+ /// Enumeration for the current flash state.
+ /// </summary>
+ public enum CameraFlashState
+ {
+ /// <summary>
+ /// Flash is not used now through camera API.
+ /// </summary>
+ NotUsed,
+ /// <summary>
+ /// Flash is used now through camera API.
+ /// </summary>
+ Used
+ }
+
+ /// <summary>
+ /// Enumeration for the camera flip type.
+ /// </summary>
+ public enum CameraFlip
+ {
+ /// <summary>
+ /// No Flip.
+ /// </summary>
+ None,
+ /// <summary>
+ /// Horizontal flip.
+ /// </summary>
+ Horizontal,
+ /// <summary>
+ /// Vertical flip.
+ /// </summary>
+ Vertical,
+ /// <summary>
+ /// Horizontal and vertical flip.
+ /// </summary>
+ Both
+ }
+
+ /// <summary>
+ /// Enumeration for the camera focus state.
+ /// </summary>
+ public enum CameraFocusState
+ {
+ /// <summary>
+ /// Focus released.
+ /// </summary>
+ Released,
+ /// <summary>
+ /// Focus in progress
+ /// </summary>
+ Ongoing,
+ /// <summary>
+ /// Focus succeeded
+ /// </summary>
+ Focused,
+ /// <summary>
+ /// Focus failed.
+ /// </summary>
+ Failed
+ }
+
+ /// <summary>
+ /// Enumeration for the camera pixel format.
+ /// </summary>
+ public enum CameraPixelFormat
+ {
+ /// <summary>
+ /// Invalid pixel format.
+ /// </summary>
+ Invalid = -1,
+ /// <summary>
+ /// NV12 pixel format.
+ /// </summary>
+ Nv12,
+ /// <summary>
+ /// NV12 Tiled pixel format.
+ /// </summary>
+ Nv12t,
+ /// <summary>
+ /// NV16 pixel format.
+ /// </summary>
+ Nv16,
+ /// <summary>
+ /// NV21 pixel format.
+ /// </summary>
+ Nv21,
+ /// <summary>
+ /// YUYV(YUY2) pixel format.
+ /// </summary>
+ Yuyv,
+ /// <summary>
+ /// UYVY pixel format.
+ /// </summary>
+ Uyvy,
+ /// <summary>
+ /// YUV422(Y:U:V) planar pixel format.
+ /// </summary>
+ Yuv422Planar,
+ /// <summary>
+ /// I420 pixel format.
+ /// </summary>
+ I420,
+ /// <summary>
+ /// YV12 pixel format.
+ /// </summary>
+ Yv12,
+ /// <summary>
+ /// RGB565 pixel format.
+ /// </summary>
+ Rgb565,
+ /// <summary>
+ /// RGB565 pixel format.
+ /// </summary>
+ Rgb888,
+ /// <summary>
+ /// RGBA pixel format.
+ /// </summary>
+ Rgba,
+ /// <summary>
+ /// ARGB pixel format.
+ /// </summary>
+ Argb,
+ /// <summary>
+ /// Encoded pixel format.
+ /// </summary>
+ Jpeg,
+ /// <summary>
+ /// Encoded pixel format : H264.
+ /// </summary>
+ H264 = 15
+ }
+
+ /// <summary>
+ /// Enumeration for the camera policy.
+ /// </summary>
+ public enum CameraPolicy
+ {
+ /// <summary>
+ /// None.
+ /// </summary>
+ None,
+ /// <summary>
+ /// Security policy
+ /// </summary>
+ Security,
+ /// <summary>
+ /// Resource conflict
+ /// </summary>
+ ResourceConflict
+ }
+
+ /// <summary>
+ /// Enumeration for the camera rotation type.
+ /// </summary>
+ public enum CameraRotation
+ {
+ /// <summary>
+ /// No rotation.
+ /// </summary>
+ None,
+ /// <summary>
+ /// 90 degree rotation.
+ /// </summary>
+ Rotation90,
+ /// <summary>
+ /// 180 degree rotation.
+ /// </summary>
+ Rotation180,
+ /// <summary>
+ /// 270 degree rotation.
+ /// </summary>
+ Rotation270
+ }
+
+ /// <summary>
+ /// Enumeration for the camera state.
+ /// </summary>
+ public enum CameraState
+ {
+ /// <summary>
+ /// Before creating.
+ /// </summary>
+ None,
+ /// <summary>
+ /// Created, but not initialized yet.
+ /// </summary>
+ Created,
+ /// <summary>
+ /// Preview.
+ /// </summary>
+ Preview,
+ /// <summary>
+ /// While capturing.
+ /// </summary>
+ Capturing,
+ /// <summary>
+ /// After capturing.
+ /// </summary>
+ Captured
+ }
+
+ /// <summary>
+ /// Enumeration for the auto focus mode.
+ /// </summary>
+ public enum CameraAutoFocusMode
+ {
+ /// <summary>
+ /// auto-focus is not set.
+ /// </summary>
+ None,
+ /// <summary>
+ /// auto-focus in the normal mode.
+ /// </summary>
+ Normal,
+ /// <summary>
+ /// auto-focus in the macro mode(close distance).
+ /// </summary>
+ Macro,
+ /// <summary>
+ /// auto-focus in the full mode(all range scan, limited by device spec).
+ /// </summary>
+ Full
+ }
+
+ /// <summary>
+ /// Enumeration for the color tone, which provides the impression of looking through a tinted glass.
+ /// </summary>
+ public enum CameraEffectMode
+ {
+ /// <summary>
+ /// None.
+ /// </summary>
+ None,
+ /// <summary>
+ /// Mono.
+ /// </summary>
+ Mono,
+ /// <summary>
+ /// Sepia.
+ /// </summary>
+ Sepia,
+ /// <summary>
+ /// Negative.
+ /// </summary>
+ Negative,
+ /// <summary>
+ /// Blue.
+ /// </summary>
+ Blue,
+ /// <summary>
+ /// Green.
+ /// </summary>
+ Green,
+ /// <summary>
+ /// Aqua.
+ /// </summary>
+ Aqua,
+ /// <summary>
+ /// Violet.
+ /// </summary>
+ Violet,
+ /// <summary>
+ /// Orange.
+ /// </summary>
+ Orange,
+ /// <summary>
+ /// Gray.
+ /// </summary>
+ Gray,
+ /// <summary>
+ /// Red.
+ /// </summary>
+ Red,
+ /// <summary>
+ /// Antique.
+ /// </summary>
+ Antique,
+ /// <summary>
+ /// Warm.
+ /// </summary>
+ Warm,
+ /// <summary>
+ /// Pink.
+ /// </summary>
+ Pink,
+ /// <summary>
+ /// Yellow.
+ /// </summary>
+ Yellow,
+ /// <summary>
+ /// Purple.
+ /// </summary>
+ Purple,
+ /// <summary>
+ /// Emboss.
+ /// </summary>
+ Emboss,
+ /// <summary>
+ /// Outline.
+ /// </summary>
+ Outline,
+ /// <summary>
+ /// Solarization.
+ /// </summary>
+ Solarization,
+ /// <summary>
+ /// Sketch.
+ /// </summary>
+ Sketch,
+ /// <summary>
+ /// Washed.
+ /// </summary>
+ Washed,
+ /// <summary>
+ /// Vintage warm.
+ /// </summary>
+ VintageWarm,
+ /// <summary>
+ /// Vintage cold .
+ /// </summary>
+ VintageCold,
+ /// <summary>
+ /// Posterization.
+ /// </summary>
+ Posterization,
+ /// <summary>
+ /// Cartoon.
+ /// </summary>
+ Cartoon,
+ /// <summary>
+ /// Selective color - Red.
+ /// </summary>
+ SelectiveRed,
+ /// <summary>
+ /// Selective color - Green.
+ /// </summary>
+ SelectiveGreen,
+ /// <summary>
+ /// Selective color - Blue.
+ /// </summary>
+ SelectiveBlue,
+ /// <summary>
+ /// Selective color - Yellow.
+ /// </summary>
+ SelectiveYellow,
+ /// <summary>
+ /// Selective color - Red and Yellow.
+ /// </summary>
+ SelectiveRedYellow,
+ /// <summary>
+ /// Other Graphic effects.
+ /// </summary>
+ OtherGraphics
+ }
+
+ /// <summary>
+ /// Enumeration for the camera exposure modes.
+ /// </summary>
+ public enum CameraExposureMode
+ {
+ /// <summary>
+ /// Off.
+ /// </summary>
+ Off,
+ /// <summary>
+ /// All mode.
+ /// </summary>
+ All,
+ /// <summary>
+ /// Center mode.
+ /// </summary>
+ Center,
+ /// <summary>
+ /// Spot mode.
+ /// </summary>
+ Spot,
+ /// <summary>
+ /// Custom mode.
+ /// </summary>
+ Custom
+ }
+
+ /// <summary>
+ /// Enumeration for the flash mode.
+ /// </summary>
+ public enum CameraFlashMode
+ {
+ /// <summary>
+ /// Always off.
+ /// </summary>
+ Off,
+ /// <summary>
+ /// Always splashes.
+ /// </summary>
+ On,
+ /// <summary>
+ /// Depending on intensity of light, strobe starts to flash.
+ /// </summary>
+ Auto,
+ /// <summary>
+ /// Red eye reduction. Multiple flash before capturing.
+ /// </summary>
+ RedEyeReduction,
+ /// <summary>
+ /// Slow sync curtain synchronization.
+ /// </summary>
+ SlowSync,
+ /// <summary>
+ /// Front curtain synchronization.
+ /// </summary>
+ FrontCurtain,
+ /// <summary>
+ /// Rear curtain synchronization.
+ /// </summary>
+ RearCurtain,
+ /// <summary>
+ /// Keep turned on until turning off.
+ /// </summary>
+ Permanent
+ }
+
+ /// <summary>
+ /// Enumeration for preview FPS.
+ /// </summary>
+ public enum CameraFps
+ {
+ /// <summary>
+ /// Auto FPS.
+ /// </summary>
+ Auto = 0,
+ /// <summary>
+ /// 7 FPS.
+ /// </summary>
+ Fps7 = 7,
+ /// <summary>
+ /// 8 FPS.
+ /// </summary>
+ Fps8 = 8,
+ /// <summary>
+ /// 15 FPS.
+ /// </summary>
+ Fps15 = 15,
+ /// <summary>
+ /// 20 FPS.
+ /// </summary>
+ Fps20 = 20,
+ /// <summary>
+ /// 24 FPS.
+ /// </summary>
+ Fps24 = 24,
+ /// <summary>
+ /// 25 FPS.
+ /// </summary>
+ Fps25 = 25,
+ /// <summary>
+ /// 30 FPS.
+ /// </summary>
+ Fps30 = 30,
+ /// <summary>
+ /// 60 FPS.
+ /// </summary>
+ Fps60 = 60,
+ /// <summary>
+ /// 90 FPS.
+ /// </summary>
+ Fps90 = 90,
+ /// <summary>
+ /// 120 FPS.
+ /// </summary>
+ Fps120 = 120
+ }
+
+ /// <summary>
+ /// Enumeration for HDR capture mode.
+ /// </summary>
+ public enum CameraHdrMode
+ {
+ /// <summary>
+ /// Disable HDR capture.
+ /// </summary>
+ Disable,
+ /// <summary>
+ /// Enable HDR capture.
+ /// </summary>
+ Enable,
+ /// <summary>
+ /// Enable HDR capture and keep original image data.
+ /// </summary>
+ KeepOriginal
+ }
+
+ /// <summary>
+ /// Enumeration for the ISO levels of the camera.
+ /// </summary>
+ public enum CameraIsoLevel
+ {
+ /// <summary>
+ /// ISO auto mode.
+ /// </summary>
+ Auto,
+ /// <summary>
+ /// ISO 50.
+ /// </summary>
+ Iso50,
+ /// <summary>
+ /// ISO 100.
+ /// </summary>
+ Iso100,
+ /// <summary>
+ /// ISO 200.
+ /// </summary>
+ Iso200,
+ /// <summary>
+ /// ISO 400.
+ /// </summary>
+ Iso400,
+ /// <summary>
+ /// ISO 800.
+ /// </summary>
+ Iso800,
+ /// <summary>
+ /// ISO 1600.
+ /// </summary>
+ Iso1600,
+ /// <summary>
+ /// ISO 3200.
+ /// </summary>
+ Iso3200
+ }
+
+ /// <summary>
+ /// Enumeration for PTZ(Pan Tilt Zoom) movement type.
+ /// </summary>
+ public enum CameraPtzMoveType
+ {
+ /// <summary>
+ /// Move to a specific coordinate position.
+ /// </summary>
+ Absoulute,
+ /// <summary>
+ /// Move a specific distance from the current position.
+ /// </summary>
+ Relative
+ }
+
+ /// <summary>
+ /// Enumeration for PTZ(Pan Tilt Zoom) type.
+ /// </summary>
+ public enum CameraPtzType
+ {
+ /// <summary>
+ /// Move the camera device physically.
+ /// </summary>
+ Mechanical,
+ /// <summary>
+ /// Zoom digitally and move into portion of the image.
+ /// </summary>
+ Electronic
+ }
+
+ /// <summary>
+ /// Enumeration for the camera scene mode.
+ /// </summary>
+ public enum CameraSceneMode
+ {
+ /// <summary>
+ /// Normal.
+ /// </summary>
+ Normal,
+ /// <summary>
+ /// Portrait.
+ /// </summary>
+ Portrait,
+ /// <summary>
+ /// Landscape.
+ /// </summary>
+ Landscape,
+ /// <summary>
+ /// Sports.
+ /// </summary>
+ Sports,
+ /// <summary>
+ /// Party & Indoor.
+ /// </summary>
+ PartyAndIndoor,
+ /// <summary>
+ /// Beach & Indoor.
+ /// </summary>
+ BeachAndIndoor,
+ /// <summary>
+ /// Sunset.
+ /// </summary>
+ Sunset,
+ /// <summary>
+ /// Dusk & Dawn.
+ /// </summary>
+ DuskAndDawn,
+ /// <summary>
+ /// Fall.
+ /// </summary>
+ FallColor,
+ /// <summary>
+ /// Night scene.
+ /// </summary>
+ NightScene,
+ /// <summary>
+ /// Firework.
+ /// </summary>
+ FireWork,
+ /// <summary>
+ /// Text.
+ /// </summary>
+ Text,
+ /// <summary>
+ /// Show window.
+ /// </summary>
+ ShowWindow,
+ /// <summary>
+ /// Candle light.
+ /// </summary>
+ CandleLight,
+ /// <summary>
+ /// Backlight.
+ /// </summary>
+ BackLight,
+ /// <summary>
+ /// Aqua.
+ /// </summary>
+ Aqua
+ }
+
+ /// <summary>
+ /// Enumeration for the orientation values of tag.
+ /// </summary>
+ public enum CameraTagOrientation
+ {
+ /// <summary>
+ /// Row #0 is at the top, Column #0 is to the left.
+ /// </summary>
+ TopLeft = 1,
+ /// <summary>
+ /// Row #0 is at the top, Column #0 is to the right.
+ /// </summary>
+ TopRight = 2,
+ /// <summary>
+ /// Row #0 is at the bottom, Column #0 is to the right.
+ /// </summary>
+ BottomRight = 3,
+ /// <summary>
+ /// Row #0 is at the bottom, Column #0 is to the left.
+ /// </summary>
+ BottomLeft = 4,
+ /// <summary>
+ /// Row #0 is at the left, Column #0 is to the top.
+ /// </summary>
+ LeftTop = 5,
+ /// <summary>
+ /// Row #0 is at the right, Column #0 is to the top.
+ /// </summary>
+ RightTop = 6,
+ /// <summary>
+ /// Row #0 is at the right, Column #0 is to the bottom.
+ /// </summary>
+ RightBottom = 7,
+ /// <summary>
+ /// Row #0 is at the left, Column #0 is to the bottom.
+ /// </summary>
+ LeftBottom = 8
+ }
+
+ /// <summary>
+ /// Enumeration for the theater mode.
+ /// </summary>
+ public enum CameraTheaterMode
+ {
+ /// <summary>
+ /// Disable theater mode - External display shows same image as device display.
+ /// </summary>
+ Disable,
+ /// <summary>
+ /// Enable theater mode - Preview image is displayed on external display with full screen mode, but preview image is not shown on device display.
+ /// </summary>
+ Enable,
+ /// <summary>
+ /// Clone mode - Preview image is displayed on external display with full screen mode. Also preview image is shown by the UI on device display.
+ /// </summary>
+ Clone
+ }
+
+ /// <summary>
+ ///Enumeration for the white balance levels of the camera.
+ /// </summary>
+ public enum CameraWhitebalance
+ {
+ /// <summary>
+ /// None.
+ /// </summary>
+ None,
+ /// <summary>
+ /// Automatic.
+ /// </summary>
+ Automatic,
+ /// <summary>
+ /// Daylight.
+ /// </summary>
+ Daylight,
+ /// <summary>
+ /// Cloudy.
+ /// </summary>
+ Cloudy,
+ /// <summary>
+ /// Fluorescent.
+ /// </summary>
+ Fluorescent,
+ /// <summary>
+ /// Incandescent.
+ /// </summary>
+ Incandescent,
+ /// <summary>
+ /// Shade.
+ /// </summary>
+ Shade,
+ /// <summary>
+ /// Horizon.
+ /// </summary>
+ Horizon,
+ /// <summary>
+ /// Flash.
+ /// </summary>
+ Flash,
+ /// <summary>
+ /// Custom.
+ /// </summary>
+ Custom
+ }
+
+ /// <summary>
+ /// Enumeration for the camera display mode.
+ /// </summary>
+ public enum CameraDisplayMode
+ {
+ /// <summary>
+ /// Letter box.
+ /// </summary>
+ LetterBox,
+ /// <summary>
+ /// Origin size.
+ /// </summary>
+ OriginSize,
+ /// <summary>
+ /// Full screen.
+ /// </summary>
+ Full,
+ /// <summary>
+ /// Cropped full screen.
+ /// </summary>
+ CroppedFull,
+ /// <summary>
+ /// Original size or letter box.
+ /// </summary>
+ OriginOrLetterBox,
+ /// <summary>
+ /// Custom ROI.
+ /// </summary>
+ CustomROI
+ }
+
+ /// <summary>
+ /// Enumeration for camera failure error.
+ /// </summary>
+ public enum CameraErrorCode
+ {
+ /// <summary>
+ /// Device Error.
+ /// </summary>
+ DeviceError = CameraError.ErrorDevice,
+ /// <summary>
+ /// Internal error.
+ /// </summary>
+ InvalidOperation = CameraError.InvalidOperation,
+ /// <summary>
+ /// Out of memory.
+ /// </summary>
+ OutOfMemory = CameraError.OutOfMemory
+ }
+
+ /// <summary>
+ /// Enumeration for Image datatype.
+ /// </summary>
+ public enum PlaneType
+ {
+ /// <summary>
+ /// Single plane data.
+ /// </summary>
+ SinglePlane,
+ /// <summary>
+ /// Double plane data.
+ /// </summary>
+ DoublePlane,
+ /// <summary>
+ /// Triple plane data.
+ /// </summary>
+ TriplePlane,
+ /// <summary>
+ /// Encoded plane data.
+ /// </summary>
+ EncodedPlane
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+using System;
+using Tizen.Internals.Errors;
+
+namespace Tizen.Multimedia
+{
+ internal enum CameraError
+ {
+ None = ErrorCode.None,
+ InvalidParameter = ErrorCode.InvalidParameter,
+ TizenErrorCamera = -0x01910000,
+ CameraErrorClass = TizenErrorCamera | 0x00,
+ InvalidState = CameraErrorClass | 0x02,
+ OutOfMemory = ErrorCode.OutOfMemory,
+ ErrorDevice = CameraErrorClass | 0x04,
+ InvalidOperation = ErrorCode.InvalidOperation,
+ SoundPolicy = CameraErrorClass | 0x06,
+ SecurityRestricted = CameraErrorClass | 0x07,
+ DeviceBusy = CameraErrorClass | 0x08,
+ DeviceNotFound = CameraErrorClass | 0x09,
+ SoundPolicyByCall = CameraErrorClass | 0x0a,
+ SoundPolicyByAlarm = CameraErrorClass | 0x0b,
+ Esd = CameraErrorClass | 0x0c,
+ PermissionDenied = ErrorCode.PermissionDenied,
+ NotSupported = ErrorCode.NotSupported,
+ ResourceConflict = CameraErrorClass | 0x0d,
+ ServiceDisconnected = CameraErrorClass | 0x0e
+ }
+
+ internal static class CameraErrorFactory
+ {
+ internal static void ThrowException(int errorCode, string errorMessage = null, string paramName = null)
+ {
+ CameraError err = (CameraError)errorCode;
+ if (string.IsNullOrEmpty(errorMessage))
+ {
+ errorMessage = err.ToString();
+ }
+
+ switch ((CameraError)errorCode)
+ {
+ case CameraError.InvalidParameter:
+ throw new ArgumentException(errorMessage, paramName);
+
+ case CameraError.InvalidState:
+ case CameraError.OutOfMemory:
+ case CameraError.ErrorDevice:
+ case CameraError.InvalidOperation:
+ case CameraError.DeviceBusy:
+ case CameraError.DeviceNotFound:
+ case CameraError.SoundPolicy:
+ case CameraError.SecurityRestricted:
+ case CameraError.SoundPolicyByCall:
+ case CameraError.SoundPolicyByAlarm:
+ case CameraError.Esd:
+ case CameraError.PermissionDenied:
+ throw new UnauthorizedAccessException(errorMessage);
+ case CameraError.NotSupported:
+ throw new NotSupportedException(errorMessage);
+ case CameraError.ResourceConflict:
+ case CameraError.ServiceDisconnected:
+ throw new InvalidOperationException(errorMessage);
+ }
+ }
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+using System;
+
+namespace Tizen.Multimedia
+{
+ /// <summary>
+ /// An extended EventArgs class which contains details about error status and
+ /// state of the camera when it failed.
+ /// </summary>
+ public class CameraErrorOccurredEventArgs : EventArgs
+ {
+ internal CameraErrorOccurredEventArgs(CameraErrorCode error, CameraState state)
+ {
+ Error = error;
+ State = state;
+ }
+
+ /// <summary>
+ /// The camera error code.
+ /// </summary>
+ public CameraErrorCode Error
+ {
+ get;
+ private set;
+ }
+
+ /// <summary>
+ /// The state of the camera.
+ /// </summary>
+ public CameraState State
+ {
+ get;
+ private set;
+ }
+ }
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+using System;
+using System.Collections.Generic;
+using Tizen.Internals.Errors;
+using System.Xml.Schema;
+
+namespace Tizen.Multimedia
+{
+ /// <summary>
+ /// The CameraFeature class provides properties
+ /// to get various capability information of the camera device.
+ /// </summary>
+ public class CameraFeature
+ {
+ internal readonly IntPtr _cameraHandle;
+ private readonly List<CameraResolution> _previewResolution;
+ private readonly List<CameraResolution> _cameraResolution;
+ private readonly List<CameraPixelFormat> _captureFormat;
+ private readonly List<CameraPixelFormat> _previewFormat;
+ private readonly List<CameraFps> _fps;
+ private readonly List<CameraFps> _fpsResolution;
+ private readonly List<CameraAutoFocusMode> _afMode;
+ private readonly List<CameraExposureMode> _exposureMode;
+ private readonly List<CameraTheaterMode> _theater;
+ private readonly List<CameraWhitebalance> _whitebalance;
+ private readonly List<CameraIsoLevel> _iso;
+ private readonly List<CameraEffectMode> _effect;
+ private readonly List<CameraSceneMode> _sceneMode;
+ private readonly List<CameraFlashMode> _flashMode;
+ private readonly List<CameraRotation> _streamRotation;
+ private readonly List<CameraFlip> _streamFlip;
+ private readonly List<CameraPtzType> _ptzType;
+
+ internal CameraFeature(IntPtr _handle)
+ {
+ _cameraHandle = _handle;
+ _previewResolution = new List<CameraResolution>();
+ _cameraResolution = new List<CameraResolution>();
+ _captureFormat = new List<CameraPixelFormat>();
+ _previewFormat = new List<CameraPixelFormat>();
+ _fps = new List<CameraFps>();
+ _fpsResolution = new List<CameraFps>();
+ _afMode = new List<CameraAutoFocusMode>();
+ _exposureMode = new List<CameraExposureMode>();
+ _theater = new List<CameraTheaterMode>();
+ _whitebalance = new List<CameraWhitebalance>();
+ _iso = new List<CameraIsoLevel>();
+ _effect = new List<CameraEffectMode>();
+ _sceneMode = new List<CameraSceneMode>();
+ _flashMode = new List<CameraFlashMode>();
+ _streamRotation = new List<CameraRotation>();
+ _streamFlip = new List<CameraFlip>();
+ _ptzType = new List<CameraPtzType>();
+ }
+
+ /// <summary>
+ /// Gets continuous capture feature's supported state.
+ /// true if supported, otherwise false.
+ /// </summary>
+ public bool ContinuousCapture
+ {
+ get
+ {
+ bool val = false;
+
+ val = Interop.CameraFeature.ContinuousCaptureSupport(_cameraHandle);
+ int ret = ErrorFacts.GetLastResult();
+ if ((CameraError)ret != CameraError.None)
+ {
+ CameraError err = (CameraError)ret;
+ Log.Error(CameraLog.Tag, "Failed to get continuous feature support, " + err.ToString());
+ }
+
+ return val;
+ }
+ }
+
+ /// <summary>
+ /// Gets the face detection feature's supported state.
+ /// true if supported, otherwise false.
+ /// </summary>
+ public bool FaceDetectionSupported
+ {
+ get
+ {
+ bool val = false;
+
+ val = Interop.CameraFeature.FaceDetectionSupport(_cameraHandle);
+ int ret = ErrorFacts.GetLastResult();
+ if ((CameraError)ret != CameraError.None)
+ {
+ CameraError err = (CameraError)ret;
+ Log.Error(CameraLog.Tag, "Failed to get face detection support, " + err.ToString());
+ }
+
+ return val;
+ }
+ }
+
+ /// <summary>
+ /// Gets the zero shutter lag feature's supported state.
+ /// true if supported, otherwise false.
+ /// </summary>
+ public bool ZeroShutterLag
+ {
+ get
+ {
+ bool val = false;
+
+ val = Interop.CameraFeature.ZeroShutterLagSupport(_cameraHandle);
+ int ret = ErrorFacts.GetLastResult();
+ if ((CameraError)ret != CameraError.None)
+ {
+ CameraError err = (CameraError)ret;
+ Log.Error(CameraLog.Tag, "Failed to get zero shutter lag support, " + err.ToString());
+ }
+
+ return val;
+ }
+ }
+
+ /// <summary>
+ /// Gets the media packet preview callback feature's supported state.
+ /// true if supported, otherwise false.
+ /// </summary>
+ public bool MediaPacketPreviewCallback
+ {
+ get
+ {
+ bool val = false;
+
+ val = Interop.CameraFeature.MediaPacketPreviewCallbackSupport(_cameraHandle);
+ int ret = ErrorFacts.GetLastResult();
+ if ((CameraError)ret != CameraError.None)
+ {
+ CameraError err = (CameraError)ret;
+ Log.Error(CameraLog.Tag, "Failed to get media packet preview callback support, " + err.ToString());
+ }
+
+ return val;
+ }
+ }
+
+ /// <summary>
+ /// Gets the support state of HDR capture.
+ /// true if supported, otherwise false.
+ /// </summary>
+ public bool HdrCapture
+ {
+ get
+ {
+ bool val = false;
+
+ val = Interop.CameraFeature.HdrCaptureSupport(_cameraHandle);
+ int ret = ErrorFacts.GetLastResult();
+ if ((CameraError)ret != CameraError.None)
+ {
+ CameraError err = (CameraError)ret;
+ Log.Error(CameraLog.Tag, "Failed to get hdr capture feature support, " + err.ToString());
+ }
+
+ return val;
+ }
+ }
+
+ /// <summary>
+ /// Gets the support state of the anti-shake feature.
+ /// true if supported, otherwise false.
+ /// </summary>
+ public bool AntiShake
+ {
+ get
+ {
+ bool val = false;
+
+ val = Interop.CameraFeature.AntiShakeSupport(_cameraHandle);
+ int ret = ErrorFacts.GetLastResult();
+ if ((CameraError)ret != CameraError.None)
+ {
+ CameraError err = (CameraError)ret;
+ Log.Error(CameraLog.Tag, "Failed to get anti shake feature support, " + err.ToString());
+ }
+
+ return val;
+ }
+ }
+
+ /// <summary>
+ /// Gets the support state of the video stabilization feature.
+ /// true if supported, otherwise false.
+ /// </summary>
+ public bool VideoStabilization
+ {
+ get
+ {
+ bool val = false;
+
+ val = Interop.CameraFeature.VideoStabilizationSupport(_cameraHandle);
+ int ret = ErrorFacts.GetLastResult();
+ if ((CameraError)ret != CameraError.None)
+ {
+ CameraError err = (CameraError)ret;
+ Log.Error(CameraLog.Tag, "Failed to get video stabilization feature support, " + err.ToString());
+ }
+
+ return val;
+ }
+ }
+
+ /// <summary>
+ /// Gets state of support of auto contrast feature.
+ /// true if supported, otherwise false.
+ /// </summary>
+ public bool AutoContrast
+ {
+ get
+ {
+ bool val = false;
+
+ val = Interop.CameraFeature.AutoContrastSupport(_cameraHandle);
+ int ret = ErrorFacts.GetLastResult();
+ if ((CameraError)ret != CameraError.None)
+ {
+ CameraError err = (CameraError)ret;
+ Log.Error(CameraLog.Tag, "Failed to get auto contrast feature support, " + err.ToString());
+ }
+
+ return val;
+ }
+ }
+
+ /// <summary>
+ /// Retrieves all the preview resolutions supported by the camera.
+ /// </summary>
+ /// <returns>
+ /// It returns a list containing all the supported preview resolutions.
+ /// by recorder.
+ /// </returns>
+ public IEnumerable<CameraResolution> PreviewResolutions
+ {
+ get
+ {
+ if (_previewResolution.Count == 0)
+ {
+ Interop.CameraFeature.PreviewResolutionCallback callback = (int width, int height, IntPtr userData) =>
+ {
+ CameraResolution temp = new CameraResolution(width, height);
+ _previewResolution.Add(temp);
+ return true;
+ };
+
+ int ret = Interop.CameraFeature.SupportedPreviewResolutions(_cameraHandle, callback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to get the supported preview resolutions");
+ }
+ }
+
+ return _previewResolution;
+ }
+ }
+
+ /// <summary>
+ /// Retrieves all the capture resolutions supported by the camera.
+ /// </summary>
+ /// <returns>
+ /// It returns a list containing all the supported capture resolutions.
+ /// </returns>
+ public IEnumerable<CameraResolution> CaptureResolutions
+ {
+ get
+ {
+ if (_cameraResolution.Count == 0)
+ {
+ Interop.CameraFeature.CaptureResolutionCallback callback = (int width, int height, IntPtr userData) =>
+ {
+ CameraResolution temp = new CameraResolution(width, height);
+ _cameraResolution.Add(temp);
+ return true;
+ };
+
+ int ret = Interop.CameraFeature.SupportedCaptureResolutions(_cameraHandle, callback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to get the supported capture resolutions");
+ }
+ }
+
+ return _cameraResolution;
+ }
+ }
+
+ /// <summary>
+ /// Retrieves all the capture formats supported by the camera.
+ /// </summary>
+ /// <returns>
+ /// It returns a list containing all the supported capture formats.
+ /// </returns>
+ public IEnumerable<CameraPixelFormat> CaptureFormats
+ {
+ get
+ {
+ if (_captureFormat.Count == 0)
+ {
+ Interop.CameraFeature.CaptureFormatCallback callback = (CameraPixelFormat format, IntPtr userData) =>
+ {
+ _captureFormat.Add(format);
+ return true;
+ };
+
+ int ret = Interop.CameraFeature.SupportedCaptureFormats(_cameraHandle, callback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to get the supported capture formats.");
+ }
+ }
+
+ return _captureFormat;
+ }
+ }
+
+ /// <summary>
+ /// Retrieves all the preview formats supported by the camera.
+ /// </summary>
+ /// <returns>
+ /// It returns a list containing all the supported preview formats.
+ /// </returns>
+ public IEnumerable<CameraPixelFormat> PreviewFormats
+ {
+ get
+ {
+ if (_previewFormat.Count == 0)
+ {
+ Interop.CameraFeature.PreviewFormatCallback callback = (CameraPixelFormat format, IntPtr userData) =>
+ {
+ _previewFormat.Add(format);
+ return true;
+ };
+
+ int ret = Interop.CameraFeature.SupportedPreviewFormats(_cameraHandle, callback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to get the supported preview formats.");
+ }
+ }
+
+ return _previewFormat;
+ }
+ }
+
+ /// <summary>
+ /// Retrieves all the fps supported by the camera.
+ /// </summary>
+ /// <returns>
+ /// It returns a list containing all the supported fps.
+ /// </returns>
+ public IEnumerable<CameraFps> Fps
+ {
+ get
+ {
+ if (_fps.Count == 0)
+ {
+ Interop.CameraFeature.FpsCallback callback = (CameraFps fps, IntPtr userData) =>
+ {
+ _fps.Add(fps);
+ return true;
+ };
+
+ int ret = Interop.CameraFeature.SupportedFps(_cameraHandle, callback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to get the supported camera fps");
+ }
+ }
+
+ return _fps;
+ }
+ }
+
+ private bool resolutionCallback(CameraFps fps, IntPtr userData)
+ {
+ _fpsResolution.Add(fps);
+ return true;
+ }
+
+ /// <summary>
+ /// Retrieves all the fps by resolution supported by the camera.
+ /// </summary>
+ /// <returns>
+ /// It returns a list containing all the supported fps by resolution.
+ /// </returns>
+ public IEnumerable<CameraFps> FpsByResolution(int width, int height)
+ {
+ if (_fpsResolution.Count == 0)
+ {
+ int ret = Interop.CameraFeature.SupportedFpsByResolution(_cameraHandle, width, height, resolutionCallback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to get the supported fps by resolutions.");
+ }
+ }
+
+ return _fpsResolution;
+ }
+
+ /// <summary>
+ /// Retrieves all the fps by resolution supported by the camera.
+ /// </summary>
+ /// <returns>
+ /// It returns a list containing all the supported fps by resolution.
+ /// </returns>
+ public IEnumerable<CameraAutoFocusMode> AfMode
+ {
+ get
+ {
+ if (_afMode.Count == 0)
+ {
+ Interop.CameraFeature.AfModeCallback callback = (CameraAutoFocusMode mode, IntPtr userData) =>
+ {
+ _afMode.Add(mode);
+ return true;
+ };
+
+ int ret = Interop.CameraFeature.SupportedAfModes(_cameraHandle, callback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to get the supported Auto focus modes.");
+ }
+ }
+
+ return _afMode;
+ }
+ }
+
+ /// <summary>
+ /// Retrieves all the exposure modes supported by the camera.
+ /// </summary>
+ /// <returns>
+ /// It returns a list containing all the supported camera exposure modes.
+ /// </returns>
+ public IEnumerable<CameraExposureMode> ExposureModes
+ {
+ get
+ {
+ if (_exposureMode.Count == 0)
+ {
+ Interop.CameraFeature.ExposureModeCallback callback = (CameraExposureMode mode, IntPtr userData) =>
+ {
+ _exposureMode.Add(mode);
+ return true;
+ };
+
+ int ret = Interop.CameraFeature.SupportedExposureModes(_cameraHandle, callback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to get the supported Exposure modes.");
+ }
+ }
+
+ return _exposureMode;
+ }
+ }
+
+ /// <summary>
+ /// Retrieves all the Iso level supported by the camera.
+ /// </summary>
+ /// <returns>
+ /// It returns a list containing all the supported camera Iso levels.
+ /// </returns>
+ public IEnumerable<CameraIsoLevel> IsoLevel
+ {
+ get
+ {
+ if (_iso.Count == 0)
+ {
+ Interop.CameraFeature.IsoCallback callback = (CameraIsoLevel iso, IntPtr userData) =>
+ {
+ _iso.Add(iso);
+ return true;
+ };
+
+ int ret = Interop.CameraFeature.SupportedIso(_cameraHandle, callback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to get the supported Iso levels.");
+ }
+ }
+
+ return _iso;
+ }
+ }
+
+ /// <summary>
+ /// Retrieves all the theater modes supported by the camera.
+ /// </summary>
+ /// <returns>
+ /// It returns a list containing all the supported camera theater modes.
+ /// </returns>
+ public IEnumerable<CameraTheaterMode> TheaterMode
+ {
+ get
+ {
+ if (_theater.Count == 0)
+ {
+ Interop.CameraFeature.TheaterModeCallback callback = (CameraTheaterMode theaterMode, IntPtr userData) =>
+ {
+ _theater.Add(theaterMode);
+ return true;
+ };
+
+ int ret = Interop.CameraFeature.SupportedTheaterModes(_cameraHandle, callback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to get the supported theater modes.");
+ }
+ }
+
+ return _theater;
+ }
+ }
+
+ /// <summary>
+ /// Retrieves all the whitebalance mode supported by the camera.
+ /// </summary>
+ /// <returns>
+ /// It returns a list containing all the supported camera white balance modes.
+ /// </returns>
+ public IEnumerable<CameraWhitebalance> Whitebalance
+ {
+ get
+ {
+ if (_whitebalance.Count == 0)
+ {
+ Interop.CameraFeature.WhitebalanceCallback callback = (CameraWhitebalance whitebalance, IntPtr userData) =>
+ {
+ _whitebalance.Add(whitebalance);
+ return true;
+ };
+ int ret = Interop.CameraFeature.SupportedWhitebalance(_cameraHandle, callback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to get the supported white balance.");
+ }
+ }
+
+ return _whitebalance;
+ }
+ }
+
+ /// <summary>
+ /// Retrieves all the flash modes supported by the camera.
+ /// </summary>
+ /// <returns>
+ /// It returns a list containing all the supported camera flash modes.
+ /// </returns>
+ public IEnumerable<CameraFlashMode> FlashMode
+ {
+ get
+ {
+ if (_flashMode.Count == 0)
+ {
+ Interop.CameraFeature.FlashModeCallback callback = (CameraFlashMode flashMode, IntPtr userData) =>
+ {
+ _flashMode.Add(flashMode);
+ return true;
+ };
+ int ret = Interop.CameraFeature.SupportedFlashModes(_cameraHandle, callback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to get the supported flash modes.");
+ }
+ }
+
+ return _flashMode;
+ }
+ }
+
+ /// <summary>
+ /// Retrieves all the scene modes supported by the camera.
+ /// </summary>
+ /// <returns>
+ /// It returns a list containing all the supported camera scene modes.
+ /// </returns>
+ public IEnumerable<CameraSceneMode> SceneMode
+ {
+ get
+ {
+ if (_sceneMode.Count == 0)
+ {
+ Interop.CameraFeature.SceneModeCallback callback = (CameraSceneMode sceneMode, IntPtr userData) =>
+ {
+ _sceneMode.Add(sceneMode);
+ return true;
+ };
+ int ret = Interop.CameraFeature.SupportedSceneModes(_cameraHandle, callback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to get the supported scene modes.");
+ }
+ }
+
+ return _sceneMode;
+ }
+ }
+
+ /// <summary>
+ /// Retrieves all the effects supported by the camera.
+ /// </summary>
+ /// <returns>
+ /// It returns a list containing all the supported camera effects.
+ /// </returns>
+ public IEnumerable<CameraEffectMode> Effect
+ {
+ get
+ {
+ if (_effect.Count == 0)
+ {
+ Interop.CameraFeature.EffectCallback callback = (CameraEffectMode effect, IntPtr userData) =>
+ {
+ _effect.Add(effect);
+ return true;
+ };
+ int ret = Interop.CameraFeature.SupportedEffects(_cameraHandle, callback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to get the supported camera effects.");
+ }
+ }
+
+ return _effect;
+ }
+ }
+
+ /// <summary>
+ /// Retrieves all the stream rotation supported by the camera.
+ /// </summary>
+ /// <returns>
+ /// It returns a list containing all the supported camera stream rotations.
+ /// </returns>
+ public IEnumerable<CameraRotation> StreamRotation
+ {
+ get
+ {
+ if (_streamRotation.Count == 0)
+ {
+ Interop.CameraFeature.StreamRotationCallback callback = (CameraRotation streamRotation, IntPtr userData) =>
+ {
+ _streamRotation.Add(streamRotation);
+ return true;
+ };
+ int ret = Interop.CameraFeature.SupportedStreamRotations(_cameraHandle, callback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to get the supported camera rotations.");
+ }
+ }
+
+ return _streamRotation;
+ }
+ }
+
+ /// <summary>
+ /// Retrieves all the flips supported by the camera.
+ /// </summary>
+ /// <returns>
+ /// It returns a list containing all the supported camera flip.
+ /// </returns>
+ public IEnumerable<CameraFlip> StreamFlip
+ {
+ get
+ {
+ if (_streamFlip.Count == 0)
+ {
+ Interop.CameraFeature.StreamFlipCallback callback = (CameraFlip streamFlip, IntPtr userData) =>
+ {
+ _streamFlip.Add(streamFlip);
+ return true;
+ };
+ int ret = Interop.CameraFeature.SupportedStreamFlips(_cameraHandle, callback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to get the supported camera flips.");
+ }
+ }
+
+ return _streamFlip;
+ }
+ }
+
+ /// <summary>
+ /// Retrieves all the ptz types by the camera.
+ /// </summary>
+ /// <returns>
+ /// It returns a list containing all the supported ptz types.
+ /// </returns>
+ public IEnumerable<CameraPtzType> PtzType
+ {
+ get
+ {
+ if (_ptzType.Count == 0)
+ {
+ Interop.CameraFeature.PtzTypeCallback callback = (CameraPtzType ptzType, IntPtr userData) =>
+ {
+ _ptzType.Add(ptzType);
+ return true;
+ };
+ int ret = Interop.CameraFeature.SupportedPtzTypes(_cameraHandle, callback, IntPtr.Zero);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to get the supported Ptz types.");
+ }
+ }
+
+ return _ptzType;
+ }
+ }
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+using System;
+
+namespace Tizen.Multimedia
+{
+ /// <summary>
+ /// An extended EventArgs class which contains details about focus state of the
+ /// camera.
+ /// </summary>
+ public class CameraFocusChangedEventArgs : EventArgs
+ {
+ internal CameraFocusChangedEventArgs(CameraFocusState state)
+ {
+ State = state;
+ }
+
+ /// <summary>
+ /// Focus state of the camera.
+ /// </summary>
+ public CameraFocusState State
+ {
+ get;
+ private set;
+ }
+ }
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+using System;
+
+namespace Tizen.Multimedia
+{
+ /// <summary>
+ /// An extended EventArgs class which contains details about previous and current state
+ /// of the camera when its interrupted.
+ /// </summary>
+ public class CameraInterruptedEventArgs : EventArgs
+ {
+ internal CameraInterruptedEventArgs(CameraPolicy policy, CameraState previous, CameraState current)
+ {
+ Policy = policy;
+ Current = current;
+ Previous = previous;
+ }
+
+ /// <summary>
+ /// Previous state of the camera.
+ /// </summary>
+ public CameraState Previous
+ {
+ get;
+ private set;
+ }
+
+ /// <summary>
+ /// Current state of the camera.
+ /// </summary>
+ public CameraState Current
+ {
+ get;
+ private set;
+ }
+
+ /// <summary>
+ /// The policy that interrupted the camera.
+ /// </summary>
+ public CameraPolicy Policy
+ {
+ get;
+ private set;
+ }
+ }
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+using System;
+
+namespace Tizen.Multimedia
+{
+ /// <summary>
+ /// Camera resolution class.
+ /// </summary>
+ public class CameraResolution
+ {
+ /// <summary>
+ /// public constructor.
+ /// </summary>
+ /// <param name="width">Resolution width</param>
+ /// <param name="height">Resolution height</param>
+ public CameraResolution(int width, int height)
+ {
+ Width = width;
+ Height = height;
+ }
+
+ /// <summary>
+ /// The resolution width.
+ /// </summary>
+ public int Width
+ {
+ get;
+ private set;
+ }
+
+ /// <summary>
+ /// The resolution height.
+ /// </summary>
+ public int Height
+ {
+ get;
+ private set;
+ }
+ }
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using Tizen.Internals.Errors;
+
+namespace Tizen.Multimedia
+{
+ /// <summary>
+ /// The camera setting class provides methods/properties to get and
+ /// set basic camera attributes.
+ /// </summary>
+ public class CameraSetting
+ {
+ internal readonly IntPtr _settingHandle;
+
+ internal CameraSetting(IntPtr _handle)
+ {
+ _settingHandle = _handle;
+ }
+
+ /// <summary>
+ /// Sets auto focus area.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ /// <param name="x">X position</param>
+ /// <param name="y">Y position</param>
+ /// <exception cref="ArgumentException">In case of invalid parameters</exception>
+ public void SetFocusArea(int x, int y)
+ {
+ int ret = Interop.CameraSetting.SetAfArea(_settingHandle, x, y);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to set the autofocus area.");
+ }
+ }
+
+ /// <summary>
+ /// Clears the auto focus area.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ public void ClearFocusArea()
+ {
+ int ret = Interop.CameraSetting.ClearAfArea(_settingHandle);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to clear the autofocus area.");
+ }
+ }
+
+ /// <summary>
+ /// Sets the position to move horizontally.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ /// <param name="type">ptz move type.</param>
+ /// <param name="panStep">pan step</param>
+ /// <exception cref="ArgumentException">In case of invalid parameters</exception>
+ public void SetPan(CameraPtzMoveType type, int panStep)
+ {
+ int ret = Interop.CameraSetting.SetPan(_settingHandle, (int)type, panStep);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to set the camera pan type.");
+ }
+ }
+
+ /// <summary>
+ /// Gets the current position of the camera.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ /// <returns>Returns the camera's horizontal position</returns>
+ public int GetPan()
+ {
+ int val = 0;
+ int ret = Interop.CameraSetting.GetPan(_settingHandle, out val);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to get the camera pan step.");
+ }
+
+ return val;
+ }
+
+ /// <summary>
+ /// Sets the position to move vertically.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ /// <param name="type">ptz move type</param>
+ /// <param name="tiltStep">tilt step</param>
+ /// <exception cref="ArgumentException">In case of invalid parameters</exception>
+ public void SetTilt(CameraPtzMoveType type, int tiltStep)
+ {
+ int ret = Interop.CameraSetting.SetTilt(_settingHandle, (int)type, tiltStep);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to set the camera tilt type\t.");
+ }
+ }
+
+ /// <summary>
+ /// Gets the current position of the camera.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ /// <returns>Returns the current vertical position</returns>
+ public int GetTilt()
+ {
+ int val = 0;
+ int ret = Interop.CameraSetting.GetTilt(_settingHandle, out val);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to set the camera current position.");
+ }
+
+ return val;
+ }
+
+ /// <summary>
+ /// Removes the geotag(GPS data) in the EXIF(Exchangeable image file format) tag.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ public void RemoveGeoTag()
+ {
+ int ret = Interop.CameraSetting.RemoveGeotag(_settingHandle);
+ if (ret != (int)CameraError.None)
+ {
+ CameraErrorFactory.ThrowException(ret, "Failed to remove the geotag\t.");
+ }
+ }
+
+ /// <summary>
+ /// The preview frame rate.
+ /// </summary>
+ public CameraFps PreviewFps
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.CameraSetting.GetPreviewFps(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera preview fps, " + (CameraError)ret);
+ }
+
+ return (CameraFps)val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.SetPreviewFps(_settingHandle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set preview fps, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set preview fps.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The quality of the image.
+ /// The range for image quality is 1 to 100.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera.
+ /// </privilege>
+ public int ImageQuality
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.CameraSetting.GetImageQuality(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get image quality, " + (CameraError)ret);
+ }
+
+ return val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.SetImageQuality(_settingHandle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set image quality, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set image quality.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The bit rate of encoded preview.
+ /// </summary>
+ public int EncodedPreviewBitrate
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.CameraSetting.GetBitrate(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get preview bitrate, " + (CameraError)ret);
+ }
+
+ return val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.SetBitrate(_settingHandle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set encoded preview bitrate, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set encoded preview bitrate.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// GOP(Group Of Pictures) interval of encoded preview.
+ /// </summary>
+ public int EncodedPreviewGopInterval
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.CameraSetting.GetGopInterval(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get preview gop interval, " + (CameraError)ret);
+ }
+
+ return val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.SetGopInterval(_settingHandle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set encoded preview gop interval, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set encoded preview gop intervals.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The zoom level.
+ /// The range for zoom level is received from ZoomRange property.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera.
+ /// </privilege>
+ public int ZoomLevel
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.CameraSetting.GetZoom(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get zoom level, " + (CameraError)ret);
+ }
+
+ return val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.SetZoom(_settingHandle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set zoom level, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set zoom level.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// Gets the available zoom level.
+ /// </summary>
+ /// <remarks>
+ /// If min value is greater than the max value, it means this feature is not supported.
+ /// </remarks>
+ public Range ZoomRange
+ {
+ get
+ {
+ int min = 0;
+ int max = 0;
+
+ int ret = Interop.CameraSetting.GetZoomRange(_settingHandle, out min, out max);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get zoom range, " + (CameraError)ret);
+ }
+
+ Range res = new Range(min, max);
+ return res;
+ }
+ }
+
+ /// <summary>
+ /// Gets the available exposure value.
+ /// </summary>
+ /// <remarks>
+ /// If min value is greater than the max value, it means this feature is not supported.
+ /// </remarks>
+ public Range ExposureRange
+ {
+ get
+ {
+ int min = 0;
+ int max = 0;
+
+ int ret = Interop.CameraSetting.GetExposureRange(_settingHandle, out min, out max);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get exposure range, " + (CameraError)ret);
+ }
+
+ Range res = new Range(min, max);
+ return res;
+ }
+ }
+
+ /// <summary>
+ /// Gets the available brightness level.
+ /// </summary>
+ /// <remarks>
+ /// If min value is greater than the max value, it means this feature is not supported.
+ /// </remarks>
+ public Range BrightnessRange
+ {
+ get
+ {
+ int min = 0;
+ int max = 0;
+
+ int ret = Interop.CameraSetting.GetBrightnessRange(_settingHandle, out min, out max);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get brightness range, " + (CameraError)ret);
+ }
+
+ Range res = new Range(min, max);
+ return res;
+ }
+ }
+
+ /// <summary>
+ /// Gets the available contrast level.
+ /// </summary>
+ /// <remarks>
+ /// If min value is greater than the max value, it means this feature is not supported.
+ /// </remarks>
+ public Range ContrastRange
+ {
+ get
+ {
+ int min = 0;
+ int max = 0;
+
+ int ret = Interop.CameraSetting.GetContrastRange(_settingHandle, out min, out max);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get contrast range, " + (CameraError)ret);
+ }
+
+ Range res = new Range(min, max);
+ return res;
+ }
+ }
+
+ /// <summary>
+ /// Gets lower limit and upper limit for pan position.
+ /// </summary>
+ /// <remarks>
+ /// If min value is greater than the max value, it means this feature is not supported.
+ /// </remarks>
+ public Range PanRange
+ {
+ get
+ {
+ int min = 0;
+ int max = 0;
+
+ int ret = Interop.CameraSetting.GetPanRange(_settingHandle, out min, out max);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get pan range, " + (CameraError)ret);
+ }
+
+ Range res = new Range(min, max);
+ return res;
+ }
+ }
+
+ /// <summary>
+ /// Gets lower limit and upper limit for tilt position.
+ /// </summary>
+ /// <remarks>
+ /// If min value is greater than the max value, it means this feature is not supported.
+ /// </remarks>
+ public Range TiltRange
+ {
+ get
+ {
+ int min = 0;
+ int max = 0;
+
+ int ret = Interop.CameraSetting.GetTiltRange(_settingHandle, out min, out max);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get tilt range, " + (CameraError)ret);
+ }
+
+ Range res = new Range(min, max);
+ return res;
+ }
+ }
+
+ /// <summary>
+ /// The auto focus mode.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ public CameraAutoFocusMode AfMode
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.CameraSetting.GetAfMode(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera autofocus mode, " + (CameraError)ret);
+ }
+
+ return (CameraAutoFocusMode)val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.SetAfMode(_settingHandle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set camera autofocus mode, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set camera autofocus mode.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The exposure mode.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ public CameraExposureMode ExposureMode
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.CameraSetting.GetExposureMode(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera exposure mode, " + (CameraError)ret);
+ }
+
+ return (CameraExposureMode)val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.SetExposureMode(_settingHandle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set camera exposure mode, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set camera exposure mode.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The exposure value.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ public int Exposure
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.CameraSetting.GetExposure(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera exposure value, " + (CameraError)ret);
+ }
+
+ return val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.SetExposure(_settingHandle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set camera exposure value, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set camera exposure value.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The ISO level.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ public CameraIsoLevel IsoLevel
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.CameraSetting.GetIso(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera Iso level, " + (CameraError)ret);
+ }
+
+ return (CameraIsoLevel)val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.SetIso(_settingHandle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set camera Iso level, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set camera Iso level.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The theater mode.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ /// <remarks>
+ /// If you want to display the preview image on the external display with the full screen mode,
+ /// use this property.
+ /// </remarks>
+ public CameraTheaterMode TheaterMode
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.CameraSetting.GetTheaterMode(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera theater mode, " + (CameraError)ret);
+ }
+
+ return (CameraTheaterMode)val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.SetTheaterMode(_settingHandle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set camera theater mode, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set camera theater mode.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The brightness level of the camera.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ public int Brightness
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.CameraSetting.GetBrightness(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera brightness value, " + (CameraError)ret);
+ }
+
+ return val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.SetBrightness(_settingHandle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set camera brightness value, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set camera brightness value.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The contrast level of the camera.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ public int Contrast
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.CameraSetting.GetContrast(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera contrast value, " + (CameraError)ret);
+ }
+
+ return val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.SetContrast(_settingHandle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set camera contrast value, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set camera contrast value.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The whitebalance mode.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ public CameraWhitebalance Whitebalance
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.CameraSetting.GetWhitebalance(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera whitebalance, " + (CameraError)ret);
+ }
+
+ return (CameraWhitebalance)val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.SetWhitebalance(_settingHandle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set camera whitebalance, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set camera whitebalance.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The camera effect mode.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ public CameraEffectMode Effect
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.CameraSetting.GetEffect(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera effect, " + (CameraError)ret);
+ }
+
+ return (CameraEffectMode)val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.SetEffect(_settingHandle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set camera effect, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set camera effect.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The scene mode.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ public CameraSceneMode SceneMode
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.CameraSetting.GetSceneMode(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera scene mode, " + (CameraError)ret);
+ }
+
+ return (CameraSceneMode)val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.SetSceneMode(_settingHandle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set camera scene mode, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set camera scene mode.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The scene mode.
+ /// true if EXIF tags are enabled in JPEG file, otherwise false.
+ /// </summary>
+ public bool EnableTag
+ {
+ get
+ {
+ bool val = false;
+ int ret = Interop.CameraSetting.IsEnabledTag(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera enable tag, " + (CameraError)ret);
+ }
+
+ return val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.EnableTag(_settingHandle, (bool)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set camera enable tag, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set camera enable tag.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The camera image description in the EXIF tag.
+ /// </summary>
+ public string ImageDescription
+ {
+ get
+ {
+ IntPtr val;
+ int ret = Interop.CameraSetting.GetImageDescription(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get image description, " + (CameraError)ret);
+ }
+
+ string result = Marshal.PtrToStringAnsi(val);
+ Interop.Libc.Free(val);
+ return result;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.SetImageDescription(_settingHandle, value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set image description, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set image description.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The software information in the EXIF tag.
+ /// </summary>
+ public string TagSoftware
+ {
+ get
+ {
+ IntPtr val;
+ int ret = Interop.CameraSetting.GetTagSoftware(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get tag software, " + (CameraError)ret);
+ }
+
+ string result = Marshal.PtrToStringAnsi(val);
+ Interop.Libc.Free(val);
+ return result;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.SetTagSoftware(_settingHandle, value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set tag software, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set tag software.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The geotag(GPS data) in the EXIF tag.
+ /// </summary>
+ public Location GeoTag
+ {
+ get
+ {
+ double latitude = 0.0;
+ double longitude = 0.0;
+ double altitude = 0.0;
+
+ int ret = Interop.CameraSetting.GetGeotag(_settingHandle, out latitude, out longitude, out altitude);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get tag, " + (CameraError)ret);
+ }
+
+ Location loc = new Location(latitude, longitude, altitude);
+ return loc;
+ }
+
+ set
+ {
+ Location loc = value;
+ int ret = Interop.CameraSetting.SetGeotag(_settingHandle, loc.Latitude, loc.Longitude, loc.Altitude);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get contrast range, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set geo tag.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The camera orientation in the tag.
+ /// </summary>
+ public CameraTagOrientation TagOrientation
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.CameraSetting.GetTagOrientation(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera tag orientation, " + (CameraError)ret);
+ }
+
+ return (CameraTagOrientation)val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.SetTagOrientation(_settingHandle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set camera tag orientation, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set camera tag orientation.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The camera's flash mode.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ public CameraFlashMode FlashMode
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.CameraSetting.GetFlashMode(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera flash mode, " + (CameraError)ret);
+ }
+
+ return (CameraFlashMode)val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.SetFlashMode(_settingHandle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set camera flash mode, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set camera flash mode.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// Gets the camera lens orientation angle.
+ /// </summary>
+ public int LensOrientation
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.CameraSetting.GetLensOrientation(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera lens orientation, " + (CameraError)ret);
+ }
+
+ return val;
+ }
+ }
+
+ /// <summary>
+ /// The stream rotation.
+ /// </summary>
+ public CameraRotation StreamRotation
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.CameraSetting.GetStreamRotation(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera stream rotation, " + (CameraError)ret);
+ }
+
+ return (CameraRotation)val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.SetStreamRotation(_settingHandle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set camera stream rotation, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set camera stream rotation.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The stream flip.
+ /// </summary>
+ public CameraFlip StreamFlip
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.CameraSetting.GetFlip(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera stream flip, " + (CameraError)ret);
+ }
+
+ return (CameraFlip)val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.SetFlip(_settingHandle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set camera stream flip, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set camera flip.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The mode of HDR(High dynamic range) capture.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ /// <remarks>
+ /// Taking multiple pictures at different exposure levels and intelligently stitching them together
+ /// so that we eventually arrive at a picture that is representative in both dark and bright areas.
+ /// If this attribute is set, then eventhandler set for HdrCaptureProgress event is invoked.
+ /// </remarks>
+ public CameraHdrMode HdrMode
+ {
+ get
+ {
+ int val = 0;
+ int ret = Interop.CameraSetting.GetHdrMode(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera hdr mode, " + (CameraError)ret);
+ }
+
+ return (CameraHdrMode)val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.SetHdrMode(_settingHandle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set camera hdr mode, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set camera hdr mode.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The anti shake feature.
+ /// If true the antishake feature is enabled, otherwise false.
+ /// </summary>
+ public bool AntiShake
+ {
+ get
+ {
+ bool val = false;
+ int ret = Interop.CameraSetting.IsEnabledAntiShake(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera anti shake value, " + (CameraError)ret);
+ }
+
+ return val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.EnableAntiShake(_settingHandle, (bool)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set camera anti shake value, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set camera anti shake value.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// Enables/Disables the video stabilization feature.
+ /// If true video stabilization is enabled, otherwise false.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ /// <remarks>
+ /// If video stabilization is enabled, zero shutter lag is disabled.
+ /// This feature is used to record a video.
+ /// </remarks>
+ public bool VideoStabilization
+ {
+ get
+ {
+ bool val = false;
+ int ret = Interop.CameraSetting.IsEnabledVideoStabilization(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera video stabilization, " + (CameraError)ret);
+ }
+
+ return val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.EnableVideoStabilization(_settingHandle, (bool)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set camera video stabilization, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set camera video stabilization.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// The auto contrast.
+ /// If true auto contrast is enabled, otherwise false.
+ /// </summary>
+ /// <privilege>
+ /// http://tizen.org/privilege/camera
+ /// </privilege>
+ public bool AutoContrast
+ {
+ get
+ {
+ bool val = false;
+ int ret = Interop.CameraSetting.IsEnabledAutoContrast(_settingHandle, out val);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get camera auto contrast, " + (CameraError)ret);
+ }
+
+ return val;
+ }
+
+ set
+ {
+ int ret = Interop.CameraSetting.EnableAutoContrast(_settingHandle, (bool)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set camera enable auto contrast, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set camera enable auto contrast.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// Disables shutter sound.
+ /// If true shutter sound is disabled, otherwise false.
+ /// </summary>
+ /// <remarks>
+ /// In some countries, this operation is not permitted.
+ /// </remarks>
+ public bool DisableShutterSound
+ {
+ set
+ {
+ int ret = Interop.CameraSetting.DisableShutterSound(_settingHandle, (bool)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to disable shutter sound, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set disable shutter sound.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// Sets the type of PTZ(Pan Tilt Zoom).
+ /// </summary>
+ public CameraPtzType PtzType
+ {
+ set
+ {
+ int ret = Interop.CameraSetting.SetPtzType(_settingHandle, (int)value);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set camera ptz type, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set camera ptz type.");
+ }
+ }
+ }
+
+ /// <summary>
+ /// the ROI(Region Of Interest) area of display.
+ /// </summary>
+ public Area DisplayRoiArea
+ {
+ get
+ {
+ int x = 0;
+ int y = 0;
+ int width = 0;
+ int height = 0;
+
+ int ret = Interop.CameraSetting.GetDisplayRoiArea(_settingHandle, out x, out y, out width, out height);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to get display roi area, " + (CameraError)ret);
+ }
+
+ Area ar = new Area(x, y, width, height);
+ return ar;
+ }
+
+ set
+ {
+ Area ar = (Area)value;
+ int ret = Interop.CameraSetting.SetDisplayRoiArea(_settingHandle, ar.X, ar.Y, ar.Width, ar.Height);
+ if ((CameraError)ret != CameraError.None)
+ {
+ Log.Error(CameraLog.Tag, "Failed to set display roi area, " + (CameraError)ret);
+ CameraErrorFactory.ThrowException(ret, "Failed to set display roi area.");
+ }
+ }
+ }
+ }
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+using System;
+
+namespace Tizen.Multimedia
+{
+ /// <summary>
+ /// An extended EventArgs class which contains details about previous and current state
+ /// of the camera when its state is changed.
+ /// </summary>
+ public class CameraStateChangedEventArgs : EventArgs
+ {
+ internal CameraStateChangedEventArgs(CameraState previous, CameraState current, bool policy)
+ {
+ Previous = previous;
+ Current = current;
+ ByPolicy = policy;
+ }
+
+ /// <summary>
+ /// Previous state of the camera.
+ /// </summary>
+ public CameraState Previous
+ {
+ get;
+ private set;
+ }
+
+ /// <summary>
+ /// Current state of the camera.
+ /// </summary>
+ public CameraState Current
+ {
+ get;
+ private set;
+ }
+
+ /// <summary>
+ /// true if the state changed by policy such as Resource Conflict or Security, otherwise false
+ /// in normal state change.
+ /// </summary>
+ public bool ByPolicy
+ {
+ get;
+ private set;
+ }
+ }
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+using System;
+
+namespace Tizen.Multimedia
+{
+ /// <summary>
+ /// An extended EventArgs class which contains details about the captured image.
+ /// </summary>
+ public class CapturingEventArgs : EventArgs
+ {
+ internal CapturingEventArgs(ImageData img, ImageData post, ImageData thumbnail)
+ {
+ Image = img;
+ PostView = post;
+ Thumbnail = thumbnail;
+ }
+
+ /// <summary>
+ /// The image data of the captured picture.
+ /// </summary>
+ public ImageData Image
+ {
+ get;
+ internal set;
+ }
+
+ /// <summary>
+ /// The image data of the postview.
+ /// </summary>
+ public ImageData PostView
+ {
+ get;
+ internal set;
+ }
+
+ /// <summary>
+ /// The image data of the thumbnail.
+ /// </summary>
+ public ImageData Thumbnail
+ {
+ get;
+ internal set;
+ }
+ }
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+using System;
+
+namespace Tizen.Multimedia
+{
+ /// <summary>
+ /// The class containing image data which has two planes.
+ /// </summary>
+ public class DoublePlaneData : PreviewData
+ {
+ internal DoublePlaneData()
+ {
+ }
+
+ /// <summary>
+ /// The Y plane data.
+ /// </summary>
+ public byte[] YData
+ {
+ get;
+ internal set;
+ }
+
+ /// <summary>
+ /// The UV plane data.
+ /// </summary>
+ public byte[] UVData
+ {
+ get;
+ internal set;
+ }
+ }
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+using System;
+
+namespace Tizen.Multimedia
+{
+ /// <summary>
+ /// The class containing Encoded image data.
+ /// </summary>
+ public class EncodedPlaneData : PreviewData
+ {
+ internal EncodedPlaneData()
+ {
+ }
+
+ /// <summary>
+ /// The buffer containing encoded image data.
+ /// </summary>
+ public byte[] Data
+ {
+ get;
+ internal set;
+ }
+ }
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+using System;
+
+namespace Tizen.Multimedia
+{
+ /// <summary>
+ /// The class contains the details of the detected face.
+ /// </summary>
+ public class FaceDetectedData
+ {
+ private int _id;
+ private int _score;
+ private int _x;
+ private int _y;
+ private int _width;
+ private int _height;
+
+ internal FaceDetectedData(int id, int score, int x, int y, int width, int height)
+ {
+ _id = id;
+ _score = score;
+ _x = x;
+ _y = y;
+ _width = width;
+ _height = height;
+ }
+
+ /// <summary>
+ /// The Id of each face.
+ /// </summary>
+ public int Id
+ {
+ get
+ {
+ return _id;
+ }
+ }
+
+ /// <summary>
+ /// The confidence level for the detection of the face.
+ /// </summary>
+ public int Score
+ {
+ get
+ {
+ return _score;
+ }
+ }
+
+ /// <summary>
+ /// The X co-ordinate of the face.
+ /// </summary>
+ public int X
+ {
+ get
+ {
+ return _x;
+ }
+ }
+
+ /// <summary>
+ /// The Y co-ordinate of the face.
+ /// </summary>
+ public int Y
+ {
+ get
+ {
+ return _y;
+ }
+ }
+
+ /// <summary>
+ /// The width of the face.
+ /// </summary>
+ public int Width
+ {
+ get
+ {
+ return _width;
+ }
+ }
+
+ /// <summary>
+ /// The height of the face.
+ /// </summary>
+ public int Height
+ {
+ get
+ {
+ return _height;
+ }
+ }
+ }
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+using System;
+using System.Collections.Generic;
+
+namespace Tizen.Multimedia
+{
+ /// <summary>
+ /// An extended EventArgs class which contains details about all the faces detected.
+ /// </summary>
+ public class FaceDetectedEventArgs : EventArgs
+ {
+ private readonly List<FaceDetectedData> _faces;
+ internal FaceDetectedEventArgs(List<FaceDetectedData> faces)
+ {
+ _faces = new List<FaceDetectedData>(faces);
+ }
+
+ /// <summary>
+ /// List containing faces of type <see cref="Tizen.Multimedia.FaceDetectedData"/>.
+ /// </summary>
+ public IEnumerable<FaceDetectedData> Faces
+ {
+ get
+ {
+ return _faces;
+ }
+ }
+ }
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+using System;
+
+namespace Tizen.Multimedia
+{
+ /// <summary>
+ /// An extended EventArgs class which contains details about the hdr capture progress.
+ /// </summary>
+ public class HdrCaptureProgressEventArgs : EventArgs
+ {
+ internal HdrCaptureProgressEventArgs(int percent)
+ {
+ Percent = percent;
+ }
+
+ /// <summary>
+ /// Hdr Capture progress in percent.
+ /// </summary>
+ public int Percent
+ {
+ get;
+ internal set;
+ }
+ }
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+using System;
+using System.Runtime.InteropServices;
+
+namespace Tizen.Multimedia
+{
+ /// <summary>
+ /// The class containing the captured image data.
+ /// </summary>
+ public class ImageData
+ {
+ internal byte[] _data;
+ internal int _width;
+ internal int _height;
+ internal CameraPixelFormat _format;
+ internal byte[] _exif;
+
+ internal ImageData()
+ {
+ }
+
+ /// <summary>
+ /// The buffer containing image data.
+ /// </summary>
+ public byte[] Data
+ {
+ get
+ {
+ return _data;
+ }
+ }
+
+ /// <summary>
+ /// The width of the image.
+ /// </summary>
+ public int Width
+ {
+ get
+ {
+ return _width;
+ }
+ }
+
+ /// <summary>
+ /// The height of the image.
+ /// </summary>
+ public int Height
+ {
+ get
+ {
+ return _height;
+ }
+ }
+
+ /// <summary>
+ /// The pixel format of the captured image.
+ /// </summary>
+ public CameraPixelFormat Format
+ {
+ get
+ {
+ return _format;
+ }
+ }
+
+ /// <summary>
+ /// String containing Exif data.
+ /// </summary>
+ public byte[] Exif
+ {
+ get
+ {
+ return _exif;
+ }
+ }
+ }
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+namespace Tizen.Multimedia
+{
+ /// <summary>
+ /// Location class containing GPS data details.
+ /// </summary>
+ public class Location
+ {
+ /// <summary>
+ /// Public constructor.
+ /// </summary
+ /// <param name="latitude">Latitude data</param>
+ /// <param name="longitude">Longitude data</param>
+ /// <param name="altitude">Altitude data</param>
+ public Location(double latitude, double longitude, double altitude)
+ {
+ Latitude = latitude;
+ Longitude = longitude;
+ Altitude = altitude;
+ }
+
+ /// <summary>
+ /// The Latitude data.
+ /// </summary>
+ public double Latitude
+ {
+ get;
+ private set;
+ }
+
+ /// <summary>
+ /// The Longitude data.
+ /// </summary>
+ public double Longitude
+ {
+ get;
+ private set;
+ }
+
+ /// <summary>
+ /// The Altitude data.
+ /// </summary>
+ public double Altitude
+ {
+ get;
+ private set;
+ }
+ }
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+using System;
+namespace Tizen.Multimedia
+{
+ /// <summary>
+ /// An extended EventArgs class which contains details about the Media packet preview frame.
+ /// </summary>
+ public class MediaPacketPreviewEventArgs : EventArgs
+ {
+ internal MediaPacketPreviewEventArgs(MediaPacket packet)
+ {
+ Packet = packet;
+ }
+
+ /// <summary>
+ /// Media Packet data.
+ /// </summary>
+ public MediaPacket Packet
+ {
+ get;
+ internal set;
+ }
+ }
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+namespace Tizen.Multimedia
+{
+ /// <summary>
+ /// The class containing preview image data.
+ /// </summary>
+ public class PreviewData
+ {
+ internal PreviewData()
+ {
+ }
+
+ /// <summary>
+ /// The pixel format of the image.
+ /// </summary>
+ public CameraPixelFormat Format
+ {
+ get;
+ internal set;
+ }
+
+ /// <summary>
+ /// The width of the image.
+ /// </summary>
+ public int Width
+ {
+ get;
+ internal set;
+ }
+
+ /// <summary>
+ /// The height of the image.
+ /// </summary>
+ public int Height
+ {
+ get;
+ internal set;
+ }
+
+ /// <summary>
+ /// The time of capture of the image.
+ /// </summary>
+ public uint TimeStamp
+ {
+ get;
+ internal set;
+ }
+ }
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+using System;
+namespace Tizen.Multimedia
+{
+ /// <summary>
+ /// An extended EventArgs class which contains details about the preview frame.
+ /// </summary>
+ public class PreviewEventArgs : EventArgs
+ {
+ internal PreviewEventArgs(PreviewData frame, PlaneType type)
+ {
+ Frame = frame;
+ Type = type;
+ }
+
+ /// <summary>
+ /// PreviewData frame.
+ /// </summary>
+ public PreviewData Frame
+ {
+ get;
+ internal set;
+ }
+
+ /// <summary>
+ /// Number of planes in image data.
+ /// </summary>
+ public PlaneType Type
+ {
+ get;
+ internal set;
+ }
+ }
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+namespace Tizen.Multimedia
+{
+ /// <summary>
+ /// Range class containing min and max value.
+ /// </summary>
+ public class Range
+ {
+ internal Range(int min, int max)
+ {
+ Min = min;
+ Max = max;
+ }
+
+ /// <summary>
+ /// The minimum value of the range.
+ /// </summary>
+ public int Min
+ {
+ get;
+ private set;
+ }
+
+ /// <summary>
+ /// The maximum value of the range.
+ /// </summary>
+ public int Max
+ {
+ get;
+ private set;
+ }
+ }
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+using System;
+
+namespace Tizen.Multimedia
+{
+ /// <summary>
+ /// The class containing image data which has single plane.
+ /// </summary>
+ public class SinglePlaneData : PreviewData
+ {
+ internal SinglePlaneData()
+ {
+ }
+
+ /// <summary>
+ /// The YUV plane data.
+ /// </summary>
+ public byte[] YUVData
+ {
+ get;
+ internal set;
+ }
+ }
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+using System;
+
+namespace Tizen.Multimedia
+{
+ /// <summary>
+ /// The class containing image data which has three planes.
+ /// </summary>
+ public class TriplePlaneData : PreviewData
+ {
+ internal TriplePlaneData()
+ {
+ }
+
+ /// <summary>
+ /// The Y plane data.
+ /// </summary>
+ public byte[] YData
+ {
+ get;
+ internal set;
+ }
+
+ /// <summary>
+ /// The U plane data.
+ /// </summary>
+ public byte[] UData
+ {
+ get;
+ internal set;
+ }
+
+ /// <summary>
+ /// The V plane data.
+ /// </summary>
+ public byte[] VData
+ {
+ get;
+ internal set;
+ }
+ }
+}
+
--- /dev/null
+using System;
+using System.Runtime.InteropServices;
+using System.Runtime.CompilerServices;
+using Tizen.Multimedia;
+
+internal static partial class Interop
+{
+ internal static partial class Camera
+ {
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate void FaceDetectedCallback(IntPtr faces, int count, IntPtr userData);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate void StateChangedCallback(CameraState previous, CameraState current, bool byPolicy, IntPtr userData);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate void InterruptedCallback(CameraPolicy policy, CameraState previous, CameraState current, IntPtr userData);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate void FocusChangedCallback(CameraFocusState state, IntPtr userData);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate void ErrorCallback(CameraErrorCode error, CameraState current, IntPtr userData);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate void CapturingCallback(IntPtr image, IntPtr postview, IntPtr thumbnail, IntPtr userData);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate void CaptureCompletedCallback(IntPtr userData);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate void PreviewCallback(IntPtr frame, IntPtr userData);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate void MediaPacketPreviewCallback(IntPtr mediaPacketHandle, IntPtr userData);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate void HdrCaptureProgressCallback(int percent, IntPtr userData);
+
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_create")]
+ internal static extern int Create(int device, out IntPtr handle);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_change_device")]
+ internal static extern int ChangeDevice(IntPtr handle, int device);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_destroy")]
+ internal static extern int Destroy(IntPtr handle);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_get_device_count")]
+ internal static extern int GetDeviceCount(IntPtr handle, out int count);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_start_preview")]
+ internal static extern int StartPreview(IntPtr handle);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_stop_preview")]
+ internal static extern int StopPreview(IntPtr handle);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_get_device_state")]
+ internal static extern int GetDeviceState(CameraDevice device, out int state);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_start_capture")]
+ internal static extern int StartCapture(IntPtr handle, CapturingCallback captureCallback,
+ CaptureCompletedCallback completedCallback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_start_continuous_capture")]
+ internal static extern int StartContinuousCapture(IntPtr handle, int count, int interval,
+ CapturingCallback captureCallback, CaptureCompletedCallback completedCallback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_stop_continuous_capture")]
+ internal static extern int StopContinuousCapture(IntPtr handle);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_get_state")]
+ internal static extern int GetState(IntPtr handle, out int state);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_start_focusing")]
+ internal static extern int StartFocusing(IntPtr handle, bool continuous);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_cancel_focusing")]
+ internal static extern int CancelFocusing(IntPtr handle);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_set_display")]
+ internal static extern int SetDisplay(IntPtr handle, int displayType, IntPtr displayHandle);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_set_preview_resolution")]
+ internal static extern int SetPreviewResolution(IntPtr handle, int width, int height);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_get_preview_resolution")]
+ internal static extern int GetPreviewResolution(IntPtr handle, out int width, out int height);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_get_recommended_preview_resolution")]
+ internal static extern int GetRecommendedPreviewResolution(IntPtr handle, out int width, out int height);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_start_face_detection")]
+ internal static extern int StartFaceDetection(IntPtr handle, FaceDetectedCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_stop_face_detection")]
+ internal static extern int StopFaceDetection(IntPtr handle);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_set_display_reuse_hint")]
+ internal static extern int SetDisplayReuseHint(IntPtr handle, bool hint);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_get_display_reuse_hint")]
+ internal static extern int GetDisplayReuseHint(IntPtr handle, out bool hint);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_set_capture_resolution")]
+ internal static extern int SetCaptureResolution(IntPtr handle, int width, int height);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_get_capture_resolution")]
+ internal static extern int GetCaptureResolution(IntPtr handle, out int width, out int height);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_set_capture_format")]
+ internal static extern int SetCaptureFormat(IntPtr handle, int format);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_get_capture_format")]
+ internal static extern int GetCaptureFormat(IntPtr handle, out int format);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_set_preview_format")]
+ internal static extern int SetPreviewFormat(IntPtr handle, int format);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_get_preview_format")]
+ internal static extern int GetPreviewFormat(IntPtr handle, out int format);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_get_facing_direction")]
+ internal static extern int GetFacingDirection(IntPtr handle, out int direction);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_get_flash_state")]
+ internal static extern int GetFlashState(IntPtr handle, out int state);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_set_preview_cb")]
+ internal static extern int SetPreviewCallback(IntPtr handle, PreviewCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_unset_preview_cb")]
+ internal static extern int UnsetPreviewCallback(IntPtr handle);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_set_media_packet_preview_cb")]
+ internal static extern int SetMediaPacketPreviewCallback(IntPtr handle, MediaPacketPreviewCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_unset_media_packet_preview_cb")]
+ internal static extern int UnsetMediaPacketPreviewCallback(IntPtr handle);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_set_state_changed_cb")]
+ internal static extern int SetStateChangedCallback(IntPtr handle, StateChangedCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_unset_state_changed_cb")]
+ internal static extern int UnsetStateChangedCallback(IntPtr handle);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_remove_device_state_changed_cb")]
+ internal static extern int UnsetDeviceStateChangedCallback(int cbId);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_set_interrupted_cb")]
+ internal static extern int SetInterruptedCallback(IntPtr handle, InterruptedCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_unset_interrupted_cb")]
+ internal static extern int UnsetInterruptedCallback(IntPtr handle);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_set_focus_changed_cb")]
+ internal static extern int SetFocusChangedCallback(IntPtr handle, FocusChangedCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_unset_focus_changed_cb")]
+ internal static extern int UnsetFocusChangedCallback(IntPtr handle);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_set_error_cb")]
+ internal static extern int SetErrorCallback(IntPtr handle, ErrorCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_unset_error_cb")]
+ internal static extern int UnsetErrorCallback(IntPtr handle);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_hdr_capture_progress_cb")]
+ internal static extern int SetHdrCaptureProgressCallback(IntPtr handle, HdrCaptureProgressCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_unset_hdr_capture_progress_cb")]
+ internal static extern int UnsetHdrCaptureProgressCallback(IntPtr handle);
+
+ [StructLayout(LayoutKind.Sequential)]
+ internal struct ImageDataStruct
+ {
+ internal IntPtr data;
+ internal uint size;
+ internal int width;
+ internal int height;
+ internal CameraPixelFormat format;
+ internal IntPtr exif;
+ internal uint exifSize;
+ }
+
+ internal static ImageDataStruct IntPtrToImageDataStruct(IntPtr unmanagedVariable)
+ {
+ ImageDataStruct ImageStruct = (ImageDataStruct)Marshal.PtrToStructure(unmanagedVariable, typeof(ImageDataStruct));
+ return ImageStruct;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ internal struct DetectedFaceStruct
+ {
+ internal int id;
+ internal int score;
+ internal int x;
+ internal int y;
+ internal int width;
+ internal int height;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ internal struct SinglePlane
+ {
+ internal IntPtr yuv;
+ internal uint yuvsize;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ internal struct DoublePlane
+ {
+ internal IntPtr y;
+ internal IntPtr uv;
+ internal uint ysize;
+ internal uint uvsize;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ internal struct TriplePlane
+ {
+ internal IntPtr y;
+ internal IntPtr u;
+ internal IntPtr v;
+ internal uint ysize;
+ internal uint usize;
+ internal uint vsize;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ internal struct EncodedPlane
+ {
+ internal IntPtr data;
+ internal uint size;
+ }
+
+ [StructLayout(LayoutKind.Explicit)]
+ internal struct PlaneData
+ {
+ [FieldOffsetAttribute(0)]
+ internal SinglePlane singlePlane;
+ [FieldOffsetAttribute(0)]
+ internal DoublePlane doublePlane;
+ [FieldOffsetAttribute(0)]
+ internal TriplePlane triplePlane;
+ [FieldOffsetAttribute(0)]
+ internal EncodedPlane encodedPlane;
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ internal struct CameraPreviewDataStruct
+ {
+ internal CameraPixelFormat format;
+ internal int width;
+ internal int height;
+ internal int numOfPlanes;
+ internal uint timestamp;
+ internal PlaneData frameData;
+ }
+
+ internal static CameraPreviewDataStruct IntPtrToCameraPreviewDataStruct(IntPtr unmanagedVariable)
+ {
+ CameraPreviewDataStruct PreviewDataStruct = (CameraPreviewDataStruct)Marshal.PtrToStructure(unmanagedVariable, typeof(CameraPreviewDataStruct));
+ return PreviewDataStruct;
+ }
+ }
+}
--- /dev/null
+using System;
+using System.Runtime.InteropServices;
+using Tizen.Multimedia;
+
+internal static partial class Interop
+{
+ internal static partial class CameraDisplay
+ {
+ [DllImport(Libraries.Camera, EntryPoint = "camera_set_display_rotation")]
+ internal static extern int SetDisplayRotation(IntPtr handle, int rotation);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_get_display_rotation")]
+ internal static extern int GetDisplayRotation(IntPtr handle, out int rotation);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_set_display_flip")]
+ internal static extern int SetDisplayFlip(IntPtr handle, int flip);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_get_display_flip")]
+ internal static extern int GetDisplayFlip(IntPtr handle, out int flip);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_set_display_visible")]
+ internal static extern int SetDisplayVisible(IntPtr handle, bool visible);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_is_display_visible")]
+ internal static extern int GetDisplayVisible(IntPtr handle, out bool visible);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_set_display_mode")]
+ internal static extern int SetDisplayMode(IntPtr handle, int mode);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_get_display_mode")]
+ internal static extern int GetDisplayMode(IntPtr handle, out int mode);
+ }
+}
--- /dev/null
+using System;
+using System.Runtime.InteropServices;
+using Tizen.Multimedia;
+
+internal static partial class Interop
+{
+ internal static partial class CameraFeature
+ {
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate bool PreviewResolutionCallback(int Width, int Height, IntPtr userData);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate bool CaptureResolutionCallback(int Width, int Height, IntPtr userData);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate bool CaptureFormatCallback(CameraPixelFormat format, IntPtr userData);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate bool PreviewFormatCallback(CameraPixelFormat format, IntPtr userData);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate bool FpsCallback(CameraFps fps, IntPtr userData);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate bool FpsByResolutionCallback(CameraFps fps, IntPtr userData);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate bool AfModeCallback(CameraAutoFocusMode mode, IntPtr userData);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate bool ExposureModeCallback(CameraExposureMode mode, IntPtr userData);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate bool IsoCallback(CameraIsoLevel iso, IntPtr userData);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate bool TheaterModeCallback(CameraTheaterMode mode, IntPtr userData);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate bool WhitebalanceCallback(CameraWhitebalance whitebalance, IntPtr userData);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate bool EffectCallback(CameraEffectMode effect, IntPtr userData);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate bool SceneModeCallback(CameraSceneMode mode, IntPtr userData);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate bool FlashModeCallback(CameraFlashMode mode, IntPtr userData);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate bool StreamRotationCallback(CameraRotation rotation, IntPtr userData);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate bool StreamFlipCallback(CameraFlip flip, IntPtr userData);
+
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate bool PtzTypeCallback(CameraPtzType type, IntPtr userData);
+
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_is_supported_continuous_capture")]
+ internal static extern bool ContinuousCaptureSupport(IntPtr handle);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_is_supported_face_detection")]
+ internal static extern bool FaceDetectionSupport(IntPtr handle);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_is_supported_zero_shutter_lag")]
+ internal static extern bool ZeroShutterLagSupport(IntPtr handle);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_is_supported_media_packet_preview_cb")]
+ internal static extern bool MediaPacketPreviewCallbackSupport(IntPtr handle);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_is_supported_hdr_capture")]
+ internal static extern bool HdrCaptureSupport(IntPtr handle);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_is_supported_anti_shake")]
+ internal static extern bool AntiShakeSupport(IntPtr handle);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_is_supported_video_stabilization")]
+ internal static extern bool VideoStabilizationSupport(IntPtr handle);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_is_supported_auto_contrast")]
+ internal static extern bool AutoContrastSupport(IntPtr handle);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_foreach_supported_preview_resolution")]
+ internal static extern int SupportedPreviewResolutions(IntPtr handle, PreviewResolutionCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_foreach_supported_capture_resolution")]
+ internal static extern int SupportedCaptureResolutions(IntPtr handle, CaptureResolutionCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_foreach_supported_capture_format")]
+ internal static extern int SupportedCaptureFormats(IntPtr handle, CaptureFormatCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_foreach_supported_preview_format")]
+ internal static extern int SupportedPreviewFormats(IntPtr handle, PreviewFormatCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_foreach_supported_fps")]
+ internal static extern int SupportedFps(IntPtr handle, FpsCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_foreach_supported_fps_by_resolution")]
+ internal static extern int SupportedFpsByResolution(IntPtr handle, int width, int height, FpsByResolutionCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_foreach_supported_af_mode")]
+ internal static extern int SupportedAfModes(IntPtr handle, AfModeCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_foreach_supported_exposure_mode")]
+ internal static extern int SupportedExposureModes(IntPtr handle, ExposureModeCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_foreach_supported_iso")]
+ internal static extern int SupportedIso(IntPtr handle, IsoCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_foreach_supported_theater_mode")]
+ internal static extern int SupportedTheaterModes(IntPtr handle, TheaterModeCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_foreach_supported_whitebalance")]
+ internal static extern int SupportedWhitebalance(IntPtr handle, WhitebalanceCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_foreach_supported_effect")]
+ internal static extern int SupportedEffects(IntPtr handle, EffectCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_foreach_supported_scene_mode")]
+ internal static extern int SupportedSceneModes(IntPtr handle, SceneModeCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_foreach_supported_flash_mode")]
+ internal static extern int SupportedFlashModes(IntPtr handle, FlashModeCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_foreach_supported_stream_rotation")]
+ internal static extern int SupportedStreamRotations(IntPtr handle, StreamRotationCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_foreach_supported_stream_flip")]
+ internal static extern int SupportedStreamFlips(IntPtr handle, StreamFlipCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_foreach_supported_ptz_type")]
+ internal static extern int SupportedPtzTypes(IntPtr handle, PtzTypeCallback callback, IntPtr userData);
+ }
+}
--- /dev/null
+using System;
+using System.Runtime.InteropServices;
+using Tizen.Multimedia;
+
+internal static partial class Interop
+{
+ internal static partial class CameraSetting
+ {
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_preview_fps")]
+ internal static extern int SetPreviewFps(IntPtr handle, int fps);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_preview_fps")]
+ internal static extern int GetPreviewFps(IntPtr handle, out int fps);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_image_quality")]
+ internal static extern int SetImageQuality(IntPtr handle, int quality);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_image_quality")]
+ internal static extern int GetImageQuality(IntPtr handle, out int quality);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_encoded_preview_bitrate")]
+ internal static extern int SetBitrate(IntPtr handle, int bitrate);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_encoded_preview_bitrate")]
+ internal static extern int GetBitrate(IntPtr handle, out int bitrate);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_encoded_preview_gop_interval")]
+ internal static extern int SetGopInterval(IntPtr handle, int interval);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_encoded_preview_gop_interval")]
+ internal static extern int GetGopInterval(IntPtr handle, out int interval);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_zoom")]
+ internal static extern int SetZoom(IntPtr handle, int zoom);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_zoom")]
+ internal static extern int GetZoom(IntPtr handle, out int zoom);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_zoom_range")]
+ internal static extern int GetZoomRange(IntPtr handle, out int min, out int max);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_af_mode")]
+ internal static extern int SetAfMode(IntPtr handle, int mode);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_af_mode")]
+ internal static extern int GetAfMode(IntPtr handle, out int mode);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_af_area")]
+ internal static extern int SetAfArea(IntPtr handle, int x, int y);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_clear_af_area")]
+ internal static extern int ClearAfArea(IntPtr handle);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_exposure_mode")]
+ internal static extern int SetExposureMode(IntPtr handle, int mode);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_exposure_mode")]
+ internal static extern int GetExposureMode(IntPtr handle, out int mode);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_exposure")]
+ internal static extern int SetExposure(IntPtr handle, int value);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_exposure")]
+ internal static extern int GetExposure(IntPtr handle, out int value);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_exposure_range")]
+ internal static extern int GetExposureRange(IntPtr handle, out int min, out int max);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_iso")]
+ internal static extern int SetIso(IntPtr handle, int iso);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_iso")]
+ internal static extern int GetIso(IntPtr handle, out int iso);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_theater_mode")]
+ internal static extern int SetTheaterMode(IntPtr handle, int mode);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_theater_mode")]
+ internal static extern int GetTheaterMode(IntPtr handle, out int mode);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_brightness")]
+ internal static extern int SetBrightness(IntPtr handle, int level);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_brightness")]
+ internal static extern int GetBrightness(IntPtr handle, out int level);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_brightness_range")]
+ internal static extern int GetBrightnessRange(IntPtr handle, out int min, out int max);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_contrast")]
+ internal static extern int SetContrast(IntPtr handle, int level);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_contrast")]
+ internal static extern int GetContrast(IntPtr handle, out int level);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_contrast_range")]
+ internal static extern int GetContrastRange(IntPtr handle, out int min, out int max);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_whitebalance")]
+ internal static extern int SetWhitebalance(IntPtr handle, int level);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_whitebalance")]
+ internal static extern int GetWhitebalance(IntPtr handle, out int level);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_effect")]
+ internal static extern int SetEffect(IntPtr handle, int level);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_effect")]
+ internal static extern int GetEffect(IntPtr handle, out int level);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_scene_mode")]
+ internal static extern int SetSceneMode(IntPtr handle, int level);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_scene_mode")]
+ internal static extern int GetSceneMode(IntPtr handle, out int level);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_enable_tag")]
+ internal static extern int EnableTag(IntPtr handle, bool enable);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_is_enabled_tag")]
+ internal static extern int IsEnabledTag(IntPtr handle, out bool enabled);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_tag_image_description")]
+ internal static extern int SetImageDescription(IntPtr handle, string description);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_tag_image_description")]
+ internal static extern int GetImageDescription(IntPtr handle, out IntPtr description);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_tag_software")]
+ internal static extern int SetTagSoftware(IntPtr handle, string software);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_tag_software")]
+ internal static extern int GetTagSoftware(IntPtr handle, out IntPtr software);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_tag_orientation")]
+ internal static extern int SetTagOrientation(IntPtr handle, int orientation);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_tag_orientation")]
+ internal static extern int GetTagOrientation(IntPtr handle, out int orientation);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_geotag")]
+ internal static extern int SetGeotag(IntPtr handle, double latitude, double longtitude, double altitude);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_geotag")]
+ internal static extern int GetGeotag(IntPtr handle, out double latitude, out double longtitude, out double altitude);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_remove_geotag")]
+ internal static extern int RemoveGeotag(IntPtr handle);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_flash_mode")]
+ internal static extern int SetFlashMode(IntPtr handle, int mode);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_flash_mode")]
+ internal static extern int GetFlashMode(IntPtr handle, out int mode);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_lens_orientation")]
+ internal static extern int GetLensOrientation(IntPtr handle, out int angle);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_stream_rotation")]
+ internal static extern int SetStreamRotation(IntPtr handle, int mode);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_stream_rotation")]
+ internal static extern int GetStreamRotation(IntPtr handle, out int mode);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_stream_flip")]
+ internal static extern int SetFlip(IntPtr handle, int flip);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_stream_flip")]
+ internal static extern int GetFlip(IntPtr handle, out int flip);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_hdr_mode")]
+ internal static extern int SetHdrMode(IntPtr handle, int hdr);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_hdr_mode")]
+ internal static extern int GetHdrMode(IntPtr handle, out int hdr);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_enable_anti_shake")]
+ internal static extern int EnableAntiShake(IntPtr handle, bool enable);
+
+ [DllImport(Libraries.Camera, EntryPoint = " camera_attr_is_enabled_anti_shake")]
+ internal static extern int IsEnabledAntiShake(IntPtr handle, out bool enabled);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_enable_video_stabilization")]
+ internal static extern int EnableVideoStabilization(IntPtr handle, bool enable);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_is_enabled_video_stabilization")]
+ internal static extern int IsEnabledVideoStabilization(IntPtr handle, out bool enabled);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_enable_auto_contrast")]
+ internal static extern int EnableAutoContrast(IntPtr handle, bool enable);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_is_enabled_auto_contrast")]
+ internal static extern int IsEnabledAutoContrast(IntPtr handle, out bool enabled);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_disable_shutter_sound")]
+ internal static extern int DisableShutterSound(IntPtr handle, bool disable);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_pan")]
+ internal static extern int SetPan(IntPtr handle, int type, int step);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_pan")]
+ internal static extern int GetPan(IntPtr handle, out int step);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_pan_range")]
+ internal static extern int GetPanRange(IntPtr handle, out int min, out int max);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_tilt")]
+ internal static extern int SetTilt(IntPtr handle, int type, int step);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_tilt")]
+ internal static extern int GetTilt(IntPtr handle, out int step);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_tilt_range")]
+ internal static extern int GetTiltRange(IntPtr handle, out int min, out int max);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_ptz_type")]
+ internal static extern int SetPtzType(IntPtr handle, int type);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_set_display_roi_area")]
+ internal static extern int SetDisplayRoiArea(IntPtr handle, int x, int y, int width, int height);
+
+ [DllImport(Libraries.Camera, EntryPoint = "camera_attr_get_display_roi_area")]
+ internal static extern int GetDisplayRoiArea(IntPtr handle, out int x, out int y, out int width, out int height);
+ }
+}
+
public const string MediaTool = "libcapi-media-tool.so.0";
public const string MediaCodec = "libcapi-media-codec.so.0";
public const string Libc = "libc.so.6";
+ public const string Camera = "libcapi-media-camera.so.0";
}
}
internal static partial class Interop
{
- internal static partial class Libc
- {
- [DllImport(Libraries.Libc, EntryPoint = "free")]
- public static extern void Free(IntPtr userData);
+ internal static partial class Libc
+ {
+ [DllImport(Libraries.Libc, EntryPoint = "free")]
+ public static extern void Free(IntPtr userData);
+ }
- }
-
- internal static partial class Recorder
- {
+ internal static partial class Recorder
+ {
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate void RecordingLimitReachedCallback(RecordingLimitType type, IntPtr userData);
- [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
- internal delegate void RecordingLimitReachedCallback(RecordingLimitType type, IntPtr userData);
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate void RecordingStatusCallback(ulong elapsedTime, ulong fileSize, IntPtr userData);
- [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
- internal delegate void RecordingStatusCallback(ulong elapsedTime, ulong fileSize, IntPtr userData);
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate void StatechangedCallback(RecorderState previous, RecorderState current, bool byPolicy, IntPtr userData);
- [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
- internal delegate void StatechangedCallback(RecorderState previous, RecorderState current, bool byPolicy, IntPtr userData);
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate void InterruptedCallback(RecorderPolicy policy, RecorderState previous, RecorderState current, IntPtr userData);
- [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
- internal delegate void InterruptedCallback(RecorderPolicy policy, RecorderState previous, RecorderState current, IntPtr userData);
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate void AudioStreamCallback(IntPtr stream, int size, AudioSampleType type, int channel, uint timeStamp, IntPtr userData);
- [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
- internal delegate void AudioStreamCallback(IntPtr stream, int size, AudioSampleType type, int channel, uint timeStamp, IntPtr userData);
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+ internal delegate void RecorderErrorCallback(RecorderErrorCode error, RecorderState current, IntPtr userData);
- [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
- internal delegate void RecorderErrorCallback(RecorderErrorCode error, RecorderState current, IntPtr userData);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_create_videorecorder")]
+ internal static extern int CreateVideo(Tizen.Multimedia.Camera camera, out IntPtr handle);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_create_videorecorder")]
- internal static extern int Create(Camera camera, out IntPtr handle);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_create_audiorecorder")]
+ internal static extern int Create(out IntPtr handle);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_create_audiorecorder")]
- internal static extern int Create(out IntPtr handle);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_destroy")]
+ internal static extern int Destroy(IntPtr handle);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_destroy")]
- internal static extern int Destroy(IntPtr handle);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_prepare")]
+ internal static extern int Prepare(IntPtr handle);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_prepare")]
- internal static extern int Prepare(IntPtr handle);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_unprepare")]
+ internal static extern int Unprepare(IntPtr handle);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_unprepare")]
- internal static extern int Unprepare(IntPtr handle);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_start")]
+ internal static extern int Start(IntPtr handle);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_start")]
- internal static extern int Start(IntPtr handle);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_pause")]
+ internal static extern int Pause(IntPtr handle);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_pause")]
- internal static extern int Pause(IntPtr handle);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_commit")]
+ internal static extern int Commit(IntPtr handle);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_commit")]
- internal static extern int Commit(IntPtr handle);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_cancel")]
+ internal static extern int Cancel(IntPtr handle);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_cancel")]
- internal static extern int Cancel(IntPtr handle);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_get_state")]
+ internal static extern int GetState(IntPtr handle, out int state);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_get_state")]
- internal static extern int GetState(IntPtr handle, out int state);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_get_audio_level")]
+ internal static extern int GetAudioLevel(IntPtr handle, out double dB);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_get_audio_level")]
- internal static extern int GetAudioLevel(IntPtr handle, out double dB);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_set_filename")]
+ internal static extern int SetFileName(IntPtr handle, string path);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_set_filename")]
- internal static extern int SetFileName(IntPtr handle, string path);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_get_filename")]
+ internal static extern int GetFileName(IntPtr handle, out IntPtr path);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_get_filename")]
- internal static extern int GetFileName(IntPtr handle, out IntPtr path);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_set_file_format")]
+ internal static extern int SetFileFormat(IntPtr handle, int format);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_set_file_format")]
- internal static extern int SetFileFormat(IntPtr handle, int format);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_get_file_format")]
+ internal static extern int GetFileFormat(IntPtr handle, out int format);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_get_file_format")]
- internal static extern int GetFileFormat(IntPtr handle, out int format);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_set_sound_stream_info")]
+ internal static extern int SetAudioStreamPolicy(IntPtr handle, IntPtr streamInfoHandle);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_set_sound_stream_info")]
- internal static extern int SetAudioStreamPolicy (IntPtr handle, IntPtr streamInfoHandle);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_set_audio_encoder")]
+ internal static extern int SetAudioEncoder(IntPtr handle, int codec);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_set_audio_encoder")]
- internal static extern int SetAudioEncoder(IntPtr handle, int codec);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_get_audio_encoder")]
+ internal static extern int GetAudioEncoder(IntPtr handle, out int codec);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_get_audio_encoder")]
- internal static extern int GetAudioEncoder(IntPtr handle, out int codec);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_set_video_encoder")]
+ internal static extern int SetVideoEncoder(IntPtr handle, int codec);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_set_video_encoder")]
- internal static extern int SetVideoEncoder(IntPtr handle, int codec);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_get_video_encoder")]
+ internal static extern int GetVideoEncoder(IntPtr handle, out int codec);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_get_video_encoder")]
- internal static extern int GetVideoEncoder(IntPtr handle, out int codec);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_set_video_resolution")]
+ internal static extern int SetVideoResolution(IntPtr handle, int width, int height);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_set_video_resolution")]
- internal static extern int SetVideoResolution(IntPtr handle, int width, int height);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_get_video_resolution")]
+ internal static extern int GetVideoResolution(IntPtr handle, out int width, out int height);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_get_video_resolution")]
- internal static extern int GetVideoResolution(IntPtr handle, out int width, out int height);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_set_state_changed_cb")]
+ internal static extern int SetStateChangedCallback(IntPtr handle, StatechangedCallback callback, IntPtr userData);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_set_state_changed_cb")]
- internal static extern int SetStateChangedCallback(IntPtr handle, StatechangedCallback callback, IntPtr userData);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_unset_state_changed_cb")]
- internal static extern int UnsetStateChangedCallback(IntPtr handle);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_unset_state_changed_cb")]
+ internal static extern int UnsetStateChangedCallback(IntPtr handle);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_set_recording_status_cb")]
- internal static extern int SetStatusChangedCallback(IntPtr handle, RecordingStatusCallback callback, IntPtr userData);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_unset_recording_status_cb")]
- internal static extern int UnsetStatusChangedCallback(IntPtr handle);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_set_recording_status_cb")]
+ internal static extern int SetStatusChangedCallback(IntPtr handle, RecordingStatusCallback callback, IntPtr userData);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_set_interrupted_cb")]
- internal static extern int SetInterruptedCallback(IntPtr handle, InterruptedCallback callback, IntPtr userData);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_unset_interrupted_cb")]
- internal static extern int UnsetInterruptedCallback(IntPtr handle);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_unset_recording_status_cb")]
+ internal static extern int UnsetStatusChangedCallback(IntPtr handle);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_set_audio_stream_cb")]
- internal static extern int SetAudioStreamCallback(IntPtr handle, AudioStreamCallback callback, IntPtr userData);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_unset_audio_stream_cb")]
- internal static extern int UnsetAudioStreamCallback(IntPtr handle);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_set_interrupted_cb")]
+ internal static extern int SetInterruptedCallback(IntPtr handle, InterruptedCallback callback, IntPtr userData);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_set_recording_limit_reached_cb")]
- internal static extern int SetLimitReachedCallback(IntPtr handle, RecordingLimitReachedCallback callback, IntPtr userData);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_unset_recording_limit_reached_cb")]
- internal static extern int UnsetLimitReachedCallback(IntPtr handle);
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_unset_interrupted_cb")]
+ internal static extern int UnsetInterruptedCallback(IntPtr handle);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_set_error_cb")]
- internal static extern int SetErrorCallback(IntPtr handle, RecorderErrorCallback callback, IntPtr userData);
- [DllImport(Libraries.Recorder, EntryPoint = "recorder_unset_error_cb")]
- internal static extern int UnsetErrorCallback(IntPtr handle);
- }
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_set_audio_stream_cb")]
+ internal static extern int SetAudioStreamCallback(IntPtr handle, AudioStreamCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_unset_audio_stream_cb")]
+ internal static extern int UnsetAudioStreamCallback(IntPtr handle);
+
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_set_recording_limit_reached_cb")]
+ internal static extern int SetLimitReachedCallback(IntPtr handle, RecordingLimitReachedCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_unset_recording_limit_reached_cb")]
+ internal static extern int UnsetLimitReachedCallback(IntPtr handle);
+
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_set_error_cb")]
+ internal static extern int SetErrorCallback(IntPtr handle, RecorderErrorCallback callback, IntPtr userData);
+
+ [DllImport(Libraries.Recorder, EntryPoint = "recorder_unset_error_cb")]
+ internal static extern int UnsetErrorCallback(IntPtr handle);
+ }
}
+++ /dev/null
-using System;
-
-namespace Tizen.Multimedia
-{
- /// <summary>
- /// The Camera API allows application developers to support using the camera
- /// </summary>
- public class Camera
- {
- public Camera()
- {
- }
- }
-}
-
/// </param>
public Recorder(Camera camera)
{
- int ret = Interop.Recorder.Create (camera, out _handle);
+ int ret = Interop.Recorder.CreateVideo (camera, out _handle);
if (ret != (int)RecorderError.None)
{
RecorderErrorFactory.ThrowException (ret, "Failed to create Video recorder");
<Compile Include="AudioIO\AudioStateChangedEventArgs.cs" />
<Compile Include="AudioIO\AudioStreamLengthChangedEventArgs.cs" />
<Compile Include="AudioIO\BaseAudio.cs" />
+ <Compile Include="Camera\Area.cs" />
+ <Compile Include="Camera\Camera.cs" />
+ <Compile Include="Camera\CameraDeviceStateChangedEventArgs.cs" />
+ <Compile Include="Camera\CameraDisplay.cs" />
+ <Compile Include="Camera\CameraEnums.cs" />
+ <Compile Include="Camera\CameraErrorFactory.cs" />
+ <Compile Include="Camera\CameraErrorOccurredEventArgs.cs" />
+ <Compile Include="Camera\CameraFeature.cs" />
+ <Compile Include="Camera\CameraFocusChangedEventArgs.cs" />
+ <Compile Include="Camera\CameraInterruptedEventArgs.cs" />
+ <Compile Include="Camera\CameraResolution.cs" />
+ <Compile Include="Camera\CameraSetting.cs" />
+ <Compile Include="Camera\CameraStateChangedEventArgs.cs" />
+ <Compile Include="Camera\CapturingEventArgs.cs" />
+ <Compile Include="Camera\DoublePlaneData.cs" />
+ <Compile Include="Camera\EncodedPlaneData.cs" />
+ <Compile Include="Camera\FaceDetectedData.cs" />
+ <Compile Include="Camera\FaceDetectedEventArgs.cs" />
+ <Compile Include="Camera\HdrCaptureProgressEventArgs.cs" />
+ <Compile Include="Camera\ImageData.cs" />
+ <Compile Include="Camera\Location.cs" />
+ <Compile Include="Camera\MediaPacketPreviewEventArgs.cs" />
+ <Compile Include="Camera\PreviewData.cs" />
+ <Compile Include="Camera\PreviewEventArgs.cs" />
+ <Compile Include="Camera\Range.cs" />
+ <Compile Include="Camera\SinglePlaneData.cs" />
+ <Compile Include="Camera\TriplePlaneData.cs" />
<Compile Include="Interop\Interop.AudioIO.cs" />
+ <Compile Include="Interop\Interop.Camera.cs" />
+ <Compile Include="Interop\Interop.CameraDisplay.cs" />
+ <Compile Include="Interop\Interop.CameraFeature.cs" />
+ <Compile Include="Interop\Interop.CameraSetting.cs" />
<Compile Include="Interop\Interop.MediaCodec.cs" />
<Compile Include="Interop\Interop.MediaTool.cs" />
<Compile Include="Interop\Interop.EvasObject.cs" />
<Compile Include="Interop\Interop.Libraries.cs" />
<Compile Include="Player\PlayerErrorFactory.cs" />
<Compile Include="Recorder\AudioStreamDeliveredEventArgs.cs" />
- <Compile Include="Recorder\Camera.cs" />
<Compile Include="Recorder\Recorder.cs" />
<Compile Include="Recorder\RecorderEnums.cs" />
<Compile Include="Recorder\RecorderErrorFactory.cs" />
-<?xml version="1.0" encoding="utf-8"?>\r
-<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">\r
- <PropertyGroup>\r
- <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>\r
- <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>\r
- <ProjectGuid>{0CE698B0-4849-4096-9D7F-30E611F50DAD}</ProjectGuid>\r
- <OutputType>Library</OutputType>\r
- <AppDesignerFolder>Properties</AppDesignerFolder>\r
- <RootNamespace>Tizen.Multimedia</RootNamespace>\r
- <AssemblyName>Tizen.Multimedia</AssemblyName>\r
- <FileAlignment>512</FileAlignment>\r
- </PropertyGroup>\r
- <PropertyGroup>\r
- <TargetFrameworkIdentifier>.NETStandard</TargetFrameworkIdentifier>\r
- <TargetFrameworkVersion>v1.3</TargetFrameworkVersion>\r
- <NuGetTargetMoniker>.NETStandard,Version=v1.3</NuGetTargetMoniker>\r
- <AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>\r
- <NoStdLib>true</NoStdLib>\r
- <NoWarn>$(NoWarn);1701;1702</NoWarn>\r
- </PropertyGroup>\r
- <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">\r
- <DebugSymbols>true</DebugSymbols>\r
- <DebugType>full</DebugType>\r
- <Optimize>false</Optimize>\r
- <OutputPath>bin\Debug\</OutputPath>\r
- <DefineConstants>DEBUG;TRACE</DefineConstants>\r
- <ErrorReport>prompt</ErrorReport>\r
- <WarningLevel>4</WarningLevel>\r
- </PropertyGroup>\r
- <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">\r
- <DebugType>pdbonly</DebugType>\r
- <Optimize>true</Optimize>\r
- <OutputPath>bin\Release\</OutputPath>\r
- <DefineConstants>TRACE</DefineConstants>\r
- <ErrorReport>prompt</ErrorReport>\r
- <WarningLevel>4</WarningLevel>\r
- </PropertyGroup>\r
- <PropertyGroup>\r
- <SignAssembly>true</SignAssembly>\r
- </PropertyGroup>\r
- <PropertyGroup>\r
- <AssemblyOriginatorKeyFile>Tizen.Multimedia.snk</AssemblyOriginatorKeyFile>\r
- </PropertyGroup>\r
- <ItemGroup>\r
- <Compile Include="AudioIO\AudioErrorHelper.cs" />\r
- <Compile Include="AudioIO\AudioInput.cs" />\r
- <Compile Include="AudioIO\AudioIOEnumerations.cs" />\r
- <Compile Include="AudioIO\AudioOutput.cs" />\r
- <Compile Include="AudioIO\AudioStateChangedEventArgs.cs" />\r
- <Compile Include="AudioIO\AudioStreamLengthChangedEventArgs.cs" />\r
- <Compile Include="AudioIO\BaseAudio.cs" />\r
- <Compile Include="Interop\Interop.AudioIO.cs" />\r
- <Compile Include="Interop\Interop.MediaCodec.cs" />\r
- <Compile Include="Interop\Interop.MediaTool.cs" />\r
- <Compile Include="Interop\Interop.Player.cs" />\r
- <Compile Include="Interop\Interop.MetadataExtractor.cs" />\r
- <Compile Include="MediaCodec\BufferStatusChangedEventArgs.cs" />\r
- <Compile Include="MediaCodec\EosReachedEventArgs.cs" />\r
- <Compile Include="MediaCodec\ErrorOccurredEventArgs.cs" />\r
- <Compile Include="MediaCodec\InputProcessedEventArgs.cs" />\r
- <Compile Include="MediaCodec\MediaCodec.cs" />\r
- <Compile Include="MediaCodec\MediaCodecDebug.cs" />\r
- <Compile Include="MediaCodec\MediaCodecError.cs" />\r
- <Compile Include="MediaCodec\MediaCodecStatus.cs" />\r
- <Compile Include="MediaCodec\MediaCodecType.cs" />\r
- <Compile Include="MediaCodec\OutputAvailableEventArgs.cs" />\r
- <Compile Include="MediaCodec\SupportedCodecType.cs" />\r
- <Compile Include="MediaTool\MediaFormat.cs" />\r
- <Compile Include="MediaTool\MediaFormatAacType.cs" />\r
- <Compile Include="MediaTool\MediaFormatMimeType.cs" />\r
- <Compile Include="MediaTool\MediaFormatTextType.cs" />\r
- <Compile Include="MediaTool\MediaPacket.cs" />\r
- <Compile Include="MediaTool\MediaPacketBuffer.cs" />\r
- <Compile Include="MediaTool\MediaPacketBufferFlags.cs" />\r
- <Compile Include="MediaTool\MediaPacketVideoPlane.cs" />\r
- <Compile Include="MediaTool\MediaToolDebug.cs" />\r
- <Compile Include="MediaTool\NotEnoughMemoryException.cs" />\r
- <Compile Include="MetadataExtractor\MetadataEnums.cs" />\r
- <Compile Include="MetadataExtractor\MetadataExtractorErrorFactory.cs" />\r
- <Compile Include="MetadataExtractor\Synclyrics.cs" />\r
- <Compile Include="MetadataExtractor\Frame.cs" />\r
- <Compile Include="MetadataExtractor\Artwork.cs" />\r
- <Compile Include="MetadataExtractor\Metadata.cs" />\r
- <Compile Include="MetadataExtractor\MetadataExtractor.cs" />\r
- <Compile Include="Interop\Interop.EvasObject.cs" />\r
- <Compile Include="MediaView\MediaView.cs" />\r
- <Compile Include="Player\PlayerEnums.cs" />\r
- <Compile Include="Player\MediaStreamConfiguration.cs" />\r
- <Compile Include="Player\SubtitleTrack.cs" />\r
- <Compile Include="Player\AudioEffect.cs" />\r
- <Compile Include="Player\BufferingProgressChangedEventArgs.cs" />\r
- <Compile Include="Player\BufferStatusEventArgs.cs" />\r
- <Compile Include="Player\DownloadProgress.cs" />\r
- <Compile Include="Player\EqualizerBand.cs" />\r
- <Compile Include="Player\ProgressiveDownloadMessageEventArgs.cs" />\r
- <Compile Include="Player\ProgressiveDownloadStatus.cs" />\r
- <Compile Include="Player\SeekOffsetEventArgs.cs" />\r
- <Compile Include="Player\SubtitleUpdatedEventArgs.cs" />\r
- <Compile Include="Player\Display.cs" />\r
- <Compile Include="Player\PlaybackCompletedEventArgs.cs" />\r
- <Compile Include="Player\PlaybackErrorEventArgs.cs" />\r
- <Compile Include="Player\PlaybackInterruptedEventArgs.cs" />\r
- <Compile Include="Player\Player.cs" />\r
- <Compile Include="Player\PlayerContentInfo.cs" />\r
- <Compile Include="Player\StreamInformation.cs" />\r
- <Compile Include="Player\StreamingConfiguration.cs" />\r
- <Compile Include="Player\Subtitle.cs" />\r
- <Compile Include="Player\VideoFrameDecodedEventArgs.cs" />\r
- <Compile Include="Player\VideoFrameCapture.cs" />\r
- <Compile Include="Player\VideoStreamEventArgs.cs" />\r
- <Compile Include="Properties\AssemblyInfo.cs" />\r
- <Compile Include="Player\MediaSource.cs" />\r
- <Compile Include="Player\MediaUriSource.cs" />\r
- <Compile Include="Player\MediaBufferSource.cs" />\r
- <Compile Include="Player\MediaStreamSource.cs" />\r
- <Compile Include="Interop\Interop.Libraries.cs" />\r
- <Compile Include="Player\PlayerErrorFactory.cs" />\r
- <Compile Include="Recorder\AudioStreamDeliveredEventArgs.cs" />\r
- <Compile Include="Recorder\Camera.cs" />\r
- <Compile Include="Recorder\Recorder.cs" />\r
- <Compile Include="Recorder\RecorderEnums.cs" />\r
- <Compile Include="Recorder\RecorderErrorFactory.cs" />\r
- <Compile Include="Recorder\RecorderInterruptedEventArgs.cs" />\r
- <Compile Include="Recorder\RecorderStateChangedEventArgs.cs" />\r
- <Compile Include="Recorder\RecordingErrorOccurredEventArgs.cs" />\r
- <Compile Include="Recorder\RecordingLimitReachedEventArgs.cs" />\r
- <Compile Include="Recorder\RecordingStatusChangedEventArgs.cs" />\r
- <Compile Include="Recorder\VideoResolution.cs" />\r
- <Compile Include="Interop\Interop.Recorder.cs" />\r
- <Compile Include="Interop\Interop.RecorderAttribute.cs" />\r
- <Compile Include="Interop\Interop.RecorderCapability.cs" />\r
- <Compile Include="AudioManager\AudioDevice.cs" />\r
- <Compile Include="AudioManager\AudioDeviceConnectionChangedEventArgs.cs" />\r
- <Compile Include="AudioManager\AudioDevicePropertyChangedEventArgs.cs" />\r
- <Compile Include="AudioManager\AudioManager.cs" />\r
- <Compile Include="AudioManager\AudioManagerEnumerations.cs" />\r
- <Compile Include="AudioManager\AudioManagerErrorFactory.cs" />\r
- <Compile Include="AudioManager\AudioStreamPolicy.cs" />\r
- <Compile Include="AudioManager\AudioVolume.cs" />\r
- <Compile Include="AudioManager\FocusStateChangedEventArgs.cs" />\r
- <Compile Include="AudioManager\MaxVolumeLevel.cs" />\r
- <Compile Include="AudioManager\StreamFocusStateChangedEventArgs.cs" />\r
- <Compile Include="AudioManager\VolumeChangedEventArgs.cs" />\r
- <Compile Include="AudioManager\VolumeLevel.cs" />\r
- <Compile Include="Interop\Interop.Device.cs" />\r
- <Compile Include="Interop\Interop.StreamPolicy.cs" />\r
- <Compile Include="Interop\Interop.Volume.cs" />\r
- <Compile Include="Interop\Interop.MediaController.cs" />\r
- <Compile Include="MediaController\Playback.cs" />\r
- <Compile Include="MediaController\Metadata.cs" />\r
- <Compile Include="MediaController\ServerInformation.cs" />\r
- <Compile Include="MediaController\CustomCommandEventArgs.cs" />\r
- <Compile Include="MediaController\PlaybackStateCommandEventArgs.cs" />\r
- <Compile Include="MediaController\ServerUpdatedEventArgs.cs" />\r
- <Compile Include="MediaController\PlaybackUpdatedEventArgs.cs" />\r
- <Compile Include="MediaController\MetadataUpdatedEventArgs.cs" />\r
- <Compile Include="MediaController\ShuffleModeUpdatedEventArgs.cs" />\r
- <Compile Include="MediaController\RepeatModeUpdatedEventArgs.cs" />\r
- <Compile Include="MediaController\MediaControllerErrorFactory.cs" />\r
- <Compile Include="MediaController\MediaControllerEnums.cs" />\r
- <Compile Include="MediaController\MediaControllerLog.cs" />\r
- <Compile Include="MediaController\Client.cs" />\r
- <Compile Include="MediaController\Server.cs" />\r
- <Compile Include="MediaController\CommandReplyEventArgs.cs" />\r
- </ItemGroup>\r
- <ItemGroup>\r
- <None Include="Tizen.Multimedia.nuspec" />\r
- <None Include="Tizen.Multimedia.project.json" />\r
- <None Include="Tizen.Multimedia.snk" />\r
- </ItemGroup>\r
- <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />\r
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <PropertyGroup>
+ <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+ <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+ <ProjectGuid>{0CE698B0-4849-4096-9D7F-30E611F50DAD}</ProjectGuid>
+ <OutputType>Library</OutputType>
+ <AppDesignerFolder>Properties</AppDesignerFolder>
+ <RootNamespace>Tizen.Multimedia</RootNamespace>
+ <AssemblyName>Tizen.Multimedia</AssemblyName>
+ <FileAlignment>512</FileAlignment>
+ </PropertyGroup>
+ <PropertyGroup>
+ <TargetFrameworkIdentifier>.NETStandard</TargetFrameworkIdentifier>
+ <TargetFrameworkVersion>v1.3</TargetFrameworkVersion>
+ <NuGetTargetMoniker>.NETStandard,Version=v1.3</NuGetTargetMoniker>
+ <AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
+ <NoStdLib>true</NoStdLib>
+ <NoWarn>$(NoWarn);1701;1702</NoWarn>
+ </PropertyGroup>
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+ <DebugSymbols>true</DebugSymbols>
+ <DebugType>full</DebugType>
+ <Optimize>false</Optimize>
+ <OutputPath>bin\Debug\</OutputPath>
+ <DefineConstants>DEBUG;TRACE</DefineConstants>
+ <ErrorReport>prompt</ErrorReport>
+ <WarningLevel>4</WarningLevel>
+ </PropertyGroup>
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+ <DebugType>pdbonly</DebugType>
+ <Optimize>true</Optimize>
+ <OutputPath>bin\Release\</OutputPath>
+ <DefineConstants>TRACE</DefineConstants>
+ <ErrorReport>prompt</ErrorReport>
+ <WarningLevel>4</WarningLevel>
+ </PropertyGroup>
+ <PropertyGroup>
+ <SignAssembly>true</SignAssembly>
+ </PropertyGroup>
+ <PropertyGroup>
+ <AssemblyOriginatorKeyFile>Tizen.Multimedia.snk</AssemblyOriginatorKeyFile>
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="AudioIO\AudioErrorHelper.cs" />
+ <Compile Include="AudioIO\AudioInput.cs" />
+ <Compile Include="AudioIO\AudioIOEnumerations.cs" />
+ <Compile Include="AudioIO\AudioOutput.cs" />
+ <Compile Include="AudioIO\AudioStateChangedEventArgs.cs" />
+ <Compile Include="AudioIO\AudioStreamLengthChangedEventArgs.cs" />
+ <Compile Include="AudioIO\BaseAudio.cs" />
+ <Compile Include="Camera\Area.cs" />
+ <Compile Include="Camera\Camera.cs" />
+ <Compile Include="Camera\CameraDisplay.cs" />
+ <Compile Include="Camera\CameraEnums.cs" />
+ <Compile Include="Camera\CameraErrorFactory.cs" />
+ <Compile Include="Camera\CameraErrorOccurredEventArgs.cs" />
+ <Compile Include="Camera\CameraFeature.cs" />
+ <Compile Include="Camera\CameraFocusChangedEventArgs.cs" />
+ <Compile Include="Camera\CameraInterruptedEventArgs.cs" />
+ <Compile Include="Camera\CameraResolution.cs" />
+ <Compile Include="Camera\CameraSetting.cs" />
+ <Compile Include="Camera\CameraStateChangedEventArgs.cs" />
+ <Compile Include="Camera\CapturingEventArgs.cs" />
+ <Compile Include="Camera\DoublePlaneData.cs" />
+ <Compile Include="Camera\EncodedPlaneData.cs" />
+ <Compile Include="Camera\FaceDetectedData.cs" />
+ <Compile Include="Camera\FaceDetectedEventArgs.cs" />
+ <Compile Include="Camera\HdrCaptureProgressEventArgs.cs" />
+ <Compile Include="Camera\ImageData.cs" />
+ <Compile Include="Camera\Location.cs" />
+ <Compile Include="Camera\MediaPacketPreviewEventArgs.cs" />
+ <Compile Include="Camera\PreviewData.cs" />
+ <Compile Include="Camera\PreviewEventArgs.cs" />
+ <Compile Include="Camera\Range.cs" />
+ <Compile Include="Camera\SinglePlaneData.cs" />
+ <Compile Include="Camera\TriplePlaneData.cs" />
+ <Compile Include="Interop\Interop.AudioIO.cs" />
+ <Compile Include="Interop\Interop.Camera.cs" />
+ <Compile Include="Interop\Interop.CameraDisplay.cs" />
+ <Compile Include="Interop\Interop.CameraFeature.cs" />
+ <Compile Include="Interop\Interop.CameraSetting.cs" />
+ <Compile Include="Interop\Interop.MediaCodec.cs" />
+ <Compile Include="Interop\Interop.MediaTool.cs" />
+ <Compile Include="Interop\Interop.Player.cs" />
+ <Compile Include="Interop\Interop.MetadataExtractor.cs" />
+ <Compile Include="MediaCodec\BufferStatusChangedEventArgs.cs" />
+ <Compile Include="MediaCodec\EosReachedEventArgs.cs" />
+ <Compile Include="MediaCodec\ErrorOccurredEventArgs.cs" />
+ <Compile Include="MediaCodec\InputProcessedEventArgs.cs" />
+ <Compile Include="MediaCodec\MediaCodec.cs" />
+ <Compile Include="MediaCodec\MediaCodecDebug.cs" />
+ <Compile Include="MediaCodec\MediaCodecError.cs" />
+ <Compile Include="MediaCodec\MediaCodecStatus.cs" />
+ <Compile Include="MediaCodec\MediaCodecType.cs" />
+ <Compile Include="MediaCodec\OutputAvailableEventArgs.cs" />
+ <Compile Include="MediaCodec\SupportedCodecType.cs" />
+ <Compile Include="MediaTool\MediaFormat.cs" />
+ <Compile Include="MediaTool\MediaFormatAacType.cs" />
+ <Compile Include="MediaTool\MediaFormatMimeType.cs" />
+ <Compile Include="MediaTool\MediaFormatTextType.cs" />
+ <Compile Include="MediaTool\MediaPacket.cs" />
+ <Compile Include="MediaTool\MediaPacketBuffer.cs" />
+ <Compile Include="MediaTool\MediaPacketBufferFlags.cs" />
+ <Compile Include="MediaTool\MediaPacketVideoPlane.cs" />
+ <Compile Include="MediaTool\MediaToolDebug.cs" />
+ <Compile Include="MediaTool\NotEnoughMemoryException.cs" />
+ <Compile Include="MetadataExtractor\MetadataEnums.cs" />
+ <Compile Include="MetadataExtractor\MetadataExtractorErrorFactory.cs" />
+ <Compile Include="MetadataExtractor\Synclyrics.cs" />
+ <Compile Include="MetadataExtractor\Frame.cs" />
+ <Compile Include="MetadataExtractor\Artwork.cs" />
+ <Compile Include="MetadataExtractor\Metadata.cs" />
+ <Compile Include="MetadataExtractor\MetadataExtractor.cs" />
+ <Compile Include="Interop\Interop.EvasObject.cs" />
+ <Compile Include="MediaView\MediaView.cs" />
+ <Compile Include="Player\PlayerEnums.cs" />
+ <Compile Include="Player\MediaStreamConfiguration.cs" />
+ <Compile Include="Player\SubtitleTrack.cs" />
+ <Compile Include="Player\AudioEffect.cs" />
+ <Compile Include="Player\BufferingProgressChangedEventArgs.cs" />
+ <Compile Include="Player\BufferStatusEventArgs.cs" />
+ <Compile Include="Player\DownloadProgress.cs" />
+ <Compile Include="Player\EqualizerBand.cs" />
+ <Compile Include="Player\ProgressiveDownloadMessageEventArgs.cs" />
+ <Compile Include="Player\ProgressiveDownloadStatus.cs" />
+ <Compile Include="Player\SeekOffsetEventArgs.cs" />
+ <Compile Include="Player\SubtitleUpdatedEventArgs.cs" />
+ <Compile Include="Player\Display.cs" />
+ <Compile Include="Player\PlaybackCompletedEventArgs.cs" />
+ <Compile Include="Player\PlaybackErrorEventArgs.cs" />
+ <Compile Include="Player\PlaybackInterruptedEventArgs.cs" />
+ <Compile Include="Player\Player.cs" />
+ <Compile Include="Player\PlayerContentInfo.cs" />
+ <Compile Include="Player\StreamInformation.cs" />
+ <Compile Include="Player\StreamingConfiguration.cs" />
+ <Compile Include="Player\Subtitle.cs" />
+ <Compile Include="Player\VideoFrameDecodedEventArgs.cs" />
+ <Compile Include="Player\VideoFrameCapture.cs" />
+ <Compile Include="Player\VideoStreamEventArgs.cs" />
+ <Compile Include="Properties\AssemblyInfo.cs" />
+ <Compile Include="Player\MediaSource.cs" />
+ <Compile Include="Player\MediaUriSource.cs" />
+ <Compile Include="Player\MediaBufferSource.cs" />
+ <Compile Include="Player\MediaStreamSource.cs" />
+ <Compile Include="Interop\Interop.Libraries.cs" />
+ <Compile Include="Player\PlayerErrorFactory.cs" />
+ <Compile Include="Recorder\AudioStreamDeliveredEventArgs.cs" />
+ <Compile Include="Recorder\Recorder.cs" />
+ <Compile Include="Recorder\RecorderEnums.cs" />
+ <Compile Include="Recorder\RecorderErrorFactory.cs" />
+ <Compile Include="Recorder\RecorderInterruptedEventArgs.cs" />
+ <Compile Include="Recorder\RecorderStateChangedEventArgs.cs" />
+ <Compile Include="Recorder\RecordingErrorOccurredEventArgs.cs" />
+ <Compile Include="Recorder\RecordingLimitReachedEventArgs.cs" />
+ <Compile Include="Recorder\RecordingStatusChangedEventArgs.cs" />
+ <Compile Include="Recorder\VideoResolution.cs" />
+ <Compile Include="Interop\Interop.Recorder.cs" />
+ <Compile Include="Interop\Interop.RecorderAttribute.cs" />
+ <Compile Include="Interop\Interop.RecorderCapability.cs" />
+ <Compile Include="AudioManager\AudioDevice.cs" />
+ <Compile Include="AudioManager\AudioDeviceConnectionChangedEventArgs.cs" />
+ <Compile Include="AudioManager\AudioDevicePropertyChangedEventArgs.cs" />
+ <Compile Include="AudioManager\AudioManager.cs" />
+ <Compile Include="AudioManager\AudioManagerEnumerations.cs" />
+ <Compile Include="AudioManager\AudioManagerErrorFactory.cs" />
+ <Compile Include="AudioManager\AudioStreamPolicy.cs" />
+ <Compile Include="AudioManager\AudioVolume.cs" />
+ <Compile Include="AudioManager\FocusStateChangedEventArgs.cs" />
+ <Compile Include="AudioManager\MaxVolumeLevel.cs" />
+ <Compile Include="AudioManager\StreamFocusStateChangedEventArgs.cs" />
+ <Compile Include="AudioManager\VolumeChangedEventArgs.cs" />
+ <Compile Include="AudioManager\VolumeLevel.cs" />
+ <Compile Include="Interop\Interop.Device.cs" />
+ <Compile Include="Interop\Interop.StreamPolicy.cs" />
+ <Compile Include="Interop\Interop.Volume.cs" />
+ <Compile Include="Interop\Interop.MediaController.cs" />
+ <Compile Include="MediaController\Playback.cs" />
+ <Compile Include="MediaController\Metadata.cs" />
+ <Compile Include="MediaController\ServerInformation.cs" />
+ <Compile Include="MediaController\CustomCommandEventArgs.cs" />
+ <Compile Include="MediaController\PlaybackStateCommandEventArgs.cs" />
+ <Compile Include="MediaController\ServerUpdatedEventArgs.cs" />
+ <Compile Include="MediaController\PlaybackUpdatedEventArgs.cs" />
+ <Compile Include="MediaController\MetadataUpdatedEventArgs.cs" />
+ <Compile Include="MediaController\ShuffleModeUpdatedEventArgs.cs" />
+ <Compile Include="MediaController\RepeatModeUpdatedEventArgs.cs" />
+ <Compile Include="MediaController\MediaControllerErrorFactory.cs" />
+ <Compile Include="MediaController\MediaControllerEnums.cs" />
+ <Compile Include="MediaController\MediaControllerLog.cs" />
+ <Compile Include="MediaController\Client.cs" />
+ <Compile Include="MediaController\Server.cs" />
+ <Compile Include="MediaController\CommandReplyEventArgs.cs" />
+ </ItemGroup>
+ <ItemGroup>
+ <None Include="Tizen.Multimedia.nuspec" />
+ <None Include="Tizen.Multimedia.project.json" />
+ <None Include="Tizen.Multimedia.snk" />
+ </ItemGroup>
+ <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
- -->\r
- <PropertyGroup>\r
+ -->
+ <PropertyGroup>
<!-- https://github.com/dotnet/corefxlab/tree/master/samples/NetCoreSample and
https://docs.microsoft.com/en-us/dotnet/articles/core/tutorials/target-dotnetcore-with-msbuild
- -->\r
+ -->
<!-- We don't use any of MSBuild's resolution logic for resolving the framework, so just set these two
properties to any folder that exists to skip the GetReferenceAssemblyPaths task (not target) and
to prevent it from outputting a warning (MSB3644).
- -->\r
- <_TargetFrameworkDirectories>$(MSBuildThisFileDirectory)</_TargetFrameworkDirectories>\r
- <_FullFrameworkReferenceAssemblyPaths>$(MSBuildThisFileDirectory)</_FullFrameworkReferenceAssemblyPaths>\r
- <AutoUnifyAssemblyReferences>true</AutoUnifyAssemblyReferences>\r
- </PropertyGroup>\r
+ -->
+ <_TargetFrameworkDirectories>$(MSBuildThisFileDirectory)</_TargetFrameworkDirectories>
+ <_FullFrameworkReferenceAssemblyPaths>$(MSBuildThisFileDirectory)</_FullFrameworkReferenceAssemblyPaths>
+ <AutoUnifyAssemblyReferences>true</AutoUnifyAssemblyReferences>
+ </PropertyGroup>
</Project>
\ No newline at end of file
projects / platform / core / csapi / tizenfx.git / commitdiff