src/Tizen.Multimedia.Camera/Camera/CameraSettings.cs

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 using System;
  18 using System.Runtime.InteropServices;
  19 using Native = Interop.CameraSettings;
  20 using static Interop.Camera;
  21
  22 namespace Tizen.Multimedia
  23 {
  24     /// <summary>
  25     /// The camera setting class provides methods/properties to get and
  26     /// set basic camera attributes.
  27     /// </summary>
  28     public class CameraSettings
  29     {
  30         internal readonly Camera _camera;
  31
  32         private readonly Range? _brightnessRange;
  33         private readonly Range? _contrastRange;
  34         private readonly Range? _panRange;
  35         private readonly Range? _tiltRange;
  36         private readonly Range? _exposureRange;
  37         private readonly Range? _zoomRange;
  38
  39         internal CameraSettings(Camera camera)
  40         {
  41             _camera = camera;
  42
  43             _contrastRange = GetRange(Native.GetContrastRange);
  44             _brightnessRange = GetRange(Native.GetBrightnessRange);
  45             _exposureRange = GetRange(Native.GetExposureRange);
  46             _zoomRange = GetRange(Native.GetZoomRange);
  47             _panRange = GetRange(Native.GetPanRange);
  48             _tiltRange = GetRange(Native.GetTiltRange);
  49         }
  50
  51         private delegate CameraError GetRangeDelegate(IntPtr handle, out int min, out int max);
  52         private Range? GetRange(GetRangeDelegate func)
  53         {
  54             CameraErrorFactory.ThrowIfError(func(_camera.GetHandle(), out int min, out int max),
  55                 "Failed to initialize the camera settings");
  56
  57             if (min > max)
  58             {
  59                 return null;
  60             }
  61
  62             return new Range(min, max);
  63         }
  64
  65         #region Auto Focus
  66         /// <summary>
  67         /// Sets the auto focus area.
  68         /// </summary>
  69         /// <since_tizen> 3 </since_tizen>
  70         /// <remarks>
  71         /// <see cref="CameraAutoFocusMode"/> should not be the <see cref="CameraAutoFocusMode.None"/>.
  72         /// </remarks>
  73         /// <param name="x">X position.</param>
  74         /// <param name="y">Y position.</param>
  75         /// <exception cref="ArgumentException">In case of invalid parameters.</exception>
  76         /// <exception cref="InvalidOperationException">In case of any invalid operations.</exception>
  77         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
  78         public void SetAutoFocusArea(int x, int y)
  79         {
  80             CameraErrorFactory.ThrowIfError(Native.SetAutoFocusArea(_camera.GetHandle(), x, y),
  81                 "Failed to set the autofocus area.");
  82         }
  83
  84         /// <summary>
  85         /// Sets the auto focus area.
  86         /// </summary>
  87         /// <since_tizen> 3 </since_tizen>
  88         /// <remarks>
  89         /// <see cref="CameraAutoFocusMode"/> should not be the <see cref="CameraAutoFocusMode.None"/>.
  90         /// </remarks>
  91         /// <param name="pos"><see cref="Point"/> structure including X, Y position.</param>
  92         /// <exception cref="ArgumentException">In case of invalid parameters.</exception>
  93         /// <exception cref="InvalidOperationException">In case of any invalid operations.</exception>
  94         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
  95         public void SetAutoFocusArea(Point pos)
  96         {
  97             CameraErrorFactory.ThrowIfError(Native.SetAutoFocusArea(_camera.GetHandle(), pos.X, pos.Y),
  98                 "Failed to set the autofocus area.");
  99         }
 100
 101         /// <summary>
 102         /// Clears the auto focus area.
 103         /// </summary>
 104         /// <since_tizen> 3 </since_tizen>
 105         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 106         public void ClearFocusArea()
 107         {
 108             CameraErrorFactory.ThrowIfError(Native.ClearAutoFocusArea(_camera.GetHandle()),
 109                 "Failed to clear the autofocus area.");
 110         }
 111
 112         /// <summary>
 113         /// The auto focus mode.
 114         /// </summary>
 115         /// <since_tizen> 3 </since_tizen>
 116         /// <value>A <see cref="CameraAutoFocusMode"/> that specifies the auto focus mode.</value>
 117         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 118         public CameraAutoFocusMode AutoFocusMode
 119         {
 120             get
 121             {
 122                 CameraAutoFocusMode val = CameraAutoFocusMode.None;
 123
 124                 CameraErrorFactory.ThrowIfError(Native.GetAutoFocusMode(_camera.GetHandle(), out val),
 125                     "Failed to get camera autofocus mode");
 126
 127                 return val;
 128             }
 129
 130             set
 131             {
 132                 ValidationUtil.ValidateEnum(typeof(CameraAutoFocusMode), value);
 133                 CameraErrorFactory.ThrowIfError(Native.SetAutoFocusMode(_camera.GetHandle(), value),
 134                     "Failed to set camera autofocus mode.");
 135             }
 136         }
 137         #endregion Auto Focus
 138
 139         #region Contrast
 140         /// <summary>
 141         /// The contrast level of the camera.
 142         /// </summary>
 143         /// <since_tizen> 3 </since_tizen>
 144         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 145         public int Contrast
 146         {
 147             get
 148             {
 149                 CameraErrorFactory.ThrowIfError(Native.GetContrast(_camera.GetHandle(), out int val),
 150                     "Failed to get camera contrast value");
 151
 152                 return val;
 153             }
 154
 155             set
 156             {
 157                 CameraErrorFactory.ThrowIfError(Native.SetContrast(_camera.GetHandle(), value),
 158                     "Failed to set camera contrast value.");
 159             }
 160         }
 161
 162         /// <summary>
 163         /// The auto contrast.
 164         /// If true auto contrast is enabled, otherwise false.
 165         /// </summary>
 166         /// <since_tizen> 3 </since_tizen>
 167         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 168         public bool AutoContrast
 169         {
 170             get
 171             {
 172                 CameraErrorFactory.ThrowIfError(Native.IsEnabledAutoContrast(_camera.GetHandle(), out bool val),
 173                     "Failed to get camera auto contrast");
 174
 175                 return val;
 176             }
 177
 178             set
 179             {
 180                 CameraErrorFactory.ThrowIfError(Native.EnableAutoContrast(_camera.GetHandle(), value),
 181                     "Failed to set camera enable auto contrast.");
 182             }
 183         }
 184         /// <summary>
 185         /// Gets the available contrast level.
 186         /// </summary>
 187         /// <since_tizen> 3 </since_tizen>
 188         /// <remarks>
 189         /// If the mininum value is greater than the maximum value, it means this feature is not supported.
 190         /// </remarks>
 191         /// <exception cref="NotSupportedException">In case of this feature is not supported.</exception>
 192         public Range ContrastRange
 193         {
 194             get
 195             {
 196                 if (!_contrastRange.HasValue)
 197                 {
 198                     throw new NotSupportedException("Contrast is not supported.");
 199                 }
 200
 201                 return _contrastRange.Value;
 202             }
 203         }
 204         #endregion Contrast
 205
 206         #region Brightness
 207         /// <summary>
 208         /// The brightness level of the camera.
 209         /// </summary>
 210         /// <since_tizen> 3 </since_tizen>
 211         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 212         public int Brightness
 213         {
 214             get
 215             {
 216                 CameraErrorFactory.ThrowIfError(Native.GetBrightness(_camera.GetHandle(), out int val),
 217                     "Failed to get camera brightness value");
 218
 219                 return val;
 220             }
 221
 222             set
 223             {
 224                 CameraErrorFactory.ThrowIfError(Native.SetBrightness(_camera.GetHandle(), value),
 225                     "Failed to set camera brightness value.");
 226             }
 227         }
 228
 229         /// <summary>
 230         /// Gets the available brightness level.
 231         /// </summary>
 232         /// <since_tizen> 3 </since_tizen>
 233         /// <remarks>
 234         /// If the minimum value is greater than the maximum value, it means this feature is not supported.
 235         /// </remarks>
 236         /// <exception cref="NotSupportedException">In case of this feature is not supported.</exception>
 237         public Range BrightnessRange
 238         {
 239             get
 240             {
 241                 if (!_brightnessRange.HasValue)
 242                 {
 243                     throw new NotSupportedException("Brightness is not supported.");
 244                 }
 245
 246                 return _brightnessRange.Value;
 247             }
 248         }
 249         #endregion Brightness
 250
 251         #region Exposure
 252         /// <summary>
 253         /// The exposure value.
 254         /// </summary>
 255         /// <since_tizen> 3 </since_tizen>
 256         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 257         public int Exposure
 258         {
 259             get
 260             {
 261                 CameraErrorFactory.ThrowIfError(Native.GetExposure(_camera.GetHandle(), out int val),
 262                     "Failed to get camera exposure value");
 263
 264                 return val;
 265             }
 266
 267             set
 268             {
 269                 CameraErrorFactory.ThrowIfError(Native.SetExposure(_camera.GetHandle(), value),
 270                     "Failed to set camera exposure value.");
 271             }
 272         }
 273
 274         /// <summary>
 275         /// The exposure mode.
 276         /// </summary>
 277         /// <since_tizen> 3 </since_tizen>
 278         /// <value>A <see cref="CameraExposureMode"/> that specifies the exposure mode.</value>
 279         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 280         public CameraExposureMode ExposureMode
 281         {
 282             get
 283             {
 284                 CameraExposureMode val = CameraExposureMode.Off;
 285
 286                 CameraErrorFactory.ThrowIfError(Native.GetExposureMode(_camera.GetHandle(), out val),
 287                     "Failed to get camera exposure mode");
 288
 289                 return val;
 290             }
 291
 292             set
 293             {
 294                 ValidationUtil.ValidateEnum(typeof(CameraExposureMode), value);
 295                 CameraErrorFactory.ThrowIfError(Native.SetExposureMode(_camera.GetHandle(), value),
 296                     "Failed to set camera exposure mode.");
 297             }
 298         }
 299
 300         /// <summary>
 301         /// Gets the available exposure value.
 302         /// </summary>
 303         /// <since_tizen> 3 </since_tizen>
 304         /// <remarks>
 305         /// If the minimum value is greater than the maximum value, it means this feature is not supported.
 306         /// </remarks>
 307         /// <exception cref="NotSupportedException">In case of this feature is not supported.</exception>
 308         public Range ExposureRange
 309         {
 310             get
 311             {
 312                 if (!_exposureRange.HasValue)
 313                 {
 314                     throw new NotSupportedException("Exposure is not supported.");
 315                 }
 316
 317                 return _exposureRange.Value;
 318             }
 319         }
 320         #endregion Exposure
 321
 322         #region Zoom
 323         /// <summary>
 324         /// The zoom level.
 325         /// The range for the zoom level is received from the ZoomRange property.
 326         /// </summary>
 327         /// <since_tizen> 3 </since_tizen>
 328         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 329         public int ZoomLevel
 330         {
 331             get
 332             {
 333                 CameraErrorFactory.ThrowIfError(Native.GetZoom(_camera.GetHandle(), out int val),
 334                     "Failed to get zoom level");
 335
 336                 return val;
 337             }
 338
 339             set
 340             {
 341                 CameraErrorFactory.ThrowIfError(Native.SetZoom(_camera.GetHandle(), value),
 342                     "Failed to set zoom level.");
 343             }
 344         }
 345
 346         /// <summary>
 347         /// Gets the available zoom level.
 348         /// </summary>
 349         /// <since_tizen> 3 </since_tizen>
 350         /// <remarks>
 351         /// If the minimum value is greater than the maximum value, it means this feature is not supported.
 352         /// </remarks>
 353         /// <exception cref="NotSupportedException">In case of this feature is not supported.</exception>
 354         public Range ZoomRange
 355         {
 356             get
 357             {
 358                 if (!_zoomRange.HasValue)
 359                 {
 360                     throw new NotSupportedException("Zoom is not supported.");
 361                 }
 362
 363                 return _zoomRange.Value;
 364             }
 365         }
 366         #endregion Zoom
 367
 368         /// <summary>
 369         /// The white balance mode.
 370         /// </summary>
 371         /// <since_tizen> 3 </since_tizen>
 372         /// <value>A <see cref="CameraWhiteBalance"/> that specifies the white balance mode.</value>
 373         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 374         public CameraWhiteBalance WhiteBalance
 375         {
 376             get
 377             {
 378                 CameraWhiteBalance val = CameraWhiteBalance.None;
 379
 380                 CameraErrorFactory.ThrowIfError(Native.GetWhiteBalance(_camera.GetHandle(), out val),
 381                     "Failed to get camera whitebalance");
 382
 383                 return val;
 384             }
 385
 386             set
 387             {
 388                 ValidationUtil.ValidateEnum(typeof(CameraWhiteBalance), value);
 389                 CameraErrorFactory.ThrowIfError(Native.SetWhitebalance(_camera.GetHandle(), value),
 390                     "Failed to set camera whitebalance.");
 391             }
 392         }
 393
 394         /// <summary>
 395         /// The ISO level.
 396         /// </summary>
 397         /// <since_tizen> 3 </since_tizen>
 398         /// <value>A <see cref="CameraIsoLevel"/> that specifies the ISO level.</value>
 399         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 400         public CameraIsoLevel IsoLevel
 401         {
 402             get
 403             {
 404                 CameraIsoLevel val = CameraIsoLevel.Auto;
 405
 406                 CameraErrorFactory.ThrowIfError(Native.GetIso(_camera.GetHandle(), out val),
 407                     "Failed to get camera Iso level");
 408
 409                 return val;
 410             }
 411
 412             set
 413             {
 414                 ValidationUtil.ValidateEnum(typeof(CameraIsoLevel), value);
 415                 CameraErrorFactory.ThrowIfError(Native.SetIso(_camera.GetHandle(), value),
 416                     "Failed to set camera Iso level.");
 417             }
 418         }
 419
 420         /// <summary>
 421         /// The quality of the image.
 422         /// The range for the image quality is 1 to 100.
 423         /// </summary>
 424         /// <since_tizen> 3 </since_tizen>
 425         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 426         public int ImageQuality
 427         {
 428             get
 429             {
 430                 CameraErrorFactory.ThrowIfError(Native.GetImageQuality(_camera.GetHandle(), out int val),
 431                     "Failed to get image quality");
 432
 433                 return val;
 434             }
 435
 436             set
 437             {
 438                 if (value < 1 || value > 100)
 439                 {
 440                     throw new ArgumentException("Valid value is from 1(lowest quality) to 100(highest quality)");
 441                 }
 442
 443                 CameraErrorFactory.ThrowIfError(Native.SetImageQuality(_camera.GetHandle(), value),
 444                     "Failed to set image quality.");
 445             }
 446         }
 447
 448         #region Resolution, Format, Fps of preview, capture
 449         /// <summary>
 450         /// The preview frame rate.
 451         /// </summary>
 452         /// <since_tizen> 3 </since_tizen>
 453         /// <value>A <see cref="CameraFps"/> that specifies the preview frame rate.</value>
 454         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 455         public CameraFps PreviewFps
 456         {
 457             get
 458             {
 459                 CameraErrorFactory.ThrowIfError(Native.GetPreviewFps(_camera.GetHandle(), out var val),
 460                     "Failed to get camera preview fps");
 461
 462                 return val;
 463             }
 464
 465             set
 466             {
 467                 ValidationUtil.ValidateEnum(typeof(CameraFps), value);
 468                 CameraErrorFactory.ThrowIfError(Native.SetPreviewFps(_camera.GetHandle(), value),
 469                     "Failed to set preview fps.");
 470             }
 471         }
 472
 473         /// <summary>
 474         /// Gets or sets the resolution of the preview.
 475         /// </summary>
 476         /// <since_tizen> 3 </since_tizen>
 477         /// <exception cref="ArgumentException">In case of invalid parameters.</exception>
 478         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 479         public Size PreviewResolution
 480         {
 481             get
 482             {
 483                 CameraErrorFactory.ThrowIfError(GetPreviewResolution(_camera.GetHandle(), out int width, out int height),
 484                     "Failed to get camera preview resolution");
 485
 486                 return new Size(width, height);
 487             }
 488
 489             set
 490             {
 491                 CameraErrorFactory.ThrowIfError(SetPreviewResolution(_camera.GetHandle(), value.Width, value.Height),
 492                     "Failed to set preview resolution.");
 493             }
 494         }
 495
 496         /// <summary>
 497         /// Gets the recommended preview resolution.
 498         /// </summary>
 499         /// <since_tizen> 3 </since_tizen>
 500         /// <remarks>
 501         /// Depending on the capture resolution aspect ratio and the display resolution,
 502         /// the recommended preview resolution is determined.
 503         /// </remarks>
 504         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 505         public Size RecommendedPreviewResolution
 506         {
 507             get
 508             {
 509                 CameraErrorFactory.ThrowIfError(GetRecommendedPreviewResolution(_camera.GetHandle(), out int width, out int height),
 510                     "Failed to get recommended preview resolution");
 511
 512                 return new Size(width, height);
 513             }
 514         }
 515
 516         /// <summary>
 517         /// The preview data format.
 518         /// </summary>
 519         /// <since_tizen> 3 </since_tizen>
 520         /// <value>A <see cref="CameraPixelFormat"/> that specifies the pixel format of the preview data.</value>
 521         /// <exception cref="ArgumentException">In case of invalid parameters.</exception>
 522         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 523         public CameraPixelFormat PreviewPixelFormat
 524         {
 525             get
 526             {
 527                 CameraErrorFactory.ThrowIfError(GetPreviewPixelFormat(_camera.GetHandle(), out var val),
 528                     "Failed to get preview format");
 529
 530                 return val;
 531             }
 532
 533             set
 534             {
 535                 ValidationUtil.ValidateEnum(typeof(CameraPixelFormat), value);
 536                 CameraErrorFactory.ThrowIfError(SetPreviewPixelFormat(_camera.GetHandle(), value),
 537                     "Failed to set preview format.");
 538             }
 539         }
 540
 541         /// <summary>
 542         /// Resolution of the captured image.
 543         /// </summary>
 544         /// <since_tizen> 3 </since_tizen>
 545         /// <exception cref="ArgumentException">In case of invalid parameters.</exception>
 546         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 547         public Size CaptureResolution
 548         {
 549             get
 550             {
 551                 CameraErrorFactory.ThrowIfError(GetCaptureResolution(_camera.GetHandle(), out int width, out int height),
 552                     "Failed to get camera capture resolution");
 553
 554                 return new Size(width, height);
 555             }
 556
 557             set
 558             {
 559                 Size res = value;
 560
 561                 CameraErrorFactory.ThrowIfError(SetCaptureResolution(_camera.GetHandle(), res.Width, res.Height),
 562                     "Failed to set capture resolution.");
 563             }
 564         }
 565
 566         /// <summary>
 567         /// Format of an image to be captured.
 568         /// </summary>
 569         /// <since_tizen> 3 </since_tizen>
 570         /// <value>A <see cref="CameraPixelFormat"/> that specifies the pixel format of captured image.</value>
 571         /// <exception cref="ArgumentException">In case of invalid parameters.</exception>
 572         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 573         public CameraPixelFormat CapturePixelFormat
 574         {
 575             get
 576             {
 577                 CameraErrorFactory.ThrowIfError(GetCaptureFormat(_camera.GetHandle(), out var val),
 578                     "Failed to get camera capture formats");
 579
 580                 return val;
 581             }
 582
 583             set
 584             {
 585                 ValidationUtil.ValidateEnum(typeof(CameraPixelFormat), value);
 586                 CameraErrorFactory.ThrowIfError(SetCaptureFormat(_camera.GetHandle(), value),
 587                     "Failed to set capture format.");
 588             }
 589         }
 590         #endregion Resolution, Format, Fps of preview, capture
 591
 592         #region Encoded preview
 593         /// <summary>
 594         /// The bit rate of the encoded preview.
 595         /// </summary>
 596         /// <since_tizen> 3 </since_tizen>
 597         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 598         public int EncodedPreviewBitrate
 599         {
 600             get
 601             {
 602                 CameraErrorFactory.ThrowIfError(Native.GetBitrate(_camera.GetHandle(), out int val),
 603                     "Failed to get preview bitrate");
 604
 605                 return val;
 606             }
 607
 608             set
 609             {
 610                 CameraErrorFactory.ThrowIfError(Native.SetBitrate(_camera.GetHandle(), value),
 611                     "Failed to set encoded preview bitrate.");
 612             }
 613         }
 614
 615         /// <summary>
 616         /// The GOP(Group Of Pictures) interval of the encoded preview.
 617         /// </summary>
 618         /// <since_tizen> 3 </since_tizen>
 619         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 620         public int EncodedPreviewGopInterval
 621         {
 622             get
 623             {
 624                 CameraErrorFactory.ThrowIfError(Native.GetGopInterval(_camera.GetHandle(), out int val),
 625                     "Failed to get preview gop interval");
 626
 627                 return val;
 628             }
 629
 630             set
 631             {
 632                 CameraErrorFactory.ThrowIfError(Native.SetGopInterval(_camera.GetHandle(), value),
 633                     "Failed to set encoded preview gop intervals.");
 634             }
 635         }
 636         #endregion Encoded preview
 637
 638         /// <summary>
 639         /// The theater mode.
 640         /// </summary>
 641         /// <since_tizen> 3 </since_tizen>
 642         /// <value>A <see cref="CameraTheaterMode"/> that specifies the theater mode.</value>
 643         /// <remarks>
 644         /// If you want to display the preview image on the external display with the full screen mode,
 645         /// use this property.
 646         /// </remarks>
 647         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 648         public CameraTheaterMode TheaterMode
 649         {
 650             get
 651             {
 652                 CameraErrorFactory.ThrowIfError(Native.GetTheaterMode(_camera.GetHandle(), out var val),
 653                     "Failed to get camera theater mode");
 654
 655                 return val;
 656             }
 657
 658             set
 659             {
 660                 ValidationUtil.ValidateEnum(typeof(CameraTheaterMode), value);
 661                 CameraErrorFactory.ThrowIfError(Native.SetTheaterMode(_camera.GetHandle(), value),
 662                     "Failed to set camera theater mode.");
 663             }
 664         }
 665
 666         /// <summary>
 667         /// The camera effect mode.
 668         /// </summary>
 669         /// <since_tizen> 3 </since_tizen>
 670         /// <value>A <see cref="CameraEffectMode"/> that specifies the effect mode.</value>
 671         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 672         public CameraEffectMode Effect
 673         {
 674             get
 675             {
 676                 CameraErrorFactory.ThrowIfError(Native.GetEffect(_camera.GetHandle(), out var val),
 677                     "Failed to get camera effect");
 678
 679                 return val;
 680             }
 681
 682             set
 683             {
 684                 ValidationUtil.ValidateEnum(typeof(CameraEffectMode), value);
 685                 CameraErrorFactory.ThrowIfError(Native.SetEffect(_camera.GetHandle(), value),
 686                     "Failed to set camera effect.");
 687             }
 688         }
 689
 690         /// <summary>
 691         /// The scene mode.
 692         /// </summary>
 693         /// <since_tizen> 3 </since_tizen>
 694         /// <value>A <see cref="CameraSceneMode"/> that specifies the scene mode.</value>
 695         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 696         public CameraSceneMode SceneMode
 697         {
 698             get
 699             {
 700                 CameraErrorFactory.ThrowIfError(Native.GetSceneMode(_camera.GetHandle(), out var val),
 701                     "Failed to get camera scene mode");
 702
 703                 return val;
 704             }
 705
 706             set
 707             {
 708                 ValidationUtil.ValidateEnum(typeof(CameraSceneMode), value);
 709                 CameraErrorFactory.ThrowIfError(Native.SetSceneMode(_camera.GetHandle(), value),
 710                     "Failed to set camera scene mode.");
 711             }
 712         }
 713
 714         /// <summary>
 715         /// The camera's flash mode.
 716         /// </summary>
 717         /// <since_tizen> 3 </since_tizen>
 718         /// <value>A <see cref="CameraFlashMode"/> that specifies the flash mode.</value>
 719         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 720         public CameraFlashMode FlashMode
 721         {
 722             get
 723             {
 724                 CameraErrorFactory.ThrowIfError(Native.GetFlashMode(_camera.GetHandle(), out var val),
 725                     "Failed to get camera flash mode");
 726
 727                 return val;
 728             }
 729
 730             set
 731             {
 732                 ValidationUtil.ValidateEnum(typeof(CameraFlashMode), value);
 733                 CameraErrorFactory.ThrowIfError(Native.SetFlashMode(_camera.GetHandle(), value),
 734                     "Failed to set camera flash mode.");
 735             }
 736         }
 737
 738         /// <summary>
 739         /// Gets the camera lens orientation angle.
 740         /// </summary>
 741         /// <since_tizen> 3 </since_tizen>
 742         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 743         public int LensOrientation
 744         {
 745             get
 746             {
 747                 CameraErrorFactory.ThrowIfError(Native.GetLensOrientation(_camera.GetHandle(), out var val),
 748                     "Failed to get camera lens orientation");
 749
 750                 return val;
 751             }
 752         }
 753
 754         /// <summary>
 755         /// The stream rotation.
 756         /// </summary>
 757         /// <since_tizen> 3 </since_tizen>
 758         /// <value>A <see cref="Rotation"/> that specifies the rotation of camera device.</value>
 759         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 760         public Rotation StreamRotation
 761         {
 762             get
 763             {
 764                 CameraErrorFactory.ThrowIfError(Native.GetStreamRotation(_camera.GetHandle(), out var val),
 765                     "Failed to get camera stream rotation");
 766
 767                 return val;
 768             }
 769
 770             set
 771             {
 772                 ValidationUtil.ValidateEnum(typeof(Rotation), value);
 773
 774                 CameraErrorFactory.ThrowIfError(Native.SetStreamRotation(_camera.GetHandle(), value),
 775                     "Failed to set camera stream rotation.");
 776             }
 777         }
 778
 779         /// <summary>
 780         /// The stream flip.
 781         /// </summary>
 782         /// <since_tizen> 3 </since_tizen>
 783         /// <value>A <see cref="Flips"/> that specifies the camera flip type.</value>
 784         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 785         public Flips StreamFlip
 786         {
 787             get
 788             {
 789                 CameraErrorFactory.ThrowIfError(Native.GetFlip(_camera.GetHandle(), out var val),
 790                     "Failed to get camera stream flip");
 791
 792                 return val;
 793             }
 794
 795             set
 796             {
 797                 ValidationUtil.ValidateFlagsEnum(value, Flips.Horizontal | Flips.Vertical, nameof(Flips));
 798
 799                 CameraErrorFactory.ThrowIfError(Native.SetFlip(_camera.GetHandle(), value),
 800                     "Failed to set camera flip.");
 801             }
 802         }
 803
 804         /// <summary>
 805         /// The mode of the HDR(High dynamic range) capture.
 806         /// </summary>
 807         /// <since_tizen> 3 </since_tizen>
 808         /// <value>A <see cref="CameraHdrMode"/> that specifies the HDR mode.</value>
 809         /// <remarks>
 810         /// Taking multiple pictures at different exposure levels and intelligently stitching them together,
 811         /// so that we eventually arrive at a picture that is representative in both dark and bright areas.
 812         /// If this attribute is set, then event handler set for the HdrCaptureProgress event is invoked.
 813         /// </remarks>
 814         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 815         public CameraHdrMode HdrMode
 816         {
 817             get
 818             {
 819                 CameraErrorFactory.ThrowIfError(Native.GetHdrMode(_camera.GetHandle(), out var val),
 820                     "Failed to get camera hdr mode");
 821
 822                 return val;
 823             }
 824
 825             set
 826             {
 827                 ValidationUtil.ValidateEnum(typeof(CameraHdrMode), value);
 828                 CameraErrorFactory.ThrowIfError(Native.SetHdrMode(_camera.GetHandle(), value),
 829                     "Failed to set camera hdr mode.");
 830             }
 831         }
 832
 833         /// <summary>
 834         /// The anti shake feature.
 835         /// If true, the antishake feature is enabled, otherwise false.
 836         /// </summary>
 837         /// <since_tizen> 3 </since_tizen>
 838         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 839         public bool AntiShake
 840         {
 841             get
 842             {
 843                 CameraErrorFactory.ThrowIfError(Native.IsEnabledAntiShake(_camera.GetHandle(), out bool val),
 844                     "Failed to get camera anti shake value");
 845
 846                 return val;
 847             }
 848
 849             set
 850             {
 851                 CameraErrorFactory.ThrowIfError(Native.EnableAntiShake(_camera.GetHandle(), value),
 852                     "Failed to set camera anti shake value.");
 853             }
 854         }
 855
 856         /// <summary>
 857         /// Enables or disables the video stabilization feature.
 858         /// If true, video stabilization is enabled, otherwise false.
 859         /// </summary>
 860         /// <since_tizen> 3 </since_tizen>
 861         /// <remarks>
 862         /// If video stabilization is enabled, zero shutter lag is disabled.
 863         /// This feature is used to record a video.
 864         /// </remarks>
 865         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 866         public bool VideoStabilization
 867         {
 868             get
 869             {
 870                 CameraErrorFactory.ThrowIfError(Native.IsEnabledVideoStabilization(_camera.GetHandle(), out bool val),
 871                     "Failed to get camera video stabilization");
 872
 873                 return val;
 874             }
 875
 876             set
 877             {
 878                 CameraErrorFactory.ThrowIfError(Native.EnableVideoStabilization(_camera.GetHandle(), value),
 879                     "Failed to set camera video stabilization.");
 880             }
 881         }
 882
 883         /// <summary>
 884         /// Turn the shutter sound on or off, if it is permitted by policy.
 885         /// </summary>
 886         /// <since_tizen> 3 </since_tizen>
 887         /// <param name="shutterSound">Shutter sound On/Off flag</param>
 888         /// <remarks>
 889         /// If this value is true, shutter sound will be disabled, otherwise enabled.
 890         /// In some countries, this operation is not permitted.
 891         /// </remarks>
 892         /// <exception cref="InvalidOperationException">Disabling shutter sound is not permitted.</exception>
 893         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 894         public void DisableShutterSound(bool shutterSound)
 895         {
 896             CameraErrorFactory.ThrowIfError(Native.DisableShutterSound(_camera.GetHandle(), shutterSound),
 897                     "Failed to set disable shutter sound.");
 898         }
 899
 900         #region PTZ(Pan Tilt Zoom), Pan, Tilt
 901         /// <summary>
 902         /// Sets the type of the PTZ(Pan Tilt Zoom). Mechanical or electronic.
 903         /// </summary>
 904         /// <since_tizen> 3 </since_tizen>
 905         /// <value>A <see cref="CameraPtzType"/> that specifies the type of the PTZ.</value>
 906         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 907         public CameraPtzType PtzType
 908         {
 909             set
 910             {
 911                 ValidationUtil.ValidateEnum(typeof(CameraPtzType), value);
 912
 913                 CameraErrorFactory.ThrowIfError(Native.SetPtzType(_camera.GetHandle(), value),
 914                     "Failed to set camera ptz type.");
 915             }
 916         }
 917
 918         /// <summary>
 919         /// Sets the position to move horizontally.
 920         /// </summary>
 921         /// <since_tizen> 3 </since_tizen>
 922         /// <param name="type">The PTZ move type. <seealso cref="CameraPtzMoveType"/>.</param>
 923         /// <param name="panStep">The pan step.</param>
 924         /// <exception cref="ArgumentException">In case of invalid parameters.</exception>
 925         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 926         public void SetPan(CameraPtzMoveType type, int panStep)
 927         {
 928             ValidationUtil.ValidateEnum(typeof(CameraPtzMoveType), type, nameof(type));
 929             CameraErrorFactory.ThrowIfError(Native.SetPan(_camera.GetHandle(), type, panStep),
 930                 "Failed to set the camera pan type.");
 931         }
 932
 933         /// <summary>
 934         /// Gets the current position of the camera.
 935         /// </summary>
 936         /// <since_tizen> 3 </since_tizen>
 937         /// <returns>Returns the camera's horizontal position.</returns>
 938         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 939         public int GetPan()
 940         {
 941             CameraErrorFactory.ThrowIfError(Native.GetPan(_camera.GetHandle(), out int val),
 942                 "Failed to get the camera pan step.");
 943
 944             return val;
 945         }
 946
 947         /// <summary>
 948         /// Sets the position to move vertically.
 949         /// </summary>
 950         /// <since_tizen> 3 </since_tizen>
 951         /// <param name="type">the PTZ move type.</param>
 952         /// <param name="tiltStep">The tilt step.</param>
 953         /// <exception cref="ArgumentException">In case of invalid parameters.</exception>
 954         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 955         public void SetTilt(CameraPtzMoveType type, int tiltStep)
 956         {
 957             ValidationUtil.ValidateEnum(typeof(CameraPtzMoveType), type, nameof(type));
 958             CameraErrorFactory.ThrowIfError(Native.SetTilt(_camera.GetHandle(), type, tiltStep),
 959                 "Failed to set the camera tilt type\t.");
 960         }
 961
 962         /// <summary>
 963         /// Gets the current position of the camera.
 964         /// </summary>
 965         /// <since_tizen> 3 </since_tizen>
 966         /// <returns>Returns the current vertical position.</returns>
 967         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
 968         public int GetTilt()
 969         {
 970             CameraErrorFactory.ThrowIfError(Native.GetTilt(_camera.GetHandle(), out int val),
 971                 "Failed to set the camera current position.");
 972
 973             return val;
 974         }
 975
 976         /// <summary>
 977         /// Gets the lower limit and the upper limit for the pan position.
 978         /// </summary>
 979         /// <since_tizen> 3 </since_tizen>
 980         /// <remarks>
 981         /// If the minimum value is greater than the maximum value, it means this feature is not supported.
 982         /// </remarks>
 983         /// <exception cref="NotSupportedException">In case of this feature is not supported.</exception>
 984         public Range PanRange
 985         {
 986             get
 987             {
 988                 if (!_panRange.HasValue)
 989                 {
 990                     throw new NotSupportedException("Pan is not supported.");
 991                 }
 992
 993                 return _panRange.Value;
 994             }
 995         }
 996
 997         /// <summary>
 998         /// Gets the lower limit and the upper limit for the tilt position.
 999         /// </summary>
1000         /// <since_tizen> 3 </since_tizen>
1001         /// <remarks>
1002         /// If the minimum value is greater than the maximum value, it means this feature is not supported.
1003         /// </remarks>
1004         /// <exception cref="NotSupportedException">In case of this feature is not supported.</exception>
1005         public Range TiltRange
1006         {
1007             get
1008             {
1009                 if (!_tiltRange.HasValue)
1010                 {
1011                     throw new NotSupportedException("Tilt is not supported.");
1012                 }
1013
1014                 return _tiltRange.Value;
1015             }
1016         }
1017         #endregion PTZ(Pan Tilt Zoom), Pan, Tilt
1018
1019         #region EXIF tag
1020         /// <summary>
1021         /// The scene mode.
1022         /// </summary>
1023         /// <value>true if EXIF tags are enabled in the JPEG file, otherwise false.</value>
1024         /// <since_tizen> 3 </since_tizen>
1025         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
1026         public bool EnableTag
1027         {
1028             get
1029             {
1030                 CameraErrorFactory.ThrowIfError(Native.IsEnabledTag(_camera.GetHandle(), out bool val),
1031                     "Failed to get camera enable tag");
1032
1033                 return val;
1034             }
1035
1036             set
1037             {
1038                 CameraErrorFactory.ThrowIfError(Native.EnableTag(_camera.GetHandle(), value),
1039                     "Failed to set camera enable tag.");
1040             }
1041         }
1042
1043         /// <summary>
1044         /// The camera image description in the EXIF tag.
1045         /// </summary>
1046         /// <since_tizen> 3 </since_tizen>
1047         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
1048         public string ImageDescriptionTag
1049         {
1050             get
1051             {
1052                 IntPtr val = IntPtr.Zero;
1053                 try
1054                 {
1055                     CameraErrorFactory.ThrowIfError(Native.GetImageDescription(_camera.GetHandle(), out val),
1056                     "Failed to get image description");
1057
1058                     return Marshal.PtrToStringAnsi(val);
1059                 }
1060                 finally
1061                 {
1062                     LibcSupport.Free(val);
1063                 }
1064             }
1065
1066             set
1067             {
1068                 CameraErrorFactory.ThrowIfError(Native.SetImageDescription(_camera.GetHandle(), value),
1069                     "Failed to set image description.");
1070             }
1071         }
1072
1073         /// <summary>
1074         /// The software information in the EXIF tag.
1075         /// </summary>
1076         /// <since_tizen> 3 </since_tizen>
1077         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
1078         public string SoftwareTag
1079         {
1080             get
1081             {
1082                 IntPtr val = IntPtr.Zero;
1083
1084                 try
1085                 {
1086                     CameraErrorFactory.ThrowIfError(Native.GetTagSoftware(_camera.GetHandle(), out val),
1087                     "Failed to get tag software");
1088
1089                     return Marshal.PtrToStringAnsi(val);
1090                 }
1091                 finally
1092                 {
1093                     LibcSupport.Free(val);
1094                 }
1095             }
1096
1097             set
1098             {
1099                 CameraErrorFactory.ThrowIfError(Native.SetTagSoftware(_camera.GetHandle(), value),
1100                     "Failed to set tag software.");
1101             }
1102         }
1103
1104         /// <summary>
1105         /// The geo tag(GPS data) in the EXIF tag.
1106         /// </summary>
1107         /// <since_tizen> 3 </since_tizen>
1108         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
1109         public Location GeoTag
1110         {
1111             get
1112             {
1113                 CameraErrorFactory.ThrowIfError(Native.GetGeotag(_camera.GetHandle(),
1114                     out double latitude, out double longitude, out double altitude), "Failed to get tag");
1115
1116                 return new Location(latitude, longitude, altitude);
1117             }
1118
1119             set
1120             {
1121                 CameraErrorFactory.ThrowIfError(Native.SetGeotag(_camera.GetHandle(),
1122                     value.Latitude, value.Longitude, value.Altitude), "Failed to set geo tag.");
1123             }
1124         }
1125
1126         /// <summary>
1127         /// Removes the geo tag(GPS data) in the EXIF(EXchangeable Image File format) tag.
1128         /// </summary>
1129         /// <since_tizen> 3 </since_tizen>
1130         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
1131         public void RemoveGeoTag()
1132         {
1133             CameraErrorFactory.ThrowIfError(Native.RemoveGeotag(_camera.GetHandle()),
1134                 "Failed to remove the geotag\t.");
1135         }
1136
1137         /// <summary>
1138         /// The camera orientation in the tag.
1139         /// </summary>
1140         /// <since_tizen> 3 </since_tizen>
1141         /// <exception cref="ObjectDisposedException">The camera already has been disposed of.</exception>
1142         public CameraTagOrientation OrientationTag
1143         {
1144             get
1145             {
1146                 CameraErrorFactory.ThrowIfError(Native.GetTagOrientation(_camera.GetHandle(), out var val),
1147                     "Failed to get camera tag orientation");
1148
1149                 return val;
1150             }
1151
1152             set
1153             {
1154                 ValidationUtil.ValidateEnum(typeof(CameraTagOrientation), value);
1155                 CameraErrorFactory.ThrowIfError(Native.SetTagOrientation(_camera.GetHandle(), value),
1156                     "Failed to set camera tag orientation.");
1157             }
1158         }
1159         #endregion EXIF tag
1160     }
1161 }