src/Tizen.Multimedia.Remoting/MediaController/MediaControllerManager.Events.cs

   1 /*
   2  * Copyright (c) 2018 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 Tizen.Applications;
  19 using Native = Interop.MediaControllerClient;
  20 using NativePlaylist = Interop.MediaControllerPlaylist;
  21
  22 namespace Tizen.Multimedia.Remoting
  23 {
  24     public partial class MediaControllerManager
  25     {
  26         // Updated event
  27         private Native.ServerUpdatedCallback _serverUpdatedCallback;
  28         private Native.PlaybackUpdatedCallback _playbackUpdatedCallback;
  29         private NativePlaylist.PlaylistUpdatedCallback _playlistUpdatedCallback;
  30         private NativePlaylist.MetadataUpdatedCallback _metadataUpdatedCallback;
  31         private Native.ShuffleModeUpdatedCallback _shufflemodeUpdatedCallback;
  32         private Native.RepeatModeUpdatedCallback _repeatmodeUpdatedCallback;
  33         private Native.BoolAttributeUpdatedCallback _subtitleModeUpdatedCallback;
  34         private Native.BoolAttributeUpdatedCallback _mode360UpdatedCallback;
  35         private Native.DisplayModeUpdatedCallback _displayModeUpdatedCallback;
  36         private Native.DisplayRotationUpdatedCallback _displayRotationUpdatedCallback;
  37
  38         // Capability updated event
  39         private Native.PlaybackCapabilityUpdatedCallback _playbackCapabilityUpdatedCallback;
  40         private Native.SimpleCapabilityUpdatedCallback _categoryCapabilityUpdatedCallback;
  41         private Native.CategoryAttributeCapabilityUpdatedCallback _displayModeCapabilityUpdatedCallback;
  42         private Native.CategoryAttributeCapabilityUpdatedCallback _displayRotationCapabilityUpdatedCallback;
  43
  44         // Command
  45         private Native.CommandCompletedCallback _commandCompletedCallback;
  46         private Native.CustomCommandReceivedCallback _customEventReceivedCallback;
  47
  48
  49         /// <summary>
  50         /// Occurs when a server is started.
  51         /// </summary>
  52         /// <since_tizen> 4 </since_tizen>
  53         public event EventHandler<MediaControlServerStartedEventArgs> ServerStarted;
  54
  55         /// <summary>
  56         /// Occurs when a server is stopped.
  57         /// </summary>
  58         /// <since_tizen> 4 </since_tizen>
  59         public event EventHandler<MediaControlServerStoppedEventArgs> ServerStopped;
  60
  61         private void InitializeEvents()
  62         {
  63             RegisterPlaybackUpdatedEvent();
  64             RegisterServerUpdatedEvent();
  65             RegisterMetadataUpdatedEvent();
  66             RegisterShuffleModeUpdatedEvent();
  67             RegisterRepeatModeUpdatedEvent();
  68             RegisterPlaylistUpdatedEvent();
  69             RegisterSubtitleModeUpdateEvent();
  70             RegisterMode360UpdateEvent();
  71             RegisterDisplayModeUpdateEvent();
  72             RegisterDisplayRotationUpdateEvent();
  73
  74             RegisterPlaybackCapabilitiesEvent();
  75             RegisterDisplayModeCapabilityUpdatedEvent();
  76             RegisterDisplayRotationCapabilityUpdatedEvent();
  77             RegisterSimpleCapabilityUpdatedEvent();
  78
  79             RegisterCommandCompletedEvent();
  80             RegisterCustomCommandReceivedEvent();
  81         }
  82
  83         private void RaiseServerChangedEvent(MediaControllerNativeServerState state, MediaController controller)
  84         {
  85             if (controller == null)
  86             {
  87                 return;
  88             }
  89
  90             if (state == MediaControllerNativeServerState.Activated)
  91             {
  92                 ServerStarted?.Invoke(this, new MediaControlServerStartedEventArgs(controller));
  93             }
  94             else
  95             {
  96                 controller.RaiseStoppedEvent();
  97                 ServerStopped?.Invoke(this, new MediaControlServerStoppedEventArgs(controller.ServerAppId));
  98             }
  99         }
 100
 101
 102         #region Updated event
 103         private void RegisterServerUpdatedEvent()
 104         {
 105             _serverUpdatedCallback = (serverName, state, _) =>
 106             {
 107                 RaiseServerChangedEvent(state, HandleServerUpdated(serverName, state));
 108             };
 109
 110             Native.SetServerUpdatedCb(Handle, _serverUpdatedCallback).
 111                 ThrowIfError("Failed to register server changed event.");
 112         }
 113
 114         private void RegisterPlaybackUpdatedEvent()
 115         {
 116             _playbackUpdatedCallback = (serverName, playbackHandle, _) =>
 117             {
 118                 GetController(serverName)?.RaisePlaybackUpdatedEvent(playbackHandle);
 119             };
 120
 121             Native.SetPlaybackUpdatedCb(Handle, _playbackUpdatedCallback).
 122                 ThrowIfError("Failed to register PlaybackUpdated event.");
 123         }
 124
 125         private void RegisterPlaylistUpdatedEvent()
 126         {
 127             _playlistUpdatedCallback = (serverName, playlistMode, name, playlistHandle, _) =>
 128             {
 129                 GetController(serverName)?.RaisePlaylistUpdatedEvent(playlistMode, name, playlistHandle);
 130             };
 131
 132             NativePlaylist.SetPlaylistModeUpdatedCb(Handle, _playlistUpdatedCallback).
 133                 ThrowIfError("Failed to register PlaylistUpdated event.");
 134         }
 135
 136         private void RegisterMetadataUpdatedEvent()
 137         {
 138             _metadataUpdatedCallback = (serverName, metadata, _) =>
 139             {
 140                 GetController(serverName)?.RaiseMetadataUpdatedEvent(metadata);
 141             };
 142
 143             NativePlaylist.SetMetadataUpdatedCb(Handle, _metadataUpdatedCallback).
 144                 ThrowIfError("Failed to register MetadataUpdated event.");
 145         }
 146
 147         private void RegisterShuffleModeUpdatedEvent()
 148         {
 149             _shufflemodeUpdatedCallback = (serverName, shuffleMode, _) =>
 150             {
 151                 GetController(serverName)?.RaiseShuffleModeUpdatedEvent(shuffleMode);
 152             };
 153
 154             Native.SetShuffleModeUpdatedCb(Handle, _shufflemodeUpdatedCallback).
 155                 ThrowIfError("Failed to register ShuffleModeUpdated event.");
 156         }
 157
 158         private void RegisterRepeatModeUpdatedEvent()
 159         {
 160             _repeatmodeUpdatedCallback = (serverName, repeatMode, _) =>
 161             {
 162                 GetController(serverName)?.RaiseRepeatModeUpdatedEvent(repeatMode.ToPublic());
 163             };
 164
 165             Native.SetRepeatModeUpdatedCb(Handle, _repeatmodeUpdatedCallback).
 166                 ThrowIfError("Failed to register RepeatModeUpdated event.");
 167         }
 168
 169         private void RegisterSubtitleModeUpdateEvent()
 170         {
 171             _subtitleModeUpdatedCallback = (serverName, isEnabled, _) =>
 172             {
 173                 GetController(serverName)?.RaiseSubtitleModeUpdatedEvent(isEnabled);
 174             };
 175
 176             Native.SetSubtitleUpdatedCb(Handle, _subtitleModeUpdatedCallback).
 177                 ThrowIfError("Failed to register SubtitleModeUpdated event.");
 178         }
 179
 180         private void RegisterMode360UpdateEvent()
 181         {
 182             _mode360UpdatedCallback = (serverName, isEnabled, _) =>
 183             {
 184                 GetController(serverName)?.RaiseMode360UpdatedEvent(isEnabled);
 185             };
 186
 187             Native.SetMode360UpdatedCb(Handle, _mode360UpdatedCallback).
 188                 ThrowIfError("Failed to register Mode360Updated event.");
 189         }
 190
 191         private void RegisterDisplayModeUpdateEvent()
 192         {
 193             _displayModeUpdatedCallback = (serverName, mode, _) =>
 194             {
 195                 GetController(serverName)?.RaiseDisplayModeUpdatedEvent(mode);
 196             };
 197
 198             Native.SetDisplayModeUpdatedCb(Handle, _displayModeUpdatedCallback).
 199                 ThrowIfError("Failed to register DisplayModeUpdated event.");
 200         }
 201
 202         private void RegisterDisplayRotationUpdateEvent()
 203         {
 204             _displayRotationUpdatedCallback = (serverName, rotation, _) =>
 205             {
 206                 GetController(serverName)?.RaiseDisplayRotationUpdatedEvent(rotation);
 207             };
 208
 209             Native.SetDisplayRotationUpdatedCb(Handle, _displayRotationUpdatedCallback).
 210                 ThrowIfError("Failed to register DisplayRotationUpdated event.");
 211         }
 212         #endregion
 213
 214
 215         #region Command
 216         private void RegisterCommandCompletedEvent()
 217         {
 218             _commandCompletedCallback = (serverName, requestId, result, bundleHandle, _) =>
 219             {
 220                 // SafeHandles cannot be marshaled from unmanaged to managed.
 221                 // So we use IntPtr type for 'bundleHandle' in native callback.
 222                 GetController(serverName)?.RaiseCommandCompletedEvent(requestId, result, bundleHandle);
 223             };
 224
 225             Native.SetCommandCompletedCb(Handle, _commandCompletedCallback).
 226                 ThrowIfError("Failed to register CommandCompleted event.");
 227         }
 228
 229         private void RegisterCustomCommandReceivedEvent()
 230         {
 231             _customEventReceivedCallback = (serverName, requestId, customEvent, bundleHandle, _) =>
 232             {
 233                 CustomCommand command = null;
 234                 if (bundleHandle != IntPtr.Zero)
 235                 {
 236                     command = new CustomCommand(customEvent, new Bundle(new SafeBundleHandle(bundleHandle, true)));
 237                 }
 238                 else
 239                 {
 240                     command = new CustomCommand(customEvent);
 241                 }
 242
 243                 command.SetResponseInformation(serverName, requestId);
 244
 245                 GetController(serverName)?.RaiseCustomCommandReceivedEvent(command);
 246             };
 247
 248             Native.SetCustomEventCb(Handle, _customEventReceivedCallback).
 249                 ThrowIfError("Failed to register CustomCommandReceived event.");
 250         }
 251         #endregion
 252
 253
 254         #region Capability updated event
 255         private void RegisterPlaybackCapabilitiesEvent()
 256         {
 257             _playbackCapabilityUpdatedCallback = (serverName, playbackCapaHandle, _) =>
 258             {
 259                 GetController(serverName)?.RaisePlaybackCapabilityUpdatedEvent(playbackCapaHandle);
 260             };
 261
 262             Native.SetPlaybackCapabilityUpdatedCb(Handle, _playbackCapabilityUpdatedCallback).
 263                 ThrowIfError("Failed to register PlaybackCapabilityUpdated event.");
 264         }
 265
 266         private void RegisterDisplayModeCapabilityUpdatedEvent()
 267         {
 268             _displayModeCapabilityUpdatedCallback = (serverName, modes, _) =>
 269             {
 270                 GetController(serverName)?.RaiseDisplayModeCapabilityUpdatedEvent(
 271                     (MediaControlNativeDisplayMode)modes);
 272             };
 273
 274             Native.SetDisplayModeCapabilityUpdatedCb(Handle, _displayModeCapabilityUpdatedCallback).
 275                 ThrowIfError("Failed to register DisplayModeCapabilityUpdated event.");
 276         }
 277
 278         private void RegisterDisplayRotationCapabilityUpdatedEvent()
 279         {
 280             _displayRotationCapabilityUpdatedCallback = (serverName, rotations, _) =>
 281             {
 282                 GetController(serverName)?.RaiseDisplayRotationCapabilityUpdatedEvent(
 283                     (MediaControlNativeDisplayRotation)rotations);
 284             };
 285
 286             Native.SetDisplayRotationCapabilityUpdatedCb(Handle, _displayRotationCapabilityUpdatedCallback).
 287                 ThrowIfError("Failed to register DisplayRotationCapabilityUpdated event.");
 288         }
 289
 290         private void RegisterSimpleCapabilityUpdatedEvent()
 291         {
 292             _categoryCapabilityUpdatedCallback = (serverName, category, support, _) =>
 293             {
 294                 switch (category)
 295                 {
 296                     case MediaControlNativeCapabilityCategory.Repeat:
 297                         GetController(serverName)?.RaiseRepeatModeCapabilityUpdatedEvent(support);
 298                         break;
 299                     case MediaControlNativeCapabilityCategory.Shuffle:
 300                         GetController(serverName)?.RaiseShuffleModeCapabilityUpdatedEvent(support);
 301                         break;
 302                 }
 303             };
 304
 305             Native.SetCategoryCapabilityUpdatedCb(Handle, _categoryCapabilityUpdatedCallback).
 306                 ThrowIfError("Failed to register capability updated event.");
 307         }
 308         #endregion
 309     }
 310 }