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