private void UnregisterMediaPacketPreviewCallback() { Native.UnsetMediaPacketPreviewCallback(_handle). ThrowIfFailed("Unsetting media packet preview callback failed"); _mediaPacketPreviewCallback = null; }
private void UnregisterHdrCaptureProgress() { Native.UnsetHdrCaptureProgressCallback(_handle). ThrowIfFailed("Unsetting hdr capture progress is failed"); _hdrCaptureProgressCallback = null; }
/// <summary> /// Starts continuously capturing still images. /// EventHandler must be set for capturing using <see cref="Capturing"/> /// and for completed using <see cref="CaptureCompleted"/> before calling this method. /// The camera must be in the <see cref="CameraState.Preview"/> state. /// </summary> /// <since_tizen> 3 </since_tizen> /// <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> /// <param name="cancellationToken">The cancellation token to cancel capturing.</param> /// <seealso cref="CancellationToken"/> /// <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 the <see cref="Capturing"/> event. /// The preview should be restarted by calling the <see cref="StartPreview"/> method after capture is completed. /// </remarks> /// <exception cref="ArgumentOutOfRangeException">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="ObjectDisposedException">The camera already has been disposed of.</exception> /// <exception cref="UnauthorizedAccessException">In case of access to the resources cannot be granted.</exception> public void StartCapture(int count, int interval, CancellationToken cancellationToken) { ValidateState(CameraState.Preview); if (count < 2) { throw new ArgumentOutOfRangeException(nameof(count), count, $"{nameof(count)} should be greater than one."); } if (interval < 0) { throw new ArgumentOutOfRangeException(nameof(interval), interval, $"{nameof(interval)} should be greater than or equal to zero."); } //Handle CancellationToken if (cancellationToken != CancellationToken.None) { cancellationToken.Register(() => { CameraErrorFactory.ThrowIfError(Native.StopContinuousCapture(_handle), "Failed to cancel the continuous capture"); SetState(CameraState.Captured); }); } CameraErrorFactory.ThrowIfError(Native.StartContinuousCapture(_handle, count, interval, _capturingCallback, _captureCompletedCallback, IntPtr.Zero), "Failed to start the continuous capture."); SetState(CameraState.Capturing); }
/// <summary> /// Starts camera auto-focusing, asynchronously. /// The camera must be in the <see cref="CameraState.Preview"/> or the <see cref="CameraState.Captured"/> state. /// </summary> /// <since_tizen> 3 </since_tizen> /// <param name="continuous">Continuous auto focus.</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="ObjectDisposedException">The camera already has been disposed of.</exception> /// <exception cref="UnauthorizedAccessException">In case of access to the resources cannot be granted.</exception> public void StartFocusing(bool continuous) { ValidateState(CameraState.Preview, CameraState.Captured); CameraErrorFactory.ThrowIfError(Native.StartFocusing(_handle, continuous), "Failed to cancel the camera focus."); }
/// <summary> /// Changes the camera device. /// </summary> /// <param name="device">The hardware camera to access.</param> /// <since_tizen> 3 </since_tizen> /// <feature> http://tizen.org/feature/camera </feature> /// <remarks> /// If display reuse is set using <see cref="DisplayReuseHint"/> /// before stopping the preview, the display will be reused and last frame on the display /// can be kept even though camera device is changed. /// The camera must be in the <see cref="CameraState.Created"/>. /// </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 the ChangeDevice feature is not supported.</exception> /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception> public void ChangeDevice(CameraDevice device) { ValidateState(CameraState.Created); ValidationUtil.ValidateEnum(typeof(CameraDevice), device, nameof(device)); Native.ChangeDevice(_handle, device).ThrowIfFailed("Failed to change the camera device"); }
private static void UnregisterDeviceStateChangedCallback() { CameraErrorFactory.ThrowIfError(Native.UnsetDeviceStateChangedCallback(_deviceStateCallbackId), "Unsetting device state changed callback failed"); _deviceStateChangedCallback = null; _deviceStateCallbackId = 0; }
/// <summary> /// Stops camera auto focusing. /// The camera must be in the <see cref="CameraState.Preview"/> or the <see cref="CameraState.Captured"/> state. /// </summary> /// <since_tizen> 3 </since_tizen> /// <privilege> /// http://tizen.org/privilege/camera /// </privilege> /// <exception cref="InvalidOperationException">In case of any invalid operations.</exception> /// <exception cref="NotSupportedException">In case of this feature is not supported.</exception> /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception> /// <exception cref="UnauthorizedAccessException">In case of access to the resources cannot be granted.</exception> public void StopFocusing() { ValidateState(CameraState.Preview, CameraState.Captured); CameraErrorFactory.ThrowIfError(Native.CancelFocusing(_handle), "Failed to cancel the camera focus."); }
private static void UnregisterDeviceStateChangedCallback() { Native.UnsetDeviceStateChangedCallback(_deviceStateCallbackId). ThrowIfFailed("Unsetting device state changed callback failed"); _deviceStateChangedCallback = null; _deviceStateCallbackId = 0; }
/// <summary> /// Stops capturing and drawing preview frames on the screen. /// The camera must be in the <see cref="CameraState.Preview"/> state. /// </summary> /// <since_tizen> 3 </since_tizen> /// <privilege> http://tizen.org/privilege/camera </privilege> /// <feature> http://tizen.org/feature/camera </feature> /// <exception cref="InvalidOperationException">In case of any invalid operations.</exception> /// <exception cref="NotSupportedException">In case of this feature is not supported.</exception> /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception> /// <exception cref="UnauthorizedAccessException">In case of access to the resources cannot be granted.</exception> public void StopPreview() { ValidateState(CameraState.Preview); Native.StopPreview(_handle).ThrowIfFailed("Failed to stop the camera preview."); SetState(CameraState.Created); }
/// <summary> /// Gets the flash state. /// </summary> /// <param name="device">The device to get the state.</param> /// <returns>Returns the flash state of the camera device.</returns> /// <since_tizen> 3 </since_tizen> /// <feature> http://tizen.org/feature/camera </feature> /// <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 static CameraFlashState GetFlashState(CameraDevice device) { ValidationUtil.ValidateEnum(typeof(CameraDevice), device, nameof(device)); Native.GetFlashState(device, out var val).ThrowIfFailed("Failed to get camera flash state"); return(val); }
/// <summary> /// Gets the device state. /// </summary> /// <param name="device">The device to get the state.</param> /// <returns>Returns the state of the camera device.</returns> /// <since_tizen> 4 </since_tizen> /// <feature> http://tizen.org/feature/camera </feature> /// <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 static CameraDeviceState GetDeviceState(CameraDevice device) { ValidationUtil.ValidateEnum(typeof(CameraDevice), device, nameof(device)); Native.GetDeviceState(device, out var val).ThrowIfFailed("Failed to get the camera device state."); return(val); }
/// <summary> /// Starts capturing of still images. /// EventHandler must be set for capturing using <see cref="Capturing"/> /// and for completed using <see cref="CaptureCompleted"/> before calling this method. /// The camera must be in the <see cref="CameraState.Preview"/> state. /// </summary> /// <since_tizen> 3 </since_tizen> /// <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 preview should be restarted by calling the <see cref="StartPreview"/> method after capture is completed. /// </remarks> /// <exception cref="InvalidOperationException">In case of any invalid operations.</exception> /// <exception cref="NotSupportedException">In case of this feature is not supported.</exception> /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception> /// <exception cref="UnauthorizedAccessException">In case of access to the resources cannot be granted.</exception> public void StartCapture() { ValidateState(CameraState.Preview); CameraErrorFactory.ThrowIfError(Native.StartCapture(_handle, _capturingCallback, _captureCompletedCallback, IntPtr.Zero), "Failed to start the camera capture."); SetState(CameraState.Capturing); }
private void RegisterHdrCaptureProgress() { _hdrCaptureProgressCallback = (int percent, IntPtr userData) => { _hdrCaptureProgress?.Invoke(this, new HdrCaptureProgressEventArgs(percent)); }; CameraErrorFactory.ThrowIfError(Native.SetHdrCaptureProgressCallback(_handle, _hdrCaptureProgressCallback, IntPtr.Zero), "Setting Hdr capture progress callback failed"); }
/// <summary> /// Starts capturing and drawing preview frames on the screen. /// The display property must be set using <see cref="Display"/> before using this method. /// If needed set fps <see cref="CameraSettings.PreviewFps"/>, preview resolution /// <see cref="CameraSettings.PreviewResolution"/>, or preview format <see cref="CameraSettings.PreviewPixelFormat"/> /// before using this method. /// The camera must be in the <see cref="CameraState.Created"/> or the <see cref="CameraState.Captured"/> state. /// </summary> /// <since_tizen> 3 </since_tizen> /// <privilege> http://tizen.org/privilege/camera </privilege> /// <feature> http://tizen.org/feature/camera </feature> /// <exception cref="InvalidOperationException">In case of any invalid operations.</exception> /// <exception cref="NotSupportedException">In case of this feature is not supported.</exception> /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception> /// <exception cref="UnauthorizedAccessException">In case of access to the resources cannot be granted.</exception> public void StartPreview() { ValidateState(CameraState.Created, CameraState.Captured); Native.StartPreview(_handle).ThrowIfFailed("Failed to start the camera preview."); // Update by StateChangedCallback can be delayed for dozens of milliseconds. SetState(CameraState.Preview); }
/// <summary> /// Stops capturing and drawing preview frames on the screen. /// The camera must be in the <see cref="CameraState.Preview"/> state. /// </summary> /// <since_tizen> 3 </since_tizen> /// <privilege> /// http://tizen.org/privilege/camera /// </privilege> /// <exception cref="InvalidOperationException">In case of any invalid operations.</exception> /// <exception cref="NotSupportedException">In case of this feature is not supported.</exception> /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception> /// <exception cref="UnauthorizedAccessException">In case of access to the resources cannot be granted.</exception> public void StopPreview() { ValidateState(CameraState.Preview); CameraErrorFactory.ThrowIfError(Native.StopPreview(_handle), "Failed to stop the camera preview."); SetState(CameraState.Created); }
private void RegisterPreviewCallback() { _previewCallback = (IntPtr frame, IntPtr userData) => { _preview?.Invoke(this, new PreviewEventArgs(new PreviewFrame(frame))); }; CameraErrorFactory.ThrowIfError(Native.SetPreviewCallback(_handle, _previewCallback, IntPtr.Zero), "Setting preview callback failed"); }
private void RegisterErrorCallback() { _errorCallback = (CameraErrorCode error, CameraState current, IntPtr userData) => { ErrorOccurred?.Invoke(this, new CameraErrorOccurredEventArgs(error, current)); }; CameraErrorFactory.ThrowIfError(Native.SetErrorCallback(_handle, _errorCallback, IntPtr.Zero), "Setting error callback failed"); }
private void RegisterInterruptedCallback() { _interruptedCallback = (CameraPolicy policy, CameraState previous, CameraState current, IntPtr userData) => { Interrupted?.Invoke(this, new CameraInterruptedEventArgs(policy, previous, current)); }; CameraErrorFactory.ThrowIfError(Native.SetInterruptedCallback(_handle, _interruptedCallback, IntPtr.Zero), "Failed to set interrupt callback"); }
private void RegisterFocusStateChanged() { _focusStateChangedCallback = (CameraFocusState state, IntPtr userData) => { FocusStateChanged?.Invoke(this, new CameraFocusStateChangedEventArgs(state)); }; CameraErrorFactory.ThrowIfError(Native.SetFocusStateChangedCallback(_handle, _focusStateChangedCallback, IntPtr.Zero), "Setting focus changed callback failed"); }
private void RegisterInterruptStartedCallback() { _interruptStartedCallback = (CameraPolicy policy, CameraState state, IntPtr userData) => { InterruptStarted?.Invoke(this, new CameraInterruptStartedEventArgs(policy, state)); }; Native.SetInterruptStartedCallback(_handle, _interruptStartedCallback, IntPtr.Zero). ThrowIfFailed("Failed to set interrupt callback"); }
private void RegisterStateChangedCallback() { _stateChangedCallback = (CameraState previous, CameraState current, bool byPolicy, IntPtr _) => { SetState(current); Log.Info(CameraLog.Tag, "Camera state changed " + previous.ToString() + " -> " + current.ToString()); StateChanged?.Invoke(this, new CameraStateChangedEventArgs(previous, current, byPolicy)); }; CameraErrorFactory.ThrowIfError(Native.SetStateChangedCallback(_handle, _stateChangedCallback, IntPtr.Zero), "Setting state changed callback failed"); }
/// <summary> /// Stops face detection. /// </summary> /// <since_tizen> 3 </since_tizen> /// <privilege> http://tizen.org/privilege/camera </privilege> /// <feature> http://tizen.org/feature/camera </feature> /// <exception cref="InvalidOperationException">In case of any invalid operations.</exception> /// <exception cref="NotSupportedException">In case of this feature is not supported.</exception> /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception> /// <exception cref="UnauthorizedAccessException">In case of access to the resources cannot be granted.</exception> public void StopFaceDetection() { if (_faceDetectedCallback == null) { throw new InvalidOperationException("The face detection is not started."); } Native.StopFaceDetection(_handle).ThrowIfFailed("Failed to stop the face detection."); _faceDetectedCallback = null; }
private static void RegisterDeviceStateChangedCallback() { _deviceStateChangedCallback = (CameraDevice device, CameraDeviceState state, IntPtr userData) => { _deviceStateChanged?.Invoke(null, new CameraDeviceStateChangedEventArgs(device, state)); }; CameraErrorFactory.ThrowIfError(Native.SetDeviceStateChangedCallback(_deviceStateChangedCallback, IntPtr.Zero, out _deviceStateCallbackId), "Failed to set device state changed callback"); Log.Info(CameraLog.Tag, "add callbackId " + _deviceStateCallbackId.ToString()); }
/// <summary> /// Initializes a new instance of the <see cref="Camera"/> class. /// </summary> /// <param name="device">The camera device to access.</param> /// <exception cref="ArgumentException">Invalid CameraDevice type.</exception> /// <exception cref="NotSupportedException">The camera feature is not supported.</exception> /// <since_tizen> 3 </since_tizen> /// <feature> http://tizen.org/feature/camera </feature> public Camera(CameraDevice device) { Native.Create(device, out _handle).ThrowIfFailed("Failed to create camera instance"); Capabilities = new CameraCapabilities(this); Settings = new CameraSettings(this); DisplaySettings = new CameraDisplaySettings(this); RegisterCallbacks(); SetState(CameraState.Created); }
/// <summary> /// Initializes a new instance of the <see cref="Camera"/> class. /// </summary> /// <param name="device">The camera device to access.</param> /// <exception cref="ArgumentException">Invalid CameraDevice type.</exception> /// <exception cref="NotSupportedException">The camera feature is not supported.</exception> /// <since_tizen> 3 </since_tizen> /// <feature> http://tizen.org/feature/camera </feature> public Camera(CameraDevice device) { if (!Features.IsSupported(CameraFeatures.Camera)) { throw new NotSupportedException("Camera feature is not supported."); } Native.Create(device, out _handle).ThrowIfFailed("Failed to create camera instance"); Capabilities = new CameraCapabilities(this); Settings = new CameraSettings(this); DisplaySettings = new CameraDisplaySettings(this); RegisterCallbacks(); SetState(CameraState.Created); }
/// <summary> /// Releases the unmanaged resources used by the camera. /// </summary> /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param> /// <since_tizen> 3 </since_tizen> protected virtual void Dispose(bool disposing) { if (!_disposed) { if (disposing) { // to be used if there are any other disposable objects } if (_handle != IntPtr.Zero) { Native.Destroy(_handle); _handle = IntPtr.Zero; } _disposed = true; } }
private void RegisterMediaPacketPreviewCallback() { _mediaPacketPreviewCallback = (IntPtr mediaPacket, IntPtr userData) => { MediaPacket packet = MediaPacket.From(mediaPacket); var eventHandler = _mediaPacketPreview; if (eventHandler != null) { eventHandler.Invoke(this, new MediaPacketPreviewEventArgs(packet)); } else { packet.Dispose(); } }; CameraErrorFactory.ThrowIfError(Native.SetMediaPacketPreviewCallback(_handle, _mediaPacketPreviewCallback, IntPtr.Zero), "Setting media packet preview callback failed"); }
/// <summary> /// Starts face detection. /// The camera must be in the <see cref="CameraState.Preview"/> state. /// </summary> /// <since_tizen> 3 </since_tizen> /// <privilege> /// http://tizen.org/privilege/camera /// </privilege> /// <remarks> /// This should be called after <see cref="StartPreview"/> is started. /// The Eventhandler set using <see cref="FaceDetected"/> is invoked when the face is detected in the preview frame. /// Internally, it starts continuously focus and focusing on the detected face. /// </remarks> /// <exception cref="InvalidOperationException">In case of any invalid operations.</exception> /// <exception cref="NotSupportedException">In case of this feature is not supported.</exception> /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception> /// <exception cref="UnauthorizedAccessException">In case of access to the resources cannot be granted.</exception> public void StartFaceDetection() { ValidateState(CameraState.Preview); _faceDetectedCallback = (IntPtr faces, int count, IntPtr userData) => { var result = new List <FaceDetectionData>(); IntPtr current = faces; for (int i = 0; i < count; i++) { result.Add(new FaceDetectionData(current)); current = IntPtr.Add(current, Marshal.SizeOf <Native.DetectedFaceStruct>()); } FaceDetected?.Invoke(this, new FaceDetectedEventArgs(result)); }; CameraErrorFactory.ThrowIfError(Native.StartFaceDetection(_handle, _faceDetectedCallback, IntPtr.Zero), "Failed to start face detection"); }
private void UnregisterPreviewCallback() { CameraErrorFactory.ThrowIfError(Native.UnsetPreviewCallback(_handle), "Unsetting preview callback failed"); _previewCallback = null; }
private void UnregisterHdrCaptureProgress() { CameraErrorFactory.ThrowIfError(Native.UnsetHdrCaptureProgressCallback(_handle), "Unsetting hdr capture progress is failed"); _hdrCaptureProgressCallback = null; }