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