src/Tizen.Network.WiFi/Tizen.Network.WiFi/WiFiNetworkChange.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.Threading.Tasks;
  19 using System.Threading;
  20 using Tizen.Applications;
  21
  22 namespace Tizen.Network.WiFi
  23 {
  24     internal static class EventHandlerExtension
  25     {
  26         internal static void SafeInvoke(this EventHandler evt, object sender, EventArgs e)
  27         {
  28             var handler = evt;
  29             if (handler != null)
  30             {
  31                 handler(sender, e);
  32             }
  33         }
  34
  35         internal static void SafeInvoke<T>(this EventHandler<T> evt, object sender, T e) where T : EventArgs
  36         {
  37             var handler = evt;
  38             if (handler != null)
  39             {
  40                 handler(sender, e);
  41             }
  42         }
  43     }
  44
  45     internal partial class WiFiManagerImpl
  46     {
  47         private event EventHandler<DeviceStateChangedEventArgs> _deviceStateChanged;
  48         private event EventHandler<ConnectionStateChangedEventArgs> _connectionStateChanged;
  49         private event EventHandler<RssiLevelChangedEventArgs> _rssiLevelChanged;
  50         private event EventHandler _backgroundScanFinished;
  51
  52         private Interop.WiFi.DeviceStateChangedCallback _deviceChangedCallback;
  53         private Interop.WiFi.ConnectionStateChangedCallback _connectionChangedCallback;
  54         private Interop.WiFi.RssiLevelChangedCallback _rssiChangedCallback;
  55         private Interop.WiFi.VoidCallback _backgroundScanFinishedCallback;
  56
  57         private TizenSynchronizationContext context = new TizenSynchronizationContext();
  58         internal event EventHandler<DeviceStateChangedEventArgs> DeviceStateChanged
  59         {
  60             add
  61             {
  62                 context.Post((x) =>
  63                         {
  64                             if (_deviceStateChanged == null)
  65                             {
  66                                 RegisterDeviceStateChangedEvent();
  67                             }
  68                             _deviceStateChanged += value;
  69                         }, null);
  70             }
  71             remove
  72             {
  73                 context.Post((x) =>
  74                         {
  75                             _deviceStateChanged -= value;
  76                             if (_deviceStateChanged == null)
  77                             {
  78                                 UnregisterDeviceStateChangedEvent();
  79                             }
  80                         }, null);
  81             }
  82         }
  83
  84         internal event EventHandler<ConnectionStateChangedEventArgs> ConnectionStateChanged
  85         {
  86             add
  87             {
  88                 context.Post((x) =>
  89                         {
  90                             if (_connectionStateChanged == null)
  91                             {
  92                                 RegisterConnectionStateChangedEvent();
  93                             }
  94                             _connectionStateChanged += value;
  95                         }, null);
  96             }
  97             remove
  98             {
  99                 context.Post((x) =>
 100                         {
 101                             _connectionStateChanged -= value;
 102                             if (_connectionStateChanged == null)
 103                             {
 104                                 UnregisterConnectionStateChangedEvent();
 105                             }
 106                         }, null);
 107             }
 108         }
 109
 110         internal event EventHandler<RssiLevelChangedEventArgs> RssiLevelChanged
 111         {
 112             add
 113             {
 114                 context.Post((x) =>
 115                         {
 116                             if (_rssiLevelChanged == null)
 117                             {
 118                                 RegisterRssiLevelChangedEvent();
 119                             }
 120                             _rssiLevelChanged += value;
 121                         }, null);
 122             }
 123             remove
 124             {
 125                 context.Post((x) =>
 126                         {
 127                             _rssiLevelChanged -= value;
 128                             if (_rssiLevelChanged == null)
 129                             {
 130                                 UnregisterRssiLevelChangedEvent();
 131                             }
 132                         }, null);
 133             }
 134         }
 135
 136         internal event EventHandler BackgroundScanFinished
 137         {
 138             add
 139             {
 140                 context.Post((x) =>
 141                         {
 142                             if (_backgroundScanFinished == null)
 143                             {
 144                                 RegisterBackgroundScanFinishedEvent();
 145                             }
 146                             _backgroundScanFinished += value;
 147                         }, null);
 148             }
 149             remove
 150             {
 151                 context.Post((x) =>
 152                         {
 153                             _backgroundScanFinished -= value;
 154                             if (_backgroundScanFinished == null)
 155                             {
 156                                 UnregisterBackgroundScanFinishedEvent();
 157                             }
 158                         }, null);
 159             }
 160         }
 161
 162         private void RegisterDeviceStateChangedEvent()
 163         {
 164             Log.Info(Globals.LogTag, "RegisterDeviceStateChangedEvent in Thread " + Thread.CurrentThread.ManagedThreadId);
 165             _deviceChangedCallback = (int deviceState, IntPtr userDate) =>
 166             {
 167                 WiFiDeviceState state = (WiFiDeviceState)deviceState;
 168                 DeviceStateChangedEventArgs e = new DeviceStateChangedEventArgs(state);
 169                 _deviceStateChanged.SafeInvoke(null, e);
 170             };
 171             int ret = Interop.WiFi.SetDeviceStateChangedCallback(GetSafeHandle(), _deviceChangedCallback, IntPtr.Zero);
 172             if (ret != (int)WiFiError.None)
 173             {
 174                 Log.Error(Globals.LogTag, "Failed to set device state changed callback, Error - " + (WiFiError)ret);
 175             }
 176         }
 177
 178         private void UnregisterDeviceStateChangedEvent()
 179         {
 180             Log.Info(Globals.LogTag, "UnregisterDeviceStateChangedEvent in Thread " + Thread.CurrentThread.ManagedThreadId);
 181             int ret = Interop.WiFi.UnsetDeviceStateChangedCallback(GetSafeHandle());
 182             if (ret != (int)WiFiError.None)
 183             {
 184                 Log.Error(Globals.LogTag, "Failed to unset device state changed callback, Error - " + (WiFiError)ret);
 185             }
 186         }
 187
 188         private void RegisterConnectionStateChangedEvent()
 189         {
 190             _connectionChangedCallback = (int connectionState, IntPtr ap, IntPtr userData) =>
 191             {
 192                 if (ap != IntPtr.Zero)
 193                 {
 194                     WiFiConnectionState state = (WiFiConnectionState)connectionState;
 195                     ConnectionStateChangedEventArgs e = new ConnectionStateChangedEventArgs(state, ap);
 196                     _connectionStateChanged.SafeInvoke(null, e);
 197                 }
 198             };
 199             int ret = Interop.WiFi.SetConnectionStateChangedCallback(GetSafeHandle(), _connectionChangedCallback, IntPtr.Zero);
 200             if (ret != (int)WiFiError.None)
 201             {
 202                 Log.Error(Globals.LogTag, "Failed to set copnnection state changed callback, Error - " + (WiFiError)ret);
 203             }
 204         }
 205
 206         private void UnregisterConnectionStateChangedEvent()
 207         {
 208             int ret = Interop.WiFi.UnsetConnectionStateChangedCallback(GetSafeHandle());
 209             if (ret != (int)WiFiError.None)
 210             {
 211                 Log.Error(Globals.LogTag, "Failed to unset device state changed callback, Error - " + (WiFiError)ret);
 212             }
 213         }
 214
 215         private void RegisterRssiLevelChangedEvent()
 216         {
 217
 218             _rssiChangedCallback = (int rssiLevel, IntPtr userDate) =>
 219             {
 220                 WiFiRssiLevel level = (WiFiRssiLevel)rssiLevel;
 221                 RssiLevelChangedEventArgs e = new RssiLevelChangedEventArgs(level);
 222                 _rssiLevelChanged.SafeInvoke(null, e);
 223             };
 224             int ret = Interop.WiFi.SetRssiLevelchangedCallback(GetSafeHandle(), _rssiChangedCallback, IntPtr.Zero);
 225             if (ret != (int)WiFiError.None)
 226             {
 227                 Log.Error(Globals.LogTag, "Failed to set rssi level changed callback, Error - " + (WiFiError)ret);
 228             }
 229         }
 230
 231         private void UnregisterRssiLevelChangedEvent()
 232         {
 233             int ret = Interop.WiFi.UnsetRssiLevelchangedCallback(GetSafeHandle());
 234             if (ret != (int)WiFiError.None)
 235             {
 236                 Log.Error(Globals.LogTag, "Failed to unset rssi level changed callback, Error - " + (WiFiError)ret);
 237             }
 238         }
 239
 240         private void RegisterBackgroundScanFinishedEvent()
 241         {
 242             _backgroundScanFinishedCallback = (int result, IntPtr userDate) =>
 243             {
 244                 EventArgs e = new EventArgs();
 245                 _backgroundScanFinished.SafeInvoke(null, e);
 246             };
 247             int ret = Interop.WiFi.SetBackgroundScanCallback(GetSafeHandle(), _backgroundScanFinishedCallback, IntPtr.Zero);
 248             if (ret != (int)WiFiError.None)
 249             {
 250                 Log.Error(Globals.LogTag, "Failed to set background scan callback, Error - " + (WiFiError)ret);
 251             }
 252         }
 253
 254         private void UnregisterBackgroundScanFinishedEvent()
 255         {
 256             int ret = Interop.WiFi.UnsetBackgroundScanCallback(GetSafeHandle());
 257             if (ret != (int)WiFiError.None)
 258             {
 259                 Log.Error(Globals.LogTag, "Failed to unset background scan callback, Error - " + (WiFiError)ret);
 260             }
 261         }
 262     }
 263 }