src/Tizen.Multimedia.MediaPlayer/Player/Player.Events.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 static Interop;
  18 using System;
  19 using System.ComponentModel;
  20 using System.Diagnostics;
  21
  22 namespace Tizen.Multimedia
  23 {
  24     public partial class Player
  25     {
  26         /// <summary>
  27         /// Occurs when the playback of a media is finished.
  28         /// </summary>
  29         /// <since_tizen> 3 </since_tizen>
  30         public event EventHandler<EventArgs> PlaybackCompleted;
  31         private NativePlayer.PlaybackCompletedCallback _playbackCompletedCallback;
  32
  33         /// <summary>
  34         /// Occurs when the playback of a media is interrupted.
  35         /// </summary>
  36         /// <remarks>
  37         /// If the reason is <see cref="PlaybackInterruptionReason.ResourceConflict"/>,
  38         /// the player state will be one of <see cref="PlayerState.Idle"/>, <see cref="PlayerState.Ready"/>,
  39         /// or <see cref="PlayerState.Paused"/>.
  40         /// </remarks>
  41         /// <seealso cref="Player.State"/>
  42         /// <since_tizen> 3 </since_tizen>
  43         public event EventHandler<PlaybackInterruptedEventArgs> PlaybackInterrupted;
  44         private NativePlayer.PlaybackInterruptedCallback _playbackInterruptedCallback;
  45
  46         /// <summary>
  47         /// Occurs when any error occurs.
  48         /// </summary>
  49         /// <remarks>The event handler will be executed on an internal thread.</remarks>
  50         /// <since_tizen> 3 </since_tizen>
  51         public event EventHandler<PlayerErrorOccurredEventArgs> ErrorOccurred;
  52         private NativePlayer.PlaybackErrorCallback _playbackErrorCallback;
  53
  54         /// <summary>
  55         /// Occurs when the video stream is changed.
  56         /// </summary>
  57         /// <remarks>The event handler will be executed on an internal thread.</remarks>
  58         /// <since_tizen> 3 </since_tizen>
  59         public event EventHandler<VideoStreamChangedEventArgs> VideoStreamChanged;
  60         private NativePlayer.VideoStreamChangedCallback _videoStreamChangedCallback;
  61
  62         /// <summary>
  63         /// Occurs when the subtitle is updated.
  64         /// </summary>
  65         /// <remarks>The event handler will be executed on an internal thread.</remarks>
  66         /// <since_tizen> 3 </since_tizen>
  67         public event EventHandler<SubtitleUpdatedEventArgs> SubtitleUpdated;
  68         private NativePlayer.SubtitleUpdatedCallback _subtitleUpdatedCallback;
  69
  70         /// <summary>
  71         /// Occurs when there is a change in the buffering status of streaming.
  72         /// </summary>
  73         /// <since_tizen> 3 </since_tizen>
  74         public event EventHandler<BufferingProgressChangedEventArgs> BufferingProgressChanged;
  75         private NativePlayer.BufferingProgressCallback _bufferingProgressCallback;
  76
  77         internal event EventHandler<MediaStreamBufferStatusChangedEventArgs> MediaStreamAudioBufferStatusChanged;
  78         private NativePlayer.MediaStreamBufferStatusCallback _mediaStreamAudioBufferStatusChangedCallback;
  79
  80         internal event EventHandler<MediaStreamBufferStatusChangedEventArgs> MediaStreamVideoBufferStatusChanged;
  81         private NativePlayer.MediaStreamBufferStatusCallback _mediaStreamVideoBufferStatusChangedCallback;
  82
  83         internal event EventHandler<MediaStreamSeekingOccurredEventArgs> MediaStreamAudioSeekingOccurred;
  84         private NativePlayer.MediaStreamSeekCallback _mediaStreamAudioSeekCallback;
  85
  86         internal event EventHandler<MediaStreamSeekingOccurredEventArgs> MediaStreamVideoSeekingOccurred;
  87         private NativePlayer.MediaStreamSeekCallback _mediaStreamVideoSeekCallback;
  88
  89         private void RegisterEvents()
  90         {
  91             RegisterSubtitleUpdatedCallback();
  92             RegisterErrorOccurredCallback();
  93             RegisterPlaybackInterruptedCallback();
  94             RegisterVideoStreamChangedCallback();
  95             RegisterBufferingCallback();
  96             RegisterMediaStreamBufferStatusCallback();
  97             RegisterMediaStreamSeekCallback();
  98             RegisterPlaybackCompletedCallback();
  99         }
 100
 101         private void RegisterSubtitleUpdatedCallback()
 102         {
 103             _subtitleUpdatedCallback = (duration, text, _) =>
 104             {
 105                 Log.Debug(PlayerLog.Tag, $"duration : {duration}, text : {text}");
 106                 SubtitleUpdated?.Invoke(this, new SubtitleUpdatedEventArgs(duration, text));
 107             };
 108
 109             NativePlayer.SetSubtitleUpdatedCb(Handle, _subtitleUpdatedCallback).
 110                 ThrowIfFailed(this, "Failed to initialize the player");
 111         }
 112
 113         private void RegisterPlaybackCompletedCallback()
 114         {
 115             _playbackCompletedCallback = _ =>
 116             {
 117                 Log.Debug(PlayerLog.Tag, "completed callback");
 118                 PlaybackCompleted?.Invoke(this, EventArgs.Empty);
 119             };
 120             NativePlayer.SetCompletedCb(Handle, _playbackCompletedCallback).
 121                 ThrowIfFailed(this, "Failed to set PlaybackCompleted");
 122         }
 123
 124         private void RegisterPlaybackInterruptedCallback()
 125         {
 126             _playbackInterruptedCallback = (code, _) =>
 127             {
 128                 if (!Enum.IsDefined(typeof(PlaybackInterruptionReason), code))
 129                 {
 130                     return;
 131                 }
 132
 133                 if (code == PlaybackInterruptionReason.ResourceConflict)
 134                 {
 135                     OnUnprepared();
 136                 }
 137
 138                 Log.Warn(PlayerLog.Tag, $"interrupted reason : {code}");
 139                 PlaybackInterrupted?.Invoke(this, new PlaybackInterruptedEventArgs(code));
 140             };
 141
 142             NativePlayer.SetInterruptedCb(Handle, _playbackInterruptedCallback).
 143                 ThrowIfFailed(this, "Failed to set PlaybackInterrupted");
 144         }
 145
 146         private void RegisterErrorOccurredCallback()
 147         {
 148             _playbackErrorCallback = (code, _) =>
 149             {
 150                 //TODO handle service disconnected error.
 151                 Log.Warn(PlayerLog.Tag, "error code : " + code);
 152                 ErrorOccurred?.Invoke(this, new PlayerErrorOccurredEventArgs((PlayerError)code));
 153             };
 154
 155             NativePlayer.SetErrorCb(Handle, _playbackErrorCallback).
 156                 ThrowIfFailed(this, "Failed to set PlaybackError");
 157         }
 158
 159         /// <summary>
 160         /// Raises the <see cref="ErrorOccurred"/> event.
 161         /// </summary>
 162         /// <param name="e">
 163         /// An <see cref="PlayerErrorOccurredEventArgs"/> that contains the event data.
 164         /// </param>
 165         [EditorBrowsable(EditorBrowsableState.Never)]
 166         protected void OnErrorOccurred(PlayerErrorOccurredEventArgs e)
 167         {
 168             ErrorOccurred?.Invoke(this, e);
 169         }
 170
 171         #region VideoFrameDecoded event
 172
 173         private EventHandler<VideoFrameDecodedEventArgs> _videoFrameDecoded;
 174
 175         private NativePlayer.VideoFrameDecodedCallback _videoFrameDecodedCallback;
 176
 177         /// <summary>
 178         /// Occurs when a video frame is decoded.
 179         /// </summary>
 180         /// <remarks>
 181         ///     <para>The event handler will be executed on an internal thread.</para>
 182         ///     <para>The <see cref="VideoFrameDecodedEventArgs.Packet"/> in event args should be disposed after use.</para>
 183         /// </remarks>
 184         /// <feature>http://tizen.org/feature/multimedia.raw_video</feature>
 185         /// <exception cref="NotSupportedException">The required feature is not supported.</exception>
 186         /// <seealso cref="VideoFrameDecodedEventArgs.Packet"/>
 187         /// <since_tizen> 3 </since_tizen>
 188         public event EventHandler<VideoFrameDecodedEventArgs> VideoFrameDecoded
 189         {
 190             add
 191             {
 192                 ValidationUtil.ValidateFeatureSupported(PlayerFeatures.RawVideo);
 193
 194                 _videoFrameDecoded += value;
 195             }
 196             remove
 197             {
 198                 ValidationUtil.ValidateFeatureSupported(PlayerFeatures.RawVideo);
 199
 200                 _videoFrameDecoded -= value;
 201             }
 202         }
 203
 204         private void RegisterVideoFrameDecodedCallback()
 205         {
 206             _videoFrameDecodedCallback = (packetHandle, _) =>
 207             {
 208                 var handler = _videoFrameDecoded;
 209                 if (handler != null)
 210                 {
 211                     Log.Debug(PlayerLog.Tag, "packet : " + packetHandle);
 212                     handler.Invoke(this,
 213                         new VideoFrameDecodedEventArgs(MediaPacket.From(packetHandle)));
 214                 }
 215                 else
 216                 {
 217                     MediaPacket.From(packetHandle).Dispose();
 218                 }
 219             };
 220
 221             NativePlayer.SetVideoFrameDecodedCb(Handle, _videoFrameDecodedCallback).
 222                 ThrowIfFailed(this, "Failed to register the VideoFrameDecoded");
 223         }
 224         #endregion
 225
 226         private void RegisterVideoStreamChangedCallback()
 227         {
 228             _videoStreamChangedCallback = (width, height, fps, bitrate, _) =>
 229             {
 230                 Log.Debug(PlayerLog.Tag, $"height={height}, width={width}, fps={fps}, bitrate={bitrate}");
 231
 232                 VideoStreamChanged?.Invoke(this, new VideoStreamChangedEventArgs(height, width, fps, bitrate));
 233             };
 234
 235             NativePlayer.SetVideoStreamChangedCb(Handle, _videoStreamChangedCallback).
 236                 ThrowIfFailed(this, "Failed to set the video stream changed callback");
 237         }
 238
 239         private void RegisterBufferingCallback()
 240         {
 241             _bufferingProgressCallback = (percent, _) =>
 242             {
 243                 Log.Debug(PlayerLog.Tag, $"Buffering callback with percent { percent }");
 244
 245                 BufferingProgressChanged?.Invoke(this, new BufferingProgressChangedEventArgs(percent));
 246             };
 247
 248             NativePlayer.SetBufferingCb(Handle, _bufferingProgressCallback).
 249                 ThrowIfFailed(this, "Failed to set BufferingProgress");
 250         }
 251
 252         private void RegisterMediaStreamBufferStatusCallback()
 253         {
 254             _mediaStreamAudioBufferStatusChangedCallback = (status, _) =>
 255             {
 256                 Debug.Assert(Enum.IsDefined(typeof(MediaStreamBufferStatus), status));
 257                 Log.Debug(PlayerLog.Tag, "audio buffer status : " + status);
 258
 259                 MediaStreamAudioBufferStatusChanged?.Invoke(this,
 260                     new MediaStreamBufferStatusChangedEventArgs(status));
 261             };
 262             _mediaStreamVideoBufferStatusChangedCallback = (status, _) =>
 263             {
 264                 Debug.Assert(Enum.IsDefined(typeof(MediaStreamBufferStatus), status));
 265                 Log.Debug(PlayerLog.Tag, "video buffer status : " + status);
 266
 267                 MediaStreamVideoBufferStatusChanged?.Invoke(this,
 268                     new MediaStreamBufferStatusChangedEventArgs(status));
 269             };
 270
 271             RegisterMediaStreamBufferStatusCallback(StreamType.Audio, _mediaStreamAudioBufferStatusChangedCallback);
 272             RegisterMediaStreamBufferStatusCallback(StreamType.Video, _mediaStreamVideoBufferStatusChangedCallback);
 273         }
 274
 275         private void RegisterMediaStreamBufferStatusCallback(StreamType streamType,
 276             NativePlayer.MediaStreamBufferStatusCallback cb)
 277         {
 278             NativePlayer.SetMediaStreamBufferStatusCb(Handle, streamType, cb).
 279                 ThrowIfFailed(this, "Failed to SetMediaStreamBufferStatus");
 280         }
 281
 282         private void RegisterMediaStreamSeekCallback()
 283         {
 284             _mediaStreamAudioSeekCallback = (offset, _) =>
 285             {
 286                 Log.Debug(PlayerLog.Tag, "audio seeking offset : " + offset);
 287                 MediaStreamAudioSeekingOccurred?.Invoke(this, new MediaStreamSeekingOccurredEventArgs(offset));
 288             };
 289             _mediaStreamVideoSeekCallback = (offset, _) =>
 290             {
 291                 Log.Debug(PlayerLog.Tag, "video seeking offset : " + offset);
 292                 MediaStreamVideoSeekingOccurred?.Invoke(this, new MediaStreamSeekingOccurredEventArgs(offset));
 293             };
 294
 295             RegisterMediaStreamSeekCallback(StreamType.Audio, _mediaStreamAudioSeekCallback);
 296             RegisterMediaStreamSeekCallback(StreamType.Video, _mediaStreamVideoSeekCallback);
 297         }
 298
 299         private void RegisterMediaStreamSeekCallback(StreamType streamType, NativePlayer.MediaStreamSeekCallback cb)
 300         {
 301             NativePlayer.SetMediaStreamSeekCb(Handle, streamType, cb).
 302                 ThrowIfFailed(this, "Failed to SetMediaStreamSeek");
 303         }
 304     }
 305 }