src/Tizen.Multimedia/MediaController/MediaControllerClient.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
  22 namespace Tizen.Multimedia.MediaController
  23 {\r
  24 \r
  25     /// <summary>
  26     /// The MediaControllerClient class provides APIs required for media-controller-client.
  27     /// </summary>
  28     /// <privilege>\r
  29     /// http://tizen.org/privilege/mediacontroller.client\r
  30     /// </privilege>
  31     /// <remarks>
  32     /// The MediaControllerClient APIs provides functions to get media information from server.
  33     /// </remarks>
  34     public class MediaControllerClient : IDisposable
  35     {
  36         internal IntPtr _handle = IntPtr.Zero;
  37
  38         private bool _disposed = false;
  39         private EventHandler<ServerUpdatedEventArgs> _serverUpdated;
  40         private Interop.MediaControllerClient.ServerUpdatedCallback _serverUpdatedCallback;
  41         private EventHandler<PlaybackUpdatedEventArgs> _playbackUpdated;
  42         private Interop.MediaControllerClient.PlaybackUpdatedCallback _playbackUpdatedCallback;
  43         private EventHandler<MetadataUpdatedEventArgs> _metadataUpdated;
  44         private Interop.MediaControllerClient.MetadataUpdatedCallback _metadataUpdatedCallback;
  45         private EventHandler<ShuffleModeUpdatedEventArgs> _shufflemodeUpdated;
  46         private Interop.MediaControllerClient.ShuffleModeUpdatedCallback _shufflemodeUpdatedCallback;
  47         private EventHandler<RepeatModeUpdatedEventArgs> _repeatmodeUpdated;
  48         private Interop.MediaControllerClient.RepeatModeUpdatedCallback _repeatmodeUpdatedCallback;
  49         private EventHandler<CustomCommandReplyEventArgs> _customcommandReply;
  50         private Interop.MediaControllerClient.CommandReplyRecievedCallback _customcommandReplyCallback;
  51
  52         /// <summary>
  53         /// The constructor of MediaControllerClient class.
  54         /// </summary>
  55         /// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state</exception>
  56         /// <exception cref="UnauthorizedAccessException">Thrown when the access is denied for media controller client</exception>
  57         public MediaControllerClient ()
  58         {
  59             MediaControllerValidator.ThrowIfError(
  60                 Interop.MediaControllerClient.Create(out _handle), "Create client failed");
  61         }
  62
  63         ~MediaControllerClient ()
  64         {
  65             Dispose(false);
  66         }
  67
  68         public void Dispose()
  69         {
  70             Dispose(true);
  71             GC.SuppressFinalize(this);
  72         }
  73
  74         protected virtual void Dispose(bool disposing)
  75         {
  76             if(!_disposed)
  77             {
  78                 if(disposing)
  79                 {
  80                     // To be used if there are any other disposable objects
  81                 }
  82                 if(_handle != IntPtr.Zero)
  83                 {
  84                     Interop.MediaControllerClient.Destroy(_handle);
  85                     _handle = IntPtr.Zero;
  86                 }
  87                 _disposed = true;
  88             }
  89         }
  90
  91         /// <summary>
  92         /// ServerUpdated event is raised when server is changed
  93         /// </summary>
  94         public event EventHandler<ServerUpdatedEventArgs> ServerUpdated
  95         {
  96             add
  97             {
  98                 if(_serverUpdated == null)
  99                 {
 100                     RegisterServerUpdatedEvent();
 101                 }
 102                 _serverUpdated += value;
 103
 104             }
 105             remove
 106             {
 107                 _serverUpdated -= value;
 108                 if(_serverUpdated == null)
 109                 {
 110                     UnregisterServerUpdatedEvent();
 111                 }
 112             }
 113         }
 114
 115         /// <summary>
 116         /// PlaybackUpdated event is raised when playback is changed
 117         /// </summary>
 118         public event EventHandler<PlaybackUpdatedEventArgs> PlaybackUpdated
 119         {
 120             add
 121             {
 122                 if(_playbackUpdated == null)
 123                 {
 124                     RegisterPlaybackUpdatedEvent();
 125                 }
 126                 _playbackUpdated += value;
 127
 128             }
 129             remove
 130             {
 131                 _playbackUpdated -= value;
 132                 if(_playbackUpdated == null)
 133                 {
 134                     UnregisterPlaybackUpdatedEvent();
 135                 }
 136             }
 137         }
 138
 139         /// <summary>
 140         /// MetadataUpdated event is raised when metadata is changed
 141         /// </summary>
 142         public event EventHandler<MetadataUpdatedEventArgs> MetadataUpdated
 143         {
 144             add
 145             {
 146                 if(_metadataUpdated == null)
 147                 {
 148                     RegisterMetadataUpdatedEvent();
 149                 }
 150                 _metadataUpdated += value;
 151
 152             }
 153             remove
 154             {
 155                 _metadataUpdated -= value;
 156                 if(_metadataUpdated == null)
 157                 {
 158                     UnregisterMetadataUpdatedEvent();
 159                 }
 160             }
 161         }
 162
 163         /// <summary>
 164         /// ShuffleModeUpdated event is raised when shuffle mode is changed
 165         /// </summary>
 166         public event EventHandler<ShuffleModeUpdatedEventArgs> ShuffleModeUpdated
 167         {
 168             add
 169             {
 170                 if(_shufflemodeUpdated == null)
 171                 {
 172                     RegisterShuffleModeUpdatedEvent();
 173                 }
 174                 _shufflemodeUpdated += value;
 175
 176             }
 177             remove
 178             {
 179                 _shufflemodeUpdated -= value;
 180                 if(_shufflemodeUpdated == null)
 181                 {
 182                     UnregisterShuffleModeUpdatedEvent();
 183                 }
 184             }
 185         }
 186
 187         /// <summary>
 188         /// RepeatModeUpdated event is raised when server is changed
 189         /// </summary>
 190         public event EventHandler<RepeatModeUpdatedEventArgs> RepeatModeUpdated
 191         {
 192             add
 193             {
 194                 if(_repeatmodeUpdated == null)
 195                 {
 196                     RegisterRepeatModeUpdatedEvent();
 197                 }
 198                 _repeatmodeUpdated += value;
 199
 200             }
 201             remove
 202             {
 203                 _repeatmodeUpdated -= value;
 204                 if(_repeatmodeUpdated == null)
 205                 {
 206                     UnregisterRepeatModeUpdatedEvent();
 207                 }
 208             }
 209         }
 210
 211         /// <summary>
 212         /// CommandReply event is raised when reply for command is recieved
 213         /// </summary>
 214         public event EventHandler<CustomCommandReplyEventArgs> CustomCommandReply
 215         {
 216             add
 217             {
 218                 if(_customcommandReply == null)
 219                 {
 220                     _customcommandReplyCallback = (string serverName, int result, IntPtr bundle, IntPtr userData) =>
 221                     {
 222                         SafeBundleHandle bundleHandle = new SafeBundleHandle(bundle, true);
 223                         Applications.Bundle _bundle = new Bundle(bundleHandle);
 224                         CustomCommandReplyEventArgs eventArgs = new CustomCommandReplyEventArgs(serverName, result, _bundle);
 225                         _customcommandReply?.Invoke(this, eventArgs);
 226                     };
 227                 }
 228                 _customcommandReply += value;
 229
 230             }
 231             remove
 232             {
 233                 _customcommandReply -= value;
 234                 if(_customcommandReply == null)
 235                 {
 236                     _customcommandReplyCallback = null;
 237                 }
 238             }
 239         }
 240
 241         /// <summary>
 242         /// gets latest server information </summary>
 243         /// <returns>The name and state of the latest media controller server application: ServerInformation object</returns>
 244         /// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state</exception>
 245         public ServerInformation GetLatestServer()
 246         {
 247             string _name = null;
 248             MediaControllerServerState _state = MediaControllerServerState.None;
 249
 250             MediaControllerValidator.ThrowIfError(\r
 251                 Interop.MediaControllerClient.GetLatestServer(_handle, out _name, out _state), "Get Latest server failed");\r
 252 \r
 253             return new ServerInformation(_name, (MediaControllerServerState)_state);\r
 254         }
 255
 256         /// <summary>
 257         /// gets playback information for specific server </summary>
 258         /// <param name="serverName"> Server Name  </param>
 259         /// <returns>The playback state and playback position of the specific media controller server application:MediaControllerPlayback object</returns>
 260         /// <exception cref="ArgumentException">Thrown when an invalid argument is used</exception>
 261         /// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state</exception>
 262         public MediaControllerPlayback GetPlayback(String serverName)
 263         {
 264             IntPtr _playbackHandle = IntPtr.Zero;
 265
 266             MediaControllerValidator.ThrowIfError(
 267                 Interop.MediaControllerClient.GetServerPlayback(_handle, serverName, out _playbackHandle), "Get Playback handle failed");
 268
 269             return new MediaControllerPlayback (_playbackHandle);
 270         }
 271
 272         /// <summary>
 273         /// gets metadata information for specific server </summary>
 274         /// <param name="serverName"> Server Name  </param>
 275         /// <returns>The metadata information of the specific media controller server application:MediaControllerMetadata object</returns>
 276         /// <exception cref="ArgumentException">Thrown when an invalid argument is used</exception>
 277         /// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state</exception>
 278         public MediaControllerMetadata GetMetadata(String serverName)
 279         {
 280             IntPtr _metadataHandle = IntPtr.Zero;
 281
 282             MediaControllerValidator.ThrowIfError(
 283                 Interop.MediaControllerClient.GetServerMetadata(_handle, serverName, out _metadataHandle), "Get Metadata handle failed");
 284
 285             return new MediaControllerMetadata (_metadataHandle);
 286         }
 287
 288         /// <summary>
 289         /// gets shuffle mode for specific server </summary>
 290         /// <param name="serverName"> Server Name  </param>
 291         /// <returns>The shuffle mode of the specific media controller server application:MediaControllerShuffleMode enum</returns>
 292         /// <exception cref="ArgumentException">Thrown when an invalid argument is used</exception>
 293         /// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state</exception>
 294         public MediaControllerShuffleMode GetShuffleMode(String serverName)
 295         {
 296             MediaControllerShuffleMode _shuffleMode = MediaControllerShuffleMode.Off;
 297
 298             MediaControllerValidator.ThrowIfError(
 299                 Interop.MediaControllerClient.GetServerShuffleMode(_handle, serverName, out _shuffleMode), "Get ShuffleMode failed");
 300
 301             return _shuffleMode;
 302         }
 303
 304         /// <summary>
 305         /// gets repeat mode for specific server </summary>
 306         /// <param name="serverName"> Server Name  </param>
 307         /// <returns>The repeat mode of the specific media controller server application:MediaControllerRepeatMode enum</returns>
 308         /// <exception cref="ArgumentException">Thrown when an invalid argument is used</exception>
 309         /// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state</exception>
 310         public MediaControllerRepeatMode GetRepeatMode(String serverName)
 311         {
 312             MediaControllerRepeatMode _repeatMode = MediaControllerRepeatMode.Off;
 313
 314             MediaControllerValidator.ThrowIfError(
 315                 Interop.MediaControllerClient.GetServerRepeatMode(_handle, serverName, out _repeatMode), "Get RepeatMode failed");
 316
 317             return _repeatMode;
 318         }
 319
 320         /// <summary>
 321         /// Send command of playback state to server application </summary>
 322         /// <param name="serverName"> Server Name  </param>
 323         /// <param name="state"> Playback State  </param>
 324         /// <exception cref="ArgumentException">Thrown when an invalid argument is used</exception>
 325         /// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state</exception>
 326         public void SendPlaybackStateCommand(string serverName, MediaControllerPlaybackState state)
 327         {
 328             MediaControllerValidator.ThrowIfError(
 329                 Interop.MediaControllerClient.SendPlaybackStateCommand(_handle, serverName, state), "Send playback state command failed");
 330         }
 331
 332         /// <summary>
 333         /// Send customized command to server application </summary>
 334         /// <param name="serverName"> Server Name  </param>
 335         /// <param name="command"> Command  </param>
 336         /// <param name="bundle"> Bundle data  </param>
 337         /// <exception cref="ArgumentException">Thrown when an invalid argument is used</exception>
 338         /// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state</exception>
 339         public void SendCustomCommand(string serverName, string command, Bundle bundle)
 340         {
 341             MediaControllerValidator.ThrowIfError(
 342                 Interop.MediaControllerClient.SendCustomCommand(_handle, serverName, command, bundle.SafeBundleHandle, _customcommandReplyCallback, IntPtr.Zero),
 343                 "Send custom command failed");
 344         }
 345
 346         /// <summary>
 347         /// Subscribe subscription type from specific server application </summary>
 348         /// <param name="type"> Subscription Type  </param>
 349         /// <param name="serverName"> Server Name  </param>
 350         /// <exception cref="ArgumentException">Thrown when an invalid argument is used</exception>
 351         public void Subscribe(MediaControllerSubscriptionType type, string serverName)
 352         {
 353             MediaControllerValidator.ThrowIfError(
 354                 Interop.MediaControllerClient.Subscribe(_handle, type, serverName), "Subscribe failed");
 355         }
 356
 357         /// <summary>
 358         /// Subscribe subscription type from specific server application </summary>
 359         /// <param name="type"> Subscription Type  </param>
 360         /// <param name="serverName"> Server Name  </param>
 361         /// <exception cref="ArgumentException">Thrown when an invalid argument is used</exception>
 362         public void Unsubscribe(MediaControllerSubscriptionType type, string serverName)
 363         {
 364             MediaControllerValidator.ThrowIfError(
 365                 Interop.MediaControllerClient.Unsubscribe(_handle, type, serverName), "Unsubscribe failed");
 366         }
 367
 368         /// <summary>
 369         /// gets activated server list </summary>
 370         /// <returns>The list of activated media controller server applications: IEnumerable of string</returns>
 371         public Task<IEnumerable<string>> GetActivatedServerList()
 372         {
 373             var task = new TaskCompletionSource<IEnumerable<string>>();
 374
 375             List<string> collectionList = ForEachActivatedServer(_handle);
 376             task.TrySetResult((IEnumerable<string>)collectionList);
 377
 378             return task.Task;
 379         }
 380
 381         /// <summary>
 382         /// gets subscribed server list </summary>
 383         /// <param name="subscriptionType"> Subscription Type  </param>
 384         /// <returns>The list of subscribed media controller server applications: IEnumerable of string</returns>
 385         /// <exception cref="ArgumentException">Thrown when an invalid argument is used</exception>
 386         /// <exception cref="InvalidOperationException">Thrown when the operation is invalid for the current state</exception>
 387         public Task<IEnumerable<string>> GetSubscribedServerList(MediaControllerSubscriptionType subscriptionType)
 388         {
 389             var task = new TaskCompletionSource<IEnumerable<string>>();
 390
 391             List<string> collectionList = ForEachSubscribedServer(_handle, subscriptionType);
 392             task.TrySetResult((IEnumerable<string>)collectionList);
 393
 394             return task.Task;
 395         }
 396
 397         private void RegisterServerUpdatedEvent()
 398         {
 399             _serverUpdatedCallback = (string serverName, MediaControllerServerState serverState, IntPtr userData) =>
 400             {
 401                 ServerUpdatedEventArgs eventArgs = new ServerUpdatedEventArgs(serverName, serverState);
 402                 _serverUpdated?.Invoke(this, eventArgs);
 403             };
 404             Interop.MediaControllerClient.SetServerUpdatedCb(_handle, _serverUpdatedCallback, IntPtr.Zero);
 405         }
 406
 407         private void UnregisterServerUpdatedEvent()
 408         {
 409             Interop.MediaControllerClient.UnsetServerUpdatedCb(_handle);
 410         }
 411
 412         private void RegisterPlaybackUpdatedEvent()
 413         {
 414             _playbackUpdatedCallback = (string serverName, IntPtr playback, IntPtr userData) =>
 415             {
 416                 PlaybackUpdatedEventArgs eventArgs = new PlaybackUpdatedEventArgs(serverName, playback);
 417                 _playbackUpdated?.Invoke(this, eventArgs);
 418             };
 419             Interop.MediaControllerClient.SetPlaybackUpdatedCb(_handle, _playbackUpdatedCallback, IntPtr.Zero);
 420         }
 421
 422         private void UnregisterPlaybackUpdatedEvent()
 423         {
 424             Interop.MediaControllerClient.UnsetPlaybackUpdatedCb(_handle);
 425         }
 426
 427         private void RegisterMetadataUpdatedEvent()
 428         {
 429             _metadataUpdatedCallback = (string serverName, IntPtr metadata, IntPtr userData) =>
 430             {
 431                 MetadataUpdatedEventArgs eventArgs = new MetadataUpdatedEventArgs(serverName, metadata);
 432                 _metadataUpdated?.Invoke(this, eventArgs);
 433             };
 434             Interop.MediaControllerClient.SetMetadataUpdatedCb(_handle, _metadataUpdatedCallback, IntPtr.Zero);
 435         }
 436
 437         private void UnregisterMetadataUpdatedEvent()
 438         {
 439             Interop.MediaControllerClient.UnsetMetadataUpdatedCb(_handle);
 440         }
 441
 442         private void RegisterShuffleModeUpdatedEvent()
 443         {
 444             _shufflemodeUpdatedCallback = (string serverName, MediaControllerShuffleMode shuffleMode, IntPtr userData) =>
 445             {
 446                 ShuffleModeUpdatedEventArgs eventArgs = new ShuffleModeUpdatedEventArgs(serverName, shuffleMode);
 447                 _shufflemodeUpdated?.Invoke(this, eventArgs);
 448             };
 449
 450             MediaControllerValidator.ThrowIfError(
 451                 Interop.MediaControllerClient.SetShuffleModeUpdatedCb(_handle, _shufflemodeUpdatedCallback, IntPtr.Zero),
 452                 "Set ShuffleModeUpdated callback failed");
 453         }
 454
 455         private void UnregisterShuffleModeUpdatedEvent()
 456         {
 457             Interop.MediaControllerClient.UnsetShuffleModeUpdatedCb(_handle);
 458         }
 459
 460         private void RegisterRepeatModeUpdatedEvent()
 461         {
 462             _repeatmodeUpdatedCallback = (string serverName, MediaControllerRepeatMode repeatMode, IntPtr userData) =>
 463             {
 464                 RepeatModeUpdatedEventArgs eventArgs = new RepeatModeUpdatedEventArgs(serverName, repeatMode);
 465                 _repeatmodeUpdated?.Invoke(this, eventArgs);
 466             };
 467
 468             MediaControllerValidator.ThrowIfError(
 469                 Interop.MediaControllerClient.SetRepeatModeUpdatedCb(_handle, _repeatmodeUpdatedCallback, IntPtr.Zero),
 470                 "Set RepeatModeUpdated callback failed");
 471         }
 472
 473         private void UnregisterRepeatModeUpdatedEvent()
 474         {
 475             Interop.MediaControllerClient.UnsetRepeatModeUpdatedCb(_handle);
 476         }
 477
 478         private static List<string> ForEachSubscribedServer(IntPtr handle, MediaControllerSubscriptionType subscriptionType)
 479         {
 480             List<string> subscribedServerCollections = new List<string>();
 481
 482             Interop.MediaControllerClient.SubscribedServerCallback serverCallback = (string serverName, IntPtr userData) =>
 483             {
 484                 subscribedServerCollections.Add (serverName);
 485                 return true;
 486             };
 487
 488             MediaControllerValidator.ThrowIfError(
 489                 Interop.MediaControllerClient.ForeachSubscribedServer(handle, subscriptionType, serverCallback, IntPtr.Zero),
 490                 "Foreach Subscribed server failed");
 491
 492             return subscribedServerCollections;
 493         }
 494
 495         private static List<string> ForEachActivatedServer(IntPtr handle)
 496         {
 497             List<string> activatedServerCollections = new List<string>();
 498
 499             Interop.MediaControllerClient.ActivatedServerCallback serverCallback = (string serverName, IntPtr userData) =>
 500             {
 501                 activatedServerCollections.Add(serverName);\r
 502                 return true;
 503             };
 504
 505             MediaControllerValidator.ThrowIfError(
 506                 Interop.MediaControllerClient.ForeachActivatedServer(handle, serverCallback, IntPtr.Zero),
 507                 "Foreach Activated server failed");
 508
 509             return activatedServerCollections;
 510         }
 511     }
 512 }
 513