src/Tizen.Multimedia.Remoting/WebRTC/WebRTC.Events.cs

   1 /*
   2  * Copyright (c) 2021 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 static Interop;
  19
  20 namespace Tizen.Multimedia.Remoting
  21 {
  22     /// <summary>
  23     /// Provides the ability to control WebRTC.
  24     /// </summary>
  25     /// <since_tizen> 9 </since_tizen>
  26     public partial class WebRTC
  27     {
  28         private NativeWebRTC.ErrorOccurredCallback _webRtcErrorOccurredCallback;
  29         private NativeWebRTC.StateChangedCallback _webRtcStateChangedCallback;
  30         private NativeWebRTC.IceGatheringStateChangedCallback _webRtcIceGatheringStateChangedCallback;
  31         private NativeWebRTC.SignalingStateChangedCallback _webRtcSignalingStateChangedCallback;
  32         private NativeWebRTC.PeerConnectionStateChangedCallback _webRtcPeerConnectionStateChangedCallback;
  33         private NativeWebRTC.IceConnectionStateChangedCallback _webRtcIceConnectionStateChangedCallback;
  34         private NativeWebRTC.NegotiationNeededCallback _webRtcNegotiationNeededCallback;
  35         private NativeWebRTC.IceCandidateCallback _webRtcIceCandidateCallback;
  36         private NativeWebRTC.TrackAddedCallback _webRtcTrackAddedCallback;
  37         private NativeWebRTC.FrameEncodedCallback _webRtcAudioFrameEncodedCallback;
  38         private NativeWebRTC.FrameEncodedCallback _webRtcVideoFrameEncodedCallback;
  39         private NativeDataChannel.CreatedCallback _webRtcDataChannelCreatedCallback;
  40
  41         /// <summary>
  42         /// Occurs when any error occurs.
  43         /// </summary>
  44         /// <since_tizen> 9 </since_tizen>
  45         public event EventHandler<WebRTCErrorOccurredEventArgs> ErrorOccurred;
  46
  47         /// <summary>
  48         /// Occurs when WebRTC state is changed.
  49         /// </summary>
  50         /// <since_tizen> 9 </since_tizen>
  51         public event EventHandler<WebRTCStateChangedEventArgs> StateChanged;
  52
  53         /// <summary>
  54         /// Occurs when the WebRTC ICE gathering state is changed.
  55         /// </summary>
  56         /// <since_tizen> 9 </since_tizen>
  57         public event EventHandler<WebRTCIceGatheringStateChangedEventArgs> IceGatheringStateChanged;
  58
  59         /// <summary>
  60         /// Occurs when the WebRTC signaling state is changed.
  61         /// </summary>
  62         /// <since_tizen> 9 </since_tizen>
  63         public event EventHandler<WebRTCSignalingStateChangedEventArgs> SignalingStateChanged;
  64
  65         /// <summary>
  66         /// Occurs when the WebRTC peer connection state is changed.
  67         /// </summary>
  68         /// <since_tizen> 9 </since_tizen>
  69         public event EventHandler<WebRTCPeerConnectionStateChangedEventArgs> PeerConnectionStateChanged;
  70
  71         /// <summary>
  72         /// Occurs when the WebRTC ICE connection state is changed.
  73         /// </summary>
  74         /// <since_tizen> 9 </since_tizen>
  75         public event EventHandler<WebRTCIceConnectionStateChangedEventArgs> IceConnectionStateChanged;
  76
  77         /// <summary>
  78         /// Occurs when negotiation is needed.
  79         /// </summary>
  80         /// <since_tizen> 9 </since_tizen>
  81         public event EventHandler<EventArgs> NegotiationNeeded;
  82
  83         /// <summary>
  84         /// Occurs when the WebRTC needs to send the ICE candidate message to the remote peer.
  85         /// </summary>
  86         /// <since_tizen> 9 </since_tizen>
  87         public event EventHandler<WebRTCIceCandidateEventArgs> IceCandidate;
  88
  89         /// <summary>
  90         /// Occurs when a new track has been added to the WebRTC.
  91         /// </summary>
  92         /// <since_tizen> 9 </since_tizen>
  93         public event EventHandler<WebRTCTrackAddedEventArgs> TrackAdded;
  94
  95         private event EventHandler<WebRTCFrameEncodedEventArgs> _audioFrameEncoded;
  96
  97         /// <summary>
  98         /// Occurs when each audio frame is ready to render.
  99         /// </summary>
 100         /// <since_tizen> 9 </since_tizen>
 101         public event EventHandler<WebRTCFrameEncodedEventArgs> AudioFrameEncoded
 102         {
 103             add
 104             {
 105                 if (_audioFrameEncoded == null)
 106                 {
 107                     RegisterAudioFrameEncodedCallback();
 108                 }
 109
 110                 _audioFrameEncoded += value;
 111             }
 112             remove
 113             {
 114                 _audioFrameEncoded -= value;
 115
 116                 if (_audioFrameEncoded == null)
 117                 {
 118                     UnregisterAudioFrameEncodedCallback();
 119                 }
 120             }
 121         }
 122
 123         private event EventHandler<WebRTCFrameEncodedEventArgs> _videoFrameEncoded;
 124
 125         /// <summary>
 126         /// Occurs when each video frame is ready to render.
 127         /// </summary>
 128         /// <since_tizen> 9 </since_tizen>
 129         public event EventHandler<WebRTCFrameEncodedEventArgs> VideoFrameEncoded
 130         {
 131             add
 132             {
 133                 if (_videoFrameEncoded == null)
 134                 {
 135                     RegisterVideoFrameEncodedCallback();
 136                 }
 137
 138                 _videoFrameEncoded += value;
 139             }
 140             remove
 141             {
 142                 _videoFrameEncoded -= value;
 143
 144                 if (_videoFrameEncoded == null)
 145                 {
 146                     UnregisterVideoFrameEncodedCallback();
 147                 }
 148             }
 149         }
 150
 151         /// <summary>
 152         /// Occurs when the data channel is created to the connection by the remote peer.
 153         /// </summary>
 154         /// <since_tizen> 9 </since_tizen>
 155         public event EventHandler<WebRTCDataChannelEventArgs> DataChannel;
 156
 157         private void RegisterEvents()
 158         {
 159             RegisterErrorOccurredCallback();
 160             RegisterStateChangedCallback();
 161             RegisterIceGatheringStateChangedCallback();
 162             RegisterSignalingStateChangedCallback();
 163             RegisterPeerConnectionStateChangedCallback();
 164             RegisterIceConnectionStateChangedCallback();
 165             RegisterNegotiationNeededCallback();
 166             RegisterIceCandidateCallback();
 167             RegisterTrackAddedCallback();
 168             RegisterDataChannelCreatedCallback();
 169         }
 170
 171         private void UnregisterEvents()
 172         {
 173             UnregisterErrorOccurredCallback();
 174             UnregisterStateChangedCallback();
 175             UnregisterIceGatheringStateChangedCallback();
 176             UnregisterSignalingStateChangedCallback();
 177             UnregisterPeerConnectionStateChangedCallback();
 178             UnregisterIceConnectionStateChangedCallback();
 179             UnregisterNegotiationNeededCallback();
 180             UnregisterIceCandidateCallback();
 181             UnregisterTrackAddedCallback();
 182             UnregisterDataChannelCreatedCallback();
 183         }
 184
 185         private void RegisterErrorOccurredCallback()
 186         {
 187             _webRtcErrorOccurredCallback = (handle, error, state, _) =>
 188             {
 189                 // Log.Info(WebRTCLog.Tag, $"{error}, {state}");
 190
 191                 ErrorOccurred?.Invoke(this, new WebRTCErrorOccurredEventArgs((WebRTCError)error, state));
 192             };
 193
 194             NativeWebRTC.SetErrorOccurredCb(Handle, _webRtcErrorOccurredCallback).
 195                 ThrowIfFailed("Failed to set error occurred callback.");
 196         }
 197
 198         private void UnregisterErrorOccurredCallback()
 199         {
 200             NativeWebRTC.UnsetErrorOccurredCb(Handle).
 201                 ThrowIfFailed("Failed to unset error occurred callback.");
 202         }
 203
 204         private void RegisterStateChangedCallback()
 205         {
 206             _webRtcStateChangedCallback = (handle, previous, current, _) =>
 207             {
 208                 // Log.Info(WebRTCLog.Tag, $"{previous}, {current}");
 209
 210                 StateChanged?.Invoke(this, new WebRTCStateChangedEventArgs(previous, current));
 211             };
 212
 213             NativeWebRTC.SetStateChangedCb(Handle, _webRtcStateChangedCallback).
 214                 ThrowIfFailed("Failed to set state changed callback.");
 215         }
 216
 217         private void UnregisterStateChangedCallback()
 218         {
 219             NativeWebRTC.UnsetStateChangedCb(Handle).
 220                 ThrowIfFailed("Failed to unset state changed callback.");
 221         }
 222
 223         private void RegisterIceGatheringStateChangedCallback()
 224         {
 225             _webRtcIceGatheringStateChangedCallback = (handle, state, _) =>
 226             {
 227                 // Log.Info(WebRTCLog.Tag, $"Ice gathering state : {state}");
 228
 229                 IceGatheringStateChanged?.Invoke(this, new WebRTCIceGatheringStateChangedEventArgs(state));
 230             };
 231
 232             NativeWebRTC.SetIceGatheringStateChangedCb(Handle, _webRtcIceGatheringStateChangedCallback).
 233                 ThrowIfFailed("Failed to set Ice gathering state changed callback.");
 234         }
 235
 236         private void UnregisterIceGatheringStateChangedCallback()
 237         {
 238             NativeWebRTC.UnsetIceGatheringStateChangedCb(Handle).
 239                 ThrowIfFailed("Failed to unset Ice gathering state changed callback.");
 240         }
 241
 242         private void RegisterSignalingStateChangedCallback()
 243         {
 244             _webRtcSignalingStateChangedCallback = (handle, state, _) =>
 245             {
 246                 // Log.Info(WebRTCLog.Tag, $"Signaling state : {state}");
 247
 248                 SignalingStateChanged?.Invoke(this, new WebRTCSignalingStateChangedEventArgs(state));
 249             };
 250
 251             NativeWebRTC.SetSignalingStateChangedCb(Handle, _webRtcSignalingStateChangedCallback).
 252                 ThrowIfFailed("Failed to set signaling state changed callback.");
 253         }
 254
 255         private void UnregisterSignalingStateChangedCallback()
 256         {
 257             NativeWebRTC.UnsetSignalingStateChangedCb(Handle).
 258                 ThrowIfFailed("Failed to unset signaling state changed callback.");
 259         }
 260
 261         private void RegisterPeerConnectionStateChangedCallback()
 262         {
 263             _webRtcPeerConnectionStateChangedCallback = (handle, state, _) =>
 264             {
 265                 Log.Info(WebRTCLog.Tag, $"Peer connection state : {state}");
 266
 267                 PeerConnectionStateChanged?.Invoke(this, new WebRTCPeerConnectionStateChangedEventArgs(state));
 268             };
 269
 270             NativeWebRTC.SetPeerConnectionStateChangedCb(Handle, _webRtcPeerConnectionStateChangedCallback).
 271                 ThrowIfFailed("Failed to set peer connection state changed callback.");
 272         }
 273
 274         private void UnregisterPeerConnectionStateChangedCallback()
 275         {
 276             NativeWebRTC.UnsetPeerConnectionStateChangedCb(Handle).
 277                 ThrowIfFailed("Failed to unset peer connection state changed callback.");
 278         }
 279
 280         private void RegisterIceConnectionStateChangedCallback()
 281         {
 282             _webRtcIceConnectionStateChangedCallback = (handle, state, _) =>
 283             {
 284                 // Log.Info(WebRTCLog.Tag, $"Ice connection state : {state}");
 285
 286                 IceConnectionStateChanged?.Invoke(this, new WebRTCIceConnectionStateChangedEventArgs(state));
 287             };
 288
 289             NativeWebRTC.SetIceConnectionStateChangedCb(Handle, _webRtcIceConnectionStateChangedCallback).
 290                 ThrowIfFailed("Failed to set ICE connection state changed callback.");
 291         }
 292
 293         private void UnregisterIceConnectionStateChangedCallback()
 294         {
 295             NativeWebRTC.UnsetIceConnectionStateChangedCb(Handle).
 296                 ThrowIfFailed("Failed to unset ICE connection state changed callback.");
 297         }
 298
 299         private void RegisterNegotiationNeededCallback()
 300         {
 301             _webRtcNegotiationNeededCallback = (handle, _) =>
 302             {
 303                 NegotiationNeeded?.Invoke(this, new EventArgs());
 304             };
 305
 306             NativeWebRTC.SetNegotiationNeededCb(Handle, _webRtcNegotiationNeededCallback).
 307                 ThrowIfFailed("Failed to set negotiation needed callback.");
 308         }
 309
 310         private void UnregisterNegotiationNeededCallback()
 311         {
 312             NativeWebRTC.UnsetNegotiationNeededCb(Handle).
 313                 ThrowIfFailed("Failed to unset negotiation needed callback.");
 314         }
 315
 316         private void RegisterIceCandidateCallback()
 317         {
 318             _webRtcIceCandidateCallback = (handle, candidate, _) =>
 319             {
 320                 IceCandidate?.Invoke(this, new WebRTCIceCandidateEventArgs(candidate));
 321             };
 322
 323             NativeWebRTC.SetIceCandidateCb(Handle, _webRtcIceCandidateCallback).
 324                 ThrowIfFailed("Failed to set ice candidate callback.");
 325         }
 326
 327         private void UnregisterIceCandidateCallback()
 328         {
 329             NativeWebRTC.UnsetIceCandidateCb(Handle).
 330                 ThrowIfFailed("Failed to unset ice candidate callback.");
 331         }
 332
 333         private void RegisterTrackAddedCallback()
 334         {
 335             _webRtcTrackAddedCallback = (handle, type, id, _) =>
 336             {
 337                 // Log.Info(WebRTCLog.Tag, $"Track type[{type}], id[{id}]");
 338
 339                 TrackAdded?.Invoke(this, new WebRTCTrackAddedEventArgs(new MediaStreamTrack(this, type, id)));
 340             };
 341
 342             NativeWebRTC.SetTrackAddedCb(Handle, _webRtcTrackAddedCallback).
 343                 ThrowIfFailed("Failed to set track added callback.");
 344         }
 345
 346         private void UnregisterTrackAddedCallback()
 347         {
 348             NativeWebRTC.UnsetTrackAddedCb(Handle).
 349                 ThrowIfFailed("Failed to unset track added callback.");
 350         }
 351
 352         private void RegisterAudioFrameEncodedCallback()
 353         {
 354             _webRtcAudioFrameEncodedCallback = (handle, type, id, packet, _) =>
 355             {
 356                 // Log.Info(WebRTCLog.Tag, $"Track type[{type}], id[{id}]");
 357
 358                 _audioFrameEncoded?.Invoke(this,
 359                     new WebRTCFrameEncodedEventArgs(new MediaStreamTrack(this, type, id), MediaPacket.From(packet)));
 360             };
 361
 362             NativeWebRTC.SetAudioFrameEncodedCb(Handle, _webRtcAudioFrameEncodedCallback).
 363                 ThrowIfFailed("Failed to set audio frame encoded callback.");
 364         }
 365
 366         private void UnregisterAudioFrameEncodedCallback()
 367         {
 368             NativeWebRTC.UnsetAudioFrameEncodedCb(Handle).
 369                 ThrowIfFailed("Failed to unset audio frame encoded callback.");
 370         }
 371
 372         private void RegisterVideoFrameEncodedCallback()
 373         {
 374             _webRtcVideoFrameEncodedCallback = (handle, type, id, packet, _) =>
 375             {
 376                 // Log.Info(WebRTCLog.Tag, $"Track type[{type}], id[{id}]");
 377
 378                 _videoFrameEncoded?.Invoke(this,
 379                     new WebRTCFrameEncodedEventArgs(new MediaStreamTrack(this, type, id), MediaPacket.From(packet)));
 380             };
 381
 382             NativeWebRTC.SetVideoFrameEncodedCb(Handle, _webRtcVideoFrameEncodedCallback).
 383                 ThrowIfFailed("Failed to set video frame encoded callback.");
 384         }
 385
 386         private void UnregisterVideoFrameEncodedCallback()
 387         {
 388             NativeWebRTC.UnsetVideoFrameEncodedCb(Handle).
 389                 ThrowIfFailed("Failed to unset video frame encoded callback.");
 390         }
 391
 392         private void RegisterDataChannelCreatedCallback()
 393         {
 394             _webRtcDataChannelCreatedCallback = (handle, dataChannelHandle, _) =>
 395             {
 396                 // Log.Debug(WebRTCLog.Tag, "Invoked");
 397
 398                 DataChannel?.Invoke(this, new WebRTCDataChannelEventArgs(dataChannelHandle));
 399             };
 400
 401             NativeDataChannel.SetCreatedByPeerCb(Handle, _webRtcDataChannelCreatedCallback).
 402                 ThrowIfFailed("Failed to set data channel created callback.");
 403         }
 404
 405         private void UnregisterDataChannelCreatedCallback()
 406         {
 407             NativeDataChannel.UnsetCreatedByPeerCb(Handle).
 408                 ThrowIfFailed("Failed to unset data channel created callback.");
 409         }
 410     }
 411 }