src/Tizen.Multimedia.Remoting/MediaController/MediaControlServer.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.Collections.Generic;
  19 using System.Threading.Tasks;
  20 using Tizen.Applications;
  21 using Native = Interop.MediaControllerServer;
  22
  23 namespace Tizen.Multimedia.Remoting
  24 {
  25     /// <summary>
  26     /// Provides a means to set playback information and metadata and receive commands from clients.
  27     /// </summary>
  28     /// <seealso cref="MediaControllerManager"/>
  29     /// <seealso cref="MediaController"/>
  30     /// <since_tizen> 4 </since_tizen>
  31     public static partial class MediaControlServer
  32     {
  33         private static IntPtr _handle = IntPtr.Zero;
  34         private static bool? _isRunning;
  35
  36         /// <summary>
  37         /// Gets a value indicating whether the server is running.
  38         /// </summary>
  39         /// <value>true if the server has started; otherwise, false.</value>
  40         /// <seealso cref="Start"/>
  41         /// <seealso cref="Stop"/>
  42         /// <since_tizen> 4 </since_tizen>
  43         public static bool IsRunning
  44         {
  45             get
  46             {
  47                 if (_isRunning.HasValue == false)
  48                 {
  49                     _isRunning = GetRunningState();
  50                 }
  51
  52                 return _isRunning.Value;
  53             }
  54         }
  55
  56         private static bool GetRunningState()
  57         {
  58             IntPtr handle = IntPtr.Zero;
  59             try
  60             {
  61                 Native.ConnectDb(out handle).ThrowIfError("Failed to retrieve the running state.");
  62
  63                 Native.CheckServerExist(handle, Applications.Application.Current.ApplicationInfo.ApplicationId,
  64                     out var value).ThrowIfError("Failed to retrieve the running state.");
  65
  66                 return value;
  67             }
  68             finally
  69             {
  70                 if (handle != IntPtr.Zero)
  71                 {
  72                     Native.DisconnectDb(handle);
  73                 }
  74             }
  75         }
  76
  77         private static void EnsureInitializedIfRunning()
  78         {
  79             if (_handle != IntPtr.Zero)
  80             {
  81                 return;
  82             }
  83
  84             if (IsRunning == false)
  85             {
  86                 throw new InvalidOperationException("The server is not running.");
  87             }
  88
  89             Initialize();
  90         }
  91
  92         private static IntPtr Handle
  93         {
  94             get
  95             {
  96                 EnsureInitializedIfRunning();
  97
  98                 return _handle;
  99             }
 100         }
 101
 102         private static void Initialize()
 103         {
 104             Native.Create(out _handle).ThrowIfError("Failed to create media controller server.");
 105
 106             try
 107             {
 108                 RegisterPlaybackCommandReceivedEvent();
 109                 RegisterPlaybackActionCommandReceivedEvent();
 110                 RegisterPlaybackPositionCommandReceivedEvent();
 111                 RegisterPlaylistCommandReceivedEvent();
 112                 RegisterShuffleModeCommandReceivedEvent();
 113                 RegisterRepeatModeCommandReceivedEvent();
 114                 RegisterCustomCommandReceivedEvent();
 115                 RegisterCommandCompletedEvent();
 116                 RegisterSearchCommandReceivedEvent();
 117
 118                 _isRunning = true;
 119             }
 120             catch
 121             {
 122                 Native.Destroy(_handle);
 123                 _playbackCommandCallback = null;
 124                 _handle = IntPtr.Zero;
 125                 throw;
 126             }
 127         }
 128
 129         /// <summary>
 130         /// Starts the media control server.
 131         /// </summary>
 132         /// <remarks>
 133         /// When the server starts, <see cref="MediaControllerManager.ServerStarted"/> will be raised.
 134         /// </remarks>
 135         /// <privilege>http://tizen.org/privilege/mediacontroller.server</privilege>
 136         /// <exception cref="InvalidOperationException">An internal error occurs.</exception>
 137         /// <exception cref="UnauthorizedAccessException">Caller does not have required privilege.</exception>
 138         /// <seealso cref="MediaControllerManager.ServerStarted"/>
 139         /// <since_tizen> 4 </since_tizen>
 140         public static void Start()
 141         {
 142             Initialize();
 143         }
 144
 145         /// <summary>
 146         /// Stops the media control server.
 147         /// </summary>
 148         /// <remarks>
 149         /// When the server stops, <see cref="MediaControllerManager.ServerStopped"/> will be raised.
 150         /// </remarks>
 151         /// <exception cref="InvalidOperationException">
 152         ///     The server is not running .<br/>
 153         ///     -or-<br/>
 154         ///     An internal error occurs.
 155         /// </exception>
 156         /// <seealso cref="MediaControllerManager.ServerStopped"/>
 157         /// <since_tizen> 4 </since_tizen>
 158         public static void Stop()
 159         {
 160             EnsureInitializedIfRunning();
 161
 162             Native.Destroy(_handle).ThrowIfError("Failed to stop the server.");
 163
 164             _handle = IntPtr.Zero;
 165             _playbackCommandCallback = null;
 166             _isRunning = false;
 167         }
 168
 169         /// <summary>
 170         /// Updates playback state and playback position.</summary>
 171         /// <param name="state">The playback state.</param>
 172         /// <param name="position">The playback position in milliseconds.</param>
 173         /// <exception cref="ArgumentException"><paramref name="state"/> is not valid.</exception>
 174         /// <exception cref="ArgumentOutOfRangeException"><paramref name="position"/> is less than zero.</exception>
 175         /// <exception cref="InvalidOperationException">
 176         ///     The server is not running .<br/>
 177         ///     -or-<br/>
 178         ///     An internal error occurs.
 179         /// </exception>
 180         /// <since_tizen> 4 </since_tizen>
 181         public static void SetPlaybackState(MediaControlPlaybackState state, long position)
 182         {
 183             ValidationUtil.ValidateEnum(typeof(MediaControlPlaybackState), state, nameof(state));
 184
 185             if (position < 0)
 186             {
 187                 throw new ArgumentOutOfRangeException(nameof(position), position, "position can't be less than zero.");
 188             }
 189
 190             Native.SetPlaybackState(Handle, state.ToNative()).ThrowIfError("Failed to set playback state.");
 191
 192             Native.SetPlaybackPosition(Handle, (ulong)position).ThrowIfError("Failed to set playback position.");
 193
 194             Native.UpdatePlayback(Handle).ThrowIfError("Failed to set playback.");
 195         }
 196
 197         private static void SetMetadata(MediaControllerNativeAttribute attribute, string value)
 198         {
 199             Native.SetMetadata(Handle, attribute, value).ThrowIfError($"Failed to set metadata({attribute}).");
 200         }
 201
 202         /// <summary>
 203         /// Updates metadata information.
 204         /// </summary>
 205         /// <param name="metadata">The metadata to update.</param>
 206         /// <exception cref="ArgumentNullException"><paramref name="metadata"/> is null.</exception>
 207         /// <exception cref="InvalidOperationException">
 208         ///     The server is not running .<br/>
 209         ///     -or-<br/>
 210         ///     An internal error occurs.
 211         /// </exception>
 212         /// <since_tizen> 4 </since_tizen>
 213         public static void SetMetadata(MediaControlMetadata metadata)
 214         {
 215             if (metadata == null)
 216             {
 217                 throw new ArgumentNullException(nameof(metadata));
 218             }
 219
 220             SetMetadata(MediaControllerNativeAttribute.Title, metadata.Title);
 221             SetMetadata(MediaControllerNativeAttribute.Artist, metadata.Artist);
 222             SetMetadata(MediaControllerNativeAttribute.Album, metadata.Album);
 223             SetMetadata(MediaControllerNativeAttribute.Author, metadata.Author);
 224             SetMetadata(MediaControllerNativeAttribute.Genre, metadata.Genre);
 225             SetMetadata(MediaControllerNativeAttribute.Duration, metadata.Duration);
 226             SetMetadata(MediaControllerNativeAttribute.Date, metadata.Date);
 227             SetMetadata(MediaControllerNativeAttribute.Copyright, metadata.Copyright);
 228             SetMetadata(MediaControllerNativeAttribute.Description, metadata.Description);
 229             SetMetadata(MediaControllerNativeAttribute.TrackNumber, metadata.TrackNumber);
 230             SetMetadata(MediaControllerNativeAttribute.Picture, metadata.AlbumArtPath);
 231
 232             Native.UpdateMetadata(Handle).ThrowIfError("Failed to set metadata.");
 233         }
 234
 235         /// <summary>
 236         /// Updates the shuffle mode.
 237         /// </summary>
 238         /// <param name="enabled">A value indicating whether the shuffle mode is enabled.</param>
 239         /// <exception cref="InvalidOperationException">
 240         ///     The server is not running .<br/>
 241         ///     -or-<br/>
 242         ///     An internal error occurs.
 243         /// </exception>
 244         /// <since_tizen> 4 </since_tizen>
 245         public static void SetShuffleModeEnabled(bool enabled)
 246         {
 247             Native.UpdateShuffleMode(Handle, enabled ? MediaControllerNativeShuffleMode.On : MediaControllerNativeShuffleMode.Off).
 248                 ThrowIfError("Failed to set shuffle mode.");
 249         }
 250
 251         /// <summary>
 252         /// Updates the repeat mode.
 253         /// </summary>
 254         /// <param name="mode">A value indicating the repeat mode.</param>
 255         /// <exception cref="InvalidOperationException">
 256         ///     The server is not running .<br/>
 257         ///     -or-<br/>
 258         ///     An internal error occurs.
 259         /// </exception>
 260         /// <exception cref="ArgumentException"><paramref name="mode"/> is invalid.</exception>
 261         /// <since_tizen> 4 </since_tizen>
 262         public static void SetRepeatMode(MediaControlRepeatMode mode)
 263         {
 264             ValidationUtil.ValidateEnum(typeof(MediaControlRepeatMode), mode, nameof(mode));
 265
 266             Native.UpdateRepeatMode(Handle, mode.ToNative()).ThrowIfError("Failed to set repeat mode.");
 267         }
 268
 269         /// <summary>
 270         /// Sets the index of current playing media.
 271         /// </summary>
 272         /// <param name="index">The index of current playing media.</param>
 273         /// <exception cref="ArgumentNullException"><paramref name="index"/> is null.</exception>
 274         /// <exception cref="InvalidOperationException">
 275         ///     The server is not running .<br/>
 276         ///     -or-<br/>
 277         ///     An internal error occurs.
 278         /// </exception>
 279         /// <since_tizen> 5 </since_tizen>
 280         [Obsolete("Please do not use! This will be deprecated. Please use SetInfoOfCurrentPlayingMedia instead.")]
 281         public static void SetIndexOfCurrentPlayingMedia(string index)
 282         {
 283             if (index == null)
 284             {
 285                 throw new ArgumentNullException(nameof(index));
 286             }
 287
 288             Native.SetIndexOfCurrentPlayingMedia(Handle, index)
 289                 .ThrowIfError("Failed to set the index of current playing media");
 290
 291             Native.UpdatePlayback(Handle).ThrowIfError("Failed to set playback.");
 292         }
 293
 294         /// <summary>
 295         /// Sets the playlist name and index of current playing media.
 296         /// </summary>
 297         /// <param name="playlistName">The playlist name of current playing media.</param>
 298         /// <param name="index">The index of current playing media.</param>
 299         /// <exception cref="ArgumentNullException">
 300         /// <paramref name="playlistName"/> or <paramref name="index"/> is null.
 301         /// </exception>
 302         /// <exception cref="InvalidOperationException">
 303         ///     The server is not running .<br/>
 304         ///     -or-<br/>
 305         ///     An internal error occurs.
 306         /// </exception>
 307         /// <since_tizen> 5 </since_tizen>
 308         public static void SetInfoOfCurrentPlayingMedia(string playlistName, string index)
 309         {
 310             if (playlistName == null)
 311             {
 312                 throw new ArgumentNullException(nameof(playlistName));
 313             }
 314             if (index == null)
 315             {
 316                 throw new ArgumentNullException(nameof(index));
 317             }
 318
 319             Native.SetInfoOfCurrentPlayingMedia(Handle, playlistName, index)
 320                 .ThrowIfError("Failed to set the playlist name and index of current playing media");
 321
 322             Native.UpdatePlayback(Handle).ThrowIfError("Failed to set playback.");
 323         }
 324
 325         /// <summary>
 326         /// Delete playlist.
 327         /// </summary>
 328         /// <param name="playlist">The name of playlist.</param>
 329         /// <exception cref="InvalidOperationException">
 330         ///     The server is not running .<br/>
 331         ///     -or-<br/>
 332         ///     An internal error occurs.
 333         /// </exception>
 334         /// <since_tizen> 5 </since_tizen>
 335         public static void RemovePlaylist(MediaControlPlaylist playlist)
 336         {
 337             Native.DeletePlaylist(Handle, playlist.Handle);
 338             playlist.Dispose();
 339         }
 340
 341         // Saves the playlist to the persistent storage.
 342         internal static void SavePlaylist(IntPtr playlistHandle)
 343         {
 344             Native.SavePlaylist(Handle, playlistHandle).ThrowIfError("Failed to save playlist");
 345         }
 346
 347         // Gets the playlist handle by name.
 348         internal static IntPtr GetPlaylistHandle(string name)
 349         {
 350             Native.GetPlaylistHandle(Handle, name, out IntPtr playlistHandle)
 351                 .ThrowIfError("Failed to get playlist handle by name");
 352
 353             return playlistHandle;
 354         }
 355
 356         /// <summary>
 357         /// Gets the active clients.
 358         /// </summary>
 359         /// <exception cref="InvalidOperationException">
 360         ///     The server is not running .<br/>
 361         ///     -or-<br/>
 362         ///     An internal error occurs.
 363         /// </exception>
 364         /// <returns>the activated client ids.</returns>
 365         /// <since_tizen> 5 </since_tizen>
 366         public static IEnumerable<string> GetActivatedClients()
 367         {
 368             var clientIds = new List<string>();
 369
 370             Native.ActivatedClientCallback activatedClientCallback = (name, _) =>
 371             {
 372                 clientIds.Add(name);
 373                 return true;
 374             };
 375
 376             Native.ForeachActivatedClient(Handle, activatedClientCallback).
 377                 ThrowIfError("Failed to get activated client.");
 378
 379             return clientIds.AsReadOnly();
 380         }
 381
 382         /// <summary>
 383         /// Requests commands to the client.
 384         /// </summary>
 385         /// <remarks>
 386         /// The client can request the command to execute <see cref="Command"/>, <br/>
 387         /// and then, the server receive the result of each request(command).
 388         /// </remarks>
 389         /// <param name="command">A <see cref="Command"/> class.</param>
 390         /// <param name="clientId">The client Id to send command.</param>
 391         /// <returns>A task that represents the asynchronous operation.</returns>
 392         /// <exception cref="InvalidOperationException">
 393         ///     The server has already been stopped.<br/>
 394         ///     -or-<br/>
 395         ///     An internal error occurs.
 396         /// </exception>
 397         /// <since_tizen> 5 </since_tizen>
 398         public static async Task RequestAsync(Command command, string clientId)
 399         {
 400             command.SetRequestInformation(clientId);
 401
 402             var tcs = new TaskCompletionSource<MediaControllerError>();
 403             string reqeustId = null;
 404
 405             EventHandler<CommandCompletedEventArgs> eventHandler = (s, e) =>
 406             {
 407                 if (e.RequestId == reqeustId)
 408                 {
 409                     tcs.TrySetResult(e.Result);
 410                 }
 411             };
 412
 413             try
 414             {
 415                 CommandCompleted += eventHandler;
 416
 417                 reqeustId = command.Request(Handle);
 418
 419                 (await tcs.Task).ThrowIfError("Failed to request event.");
 420             }
 421             finally
 422             {
 423                 CommandCompleted -= eventHandler;
 424             }
 425         }
 426
 427         /// <summary>
 428         /// Sends the result of each command.
 429         /// </summary>
 430         /// <param name="command">The command that return to client.</param>
 431         /// <param name="result">The result of <paramref name="command"/>.</param>
 432         /// <param name="bundle">The extra data.</param>
 433         /// <exception cref="InvalidOperationException">
 434         ///     The server is not running .<br/>
 435         ///     -or-<br/>
 436         ///     An internal error occurs.
 437         /// </exception>
 438         /// <since_tizen> 5 </since_tizen>
 439         public static void Response(Command command, int result, Bundle bundle)
 440         {
 441             command.Response(Handle, result, bundle);
 442         }
 443
 444         /// <summary>
 445         /// Sends the result of each command.
 446         /// </summary>
 447         /// <param name="command">The command that return to client.</param>
 448         /// <param name="result">The result of <paramref name="command"/>.</param>
 449         /// <exception cref="InvalidOperationException">
 450         ///     The server is not running .<br/>
 451         ///     -or-<br/>
 452         ///     An internal error occurs.
 453         /// </exception>
 454         /// <since_tizen> 5 </since_tizen>
 455         public static void Response(Command command, int result)
 456         {
 457             command.Response(Handle, result, null);
 458         }
 459
 460         #region Capabilities
 461         /// <summary>
 462         /// Sets the content type of latest played media.
 463         /// </summary>
 464         /// <param name="type">A value indicating the content type of the latest played media.</param>
 465         /// <exception cref="InvalidOperationException">
 466         ///     The server is not running .<br/>
 467         ///     -or-<br/>
 468         ///     An internal error occurs.
 469         /// </exception>
 470         /// <exception cref="ArgumentException"><paramref name="type"/> is invalid.</exception>
 471         /// <since_tizen> 5 </since_tizen>
 472         public static void SetPlaybackContentType(MediaControlContentType type)
 473         {
 474             ValidationUtil.ValidateEnum(typeof(MediaControlContentType), type, nameof(type));
 475
 476             Native.SetPlaybackContentType(Handle, type).ThrowIfError("Failed to set playback content type.");
 477
 478             Native.UpdatePlayback(Handle).ThrowIfError("Failed to set playback.");
 479         }
 480
 481         /// <summary>
 482         /// Sets the path of icon.
 483         /// </summary>
 484         /// <param name="path">The path of icon.</param>
 485         /// <exception cref="InvalidOperationException">
 486         ///     The server is not running .<br/>
 487         ///     -or-<br/>
 488         ///     An internal error occurs.
 489         /// </exception>
 490         /// <exception cref="ArgumentNullException"><paramref name="path"/> is invalid.</exception>
 491         /// <since_tizen> 5 </since_tizen>
 492         public static void SetIconPath(string path)
 493         {
 494             if (path == null)
 495             {
 496                 throw new ArgumentNullException(nameof(path));
 497             }
 498
 499             Native.SetIconPath(Handle, path).ThrowIfError("Failed to set uri path.");
 500         }
 501
 502         /// <summary>
 503         /// Sets the capabilities by <see cref="MediaControlPlaybackCommand"/>.
 504         /// </summary>
 505         /// <param name="capabilities">The set of <see cref="MediaControlPlaybackCommand"/> and <see cref="MediaControlCapabilitySupport"/>.</param>
 506         /// <exception cref="InvalidOperationException">
 507         ///     The server is not running .<br/>
 508         ///     -or-<br/>
 509         ///     An internal error occurs.
 510         /// </exception>
 511         /// <exception cref="ArgumentException"><paramref name="capabilities"/> is invalid.</exception>
 512         /// <since_tizen> 5 </since_tizen>
 513         public static void SetPlaybackCapabilities(Dictionary<MediaControlPlaybackCommand, MediaControlCapabilitySupport> capabilities)
 514         {
 515             foreach (var pair in capabilities)
 516             {
 517                 ValidationUtil.ValidateEnum(typeof(MediaControlPlaybackCommand), pair.Key, nameof(pair.Key));
 518                 ValidationUtil.ValidateEnum(typeof(MediaControlCapabilitySupport), pair.Value, nameof(pair.Value));
 519
 520                 SetPlaybackCapability(pair.Key, pair.Value);
 521                 Native.SetPlaybackCapability(Handle, pair.Key.ToNative(), pair.Value).
 522                     ThrowIfError("Failed to set playback capability.");
 523             }
 524
 525             Native.SaveAndNotifyPlaybackCapabilityUpdated(Handle).ThrowIfError("Failed to update playback capability.");
 526         }
 527
 528         /// <summary>
 529         /// Sets the capabilities by <see cref="MediaControlPlaybackCommand"/>.
 530         /// </summary>
 531         /// <param name="action">A playback command.</param>
 532         /// <param name="support">A value indicating whether the <paramref name="action"/> is supported or not.</param>
 533         /// <exception cref="InvalidOperationException">
 534         ///     The server is not running .<br/>
 535         ///     -or-<br/>
 536         ///     An internal error occurs.
 537         /// </exception>
 538         /// <exception cref="ArgumentException"><paramref name="action"/> or <paramref name="support"/> is invalid.</exception>
 539         /// <since_tizen> 5 </since_tizen>
 540         public static void SetPlaybackCapability(MediaControlPlaybackCommand action, MediaControlCapabilitySupport support)
 541         {
 542             ValidationUtil.ValidateEnum(typeof(MediaControlPlaybackCommand), action, nameof(action));
 543             ValidationUtil.ValidateEnum(typeof(MediaControlCapabilitySupport), support, nameof(support));
 544
 545             Native.SetPlaybackCapability(Handle, action.ToNative(), support).ThrowIfError("Failed to set playback capability.");
 546
 547             Native.SaveAndNotifyPlaybackCapabilityUpdated(Handle).ThrowIfError("Failed to update playback capability.");
 548         }
 549
 550         /// <summary>
 551         /// Sets the <see cref="MediaControlCapabilitySupport"/> indicating shuffle mode is supported or not.
 552         /// </summary>
 553         /// <param name="support">A value indicating whether the shuffle mode is supported or not.</param>
 554         /// <exception cref="InvalidOperationException">
 555         ///     The server is not running .<br/>
 556         ///     -or-<br/>
 557         ///     An internal error occurs.
 558         /// </exception>
 559         /// <exception cref="ArgumentException"><paramref name="support"/> is invalid.</exception>
 560         /// <since_tizen> 5 </since_tizen>
 561         public static void SetShuffleModeCapability(MediaControlCapabilitySupport support)
 562         {
 563             ValidationUtil.ValidateEnum(typeof(MediaControlCapabilitySupport), support, nameof(support));
 564
 565             Native.SetShuffleModeCapability(Handle, support).ThrowIfError("Failed to set shuffle mode capability.");
 566         }
 567
 568         /// <summary>
 569         /// Sets the content type of latest played media.
 570         /// </summary>
 571         /// <param name="support">A value indicating whether the <see cref="MediaControlRepeatMode"/> is supported or not.</param>
 572         /// <exception cref="InvalidOperationException">
 573         ///     The server is not running .<br/>
 574         ///     -or-<br/>
 575         ///     An internal error occurs.
 576         /// </exception>
 577         /// <exception cref="ArgumentException"><paramref name="support"/> is invalid.</exception>
 578         /// <since_tizen> 5 </since_tizen>
 579         public static void SetRepeatModeCapability(MediaControlCapabilitySupport support)
 580         {
 581             ValidationUtil.ValidateEnum(typeof(MediaControlCapabilitySupport), support, nameof(support));
 582
 583             Native.SetRepeatModeCapability(Handle, support).ThrowIfError("Failed to set shuffle mode capability.");
 584         }
 585         #endregion Capabilities
 586
 587         /// <summary>
 588         /// Sets the age rating of latest played media.
 589         /// </summary>
 590         /// <param name="ageRating">
 591         /// The Age rating of latest played media. The valid range is 0 to 19, inclusive.
 592         /// Especially, 0 means that media is suitable for all ages.
 593         /// </param>
 594         /// <exception cref="ArgumentOutOfRangeException">The specified <paramref name="ageRating"/> is not valid.</exception>
 595         /// <exception cref="InvalidOperationException">
 596         ///     The server is not running .<br/>
 597         ///     -or-<br/>
 598         ///     An internal error occurs.
 599         /// </exception>
 600         /// <since_tizen> 5 </since_tizen>
 601         public static void SetAgeRating(int ageRating)
 602         {
 603             if (ageRating < 0 || ageRating > 19)
 604             {
 605                 throw new ArgumentOutOfRangeException(nameof(ageRating));
 606             }
 607
 608             Native.SetAgeRating(Handle, ageRating).ThrowIfError("Failed to set age rating.");
 609
 610             Native.UpdatePlayback(Handle).ThrowIfError("Failed to set playback.");
 611         }
 612     }
 613 }