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

   1 using System.ComponentModel;
   2 /*
   3  * Copyright (c) 2021 Samsung Electronics Co., Ltd All Rights Reserved
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the License);
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  * http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an AS IS BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 using System;
  19 using static Interop;
  20
  21 namespace Tizen.Multimedia.Remoting
  22 {
  23     /// <summary>
  24     /// Provides the ability to control WebRTC data channel.
  25     /// </summary>
  26     /// <since_tizen> 9 </since_tizen>
  27     public partial class WebRTCDataChannel
  28     {
  29         private NativeDataChannel.OpenedCallback _webRtcDataChannelOpenedCallback;
  30         private NativeDataChannel.ClosedCallback _webRtcDataChannelClosedCallback;
  31         private NativeDataChannel.MessageReceivedCallback _webRtcDataChannelMsgRecvCallback;
  32         private NativeDataChannel.ErrorOccurredCallback _webRtcDataChannelErrorOccurredCallback;
  33         private NativeDataChannel.BufferedAmountLowThresholdCallback _webRtcDataChannelBufferedAmountLowThresholdCallback;
  34
  35         private event EventHandler<EventArgs> _opened;
  36         private event EventHandler<EventArgs> _closed;
  37         private event EventHandler<WebRTCDataChannelMessageReceivedEventArgs> _messageReceived;
  38         private event EventHandler<WebRTCDataChannelErrorOccurredEventArgs> _errorOccurred;
  39         private event EventHandler<EventArgs> _bufferedAmountLowThresholdOccurred;
  40
  41         /// <summary>
  42         /// Occurs when the data channel's underlying data transport is established.
  43         /// </summary>
  44         /// <since_tizen> 9 </since_tizen>
  45         public event EventHandler<EventArgs> Opened
  46         {
  47             add
  48             {
  49                 if (_opened == null)
  50                 {
  51                     RegisterDataChannelOpenedCallback();
  52                 }
  53                 _opened += value;
  54             }
  55             remove
  56             {
  57                 _opened -= value;
  58                 if (_opened == null)
  59                 {
  60                     UnregisterDataChannelOpenedCallback();
  61                 }
  62             }
  63         }
  64
  65         /// <summary>
  66         /// Occurs when the data channel has closed down.
  67         /// </summary>
  68         /// <since_tizen> 9 </since_tizen>
  69         public event EventHandler<EventArgs> Closed
  70         {
  71             add
  72             {
  73                 if (_closed == null)
  74                 {
  75                     RegisterDataChannelClosedCallback();
  76                 }
  77                 _closed += value;
  78             }
  79             remove
  80             {
  81                 _closed -= value;
  82                 if (_closed == null)
  83                 {
  84                     UnregisterDataChannelClosedCallback();
  85                 }
  86             }
  87         }
  88
  89         /// <summary>
  90         /// Occurs when a message is received from the remote peer.
  91         /// </summary>
  92         /// <since_tizen> 9 </since_tizen>
  93         public event EventHandler<WebRTCDataChannelMessageReceivedEventArgs> MessageReceived
  94         {
  95             add
  96             {
  97                 if (_messageReceived == null)
  98                 {
  99                     RegisterDataChannelMessageReceivedCallback();
 100                 }
 101                 _messageReceived += value;
 102             }
 103             remove
 104             {
 105                 _messageReceived -= value;
 106                 if (_messageReceived == null)
 107                 {
 108                     UnregisterDataChannelMessageReceivedCallback();
 109                 }
 110             }
 111         }
 112
 113         /// <summary>
 114         /// Occurs when an error occurs on the data channel.
 115         /// </summary>
 116         /// <since_tizen> 9 </since_tizen>
 117         public event EventHandler<WebRTCDataChannelErrorOccurredEventArgs> ErrorOccurred
 118         {
 119             add
 120             {
 121                 if (_errorOccurred == null)
 122                 {
 123                     RegisterDataChannelErrorOccurredCallback();
 124                 }
 125                 _errorOccurred += value;
 126             }
 127             remove
 128             {
 129                 _errorOccurred -= value;
 130                 if (_errorOccurred == null)
 131                 {
 132                     UnregisterDataChannelErrorOccurredCallback();
 133                 }
 134             }
 135         }
 136
 137         /// <summary>
 138         /// Occurs when the buffered data amount is lower than <see cref="BufferedAmountLowThreshold"/>.<br/>
 139         /// If <see cref="BufferedAmountLowThreshold"/> is not set, this event will not be raised.
 140         /// </summary>
 141         /// <since_tizen> 10 </since_tizen>
 142         public event EventHandler<EventArgs> BufferedAmountLow
 143         {
 144             add
 145             {
 146                 if (_bufferedAmountLowThresholdOccurred == null)
 147                 {
 148                     RegisterDataChannelBufferedAmountLowThresholdCallback();
 149                 }
 150                 _bufferedAmountLowThresholdOccurred += value;
 151             }
 152             remove
 153             {
 154                 _bufferedAmountLowThresholdOccurred -= value;
 155                 if (_bufferedAmountLowThresholdOccurred == null)
 156                 {
 157                     UnregisterDataChannelBufferedAmountLowThresholdCallback();
 158                 }
 159             }
 160         }
 161
 162         private void RegisterDataChannelOpenedCallback()
 163         {
 164             _webRtcDataChannelOpenedCallback = (dataChannelHandle, _) =>
 165             {
 166                 _opened?.Invoke(this, new EventArgs());
 167             };
 168
 169             NativeDataChannel.SetOpenedCb(_handle, _webRtcDataChannelOpenedCallback).
 170                 ThrowIfFailed("Failed to set data channel opened callback.");
 171         }
 172
 173         private void UnregisterDataChannelOpenedCallback()
 174         {
 175             NativeDataChannel.UnsetOpenedCb(_handle).
 176                 ThrowIfFailed("Failed to unset data channel opened callback.");
 177         }
 178
 179         private void RegisterDataChannelClosedCallback()
 180         {
 181             _webRtcDataChannelClosedCallback = (dataChannelHandle, _) =>
 182             {
 183                 _closed?.Invoke(this, new EventArgs());
 184             };
 185
 186             NativeDataChannel.SetClosedCb(_handle, _webRtcDataChannelClosedCallback).
 187                 ThrowIfFailed("Failed to set data channel closed callback.");
 188         }
 189
 190         private void UnregisterDataChannelClosedCallback()
 191         {
 192             NativeDataChannel.UnsetClosedCb(_handle).
 193                 ThrowIfFailed("Failed to unset data channel closed callback.");
 194         }
 195
 196         private void RegisterDataChannelMessageReceivedCallback()
 197         {
 198             _webRtcDataChannelMsgRecvCallback = (dataChannelHandle, type, message, _) =>
 199             {
 200                 _messageReceived?.Invoke(this, new WebRTCDataChannelMessageReceivedEventArgs(type, message));
 201             };
 202
 203             NativeDataChannel.SetMessageReceivedCb(_handle, _webRtcDataChannelMsgRecvCallback).
 204                 ThrowIfFailed("Failed to set data channel message received callback.");
 205         }
 206
 207         private void UnregisterDataChannelMessageReceivedCallback()
 208         {
 209             NativeDataChannel.UnsetMessageReceivedCb(_handle).
 210                 ThrowIfFailed("Failed to unset data channel message received callback.");
 211         }
 212
 213         private void RegisterDataChannelErrorOccurredCallback()
 214         {
 215             _webRtcDataChannelErrorOccurredCallback = (dataChannelHandle, error, _) =>
 216             {
 217                 _errorOccurred?.Invoke(this, new WebRTCDataChannelErrorOccurredEventArgs((WebRTCError)error));
 218             };
 219
 220             NativeDataChannel.SetErrorOccurredCb(_handle, _webRtcDataChannelErrorOccurredCallback).
 221                 ThrowIfFailed("Failed to set data channel error callback.");
 222         }
 223
 224         private void UnregisterDataChannelErrorOccurredCallback()
 225         {
 226             NativeDataChannel.UnsetErrorOccurredCb(_handle).
 227                 ThrowIfFailed("Failed to unset data channel error callback.");
 228         }
 229
 230         private void RegisterDataChannelBufferedAmountLowThresholdCallback()
 231         {
 232             if (_webRtcDataChannelBufferedAmountLowThresholdCallback == null)
 233             {
 234                 _webRtcDataChannelBufferedAmountLowThresholdCallback = (dataChannelHanel, _) =>
 235                 {
 236                     _bufferedAmountLowThresholdOccurred?.Invoke(this, new EventArgs());
 237                 };
 238             }
 239
 240             NativeDataChannel.SetBufferedAmountLowThresholdCb(_handle, _bufferThreshold.Value,
 241                 _webRtcDataChannelBufferedAmountLowThresholdCallback).
 242                 ThrowIfFailed("Failed to set buffered amount low threshold callback.");
 243         }
 244
 245         private void UnregisterDataChannelBufferedAmountLowThresholdCallback()
 246         {
 247             NativeDataChannel.UnsetBufferedAmountLowThresholdCb(_handle).
 248                 ThrowIfFailed("Failed to unset buffered amount low threshold callback.");
 249         }
 250     }
 251 }