src/Tizen.Network.WiFi/Tizen.Network.WiFi/WiFiManagerImpl.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.Collections.Generic;
  19 using System.Threading.Tasks;
  20
  21 namespace Tizen.Network.WiFi
  22 {
  23     static internal class Globals
  24     {
  25         internal const string LogTag = "Tizen.Network.WiFi";
  26     }
  27
  28     internal partial class WiFiManagerImpl : IDisposable
  29     {
  30         private static readonly WiFiManagerImpl _instance = new WiFiManagerImpl();
  31         private Dictionary<IntPtr, Interop.WiFi.VoidCallback> _callback_map = new Dictionary<IntPtr, Interop.WiFi.VoidCallback>();
  32         private int _requestId = 0;
  33         private string _macAddress;
  34         private bool disposed = false;
  35
  36         internal string MacAddress
  37         {
  38             get
  39             {
  40                 if (String.IsNullOrEmpty(_macAddress))
  41                 {
  42                     string address;
  43                     int ret = Interop.WiFi.GetMacAddress(out address);
  44                     if (ret != (int)WiFiError.None)
  45                     {
  46                         Log.Error(Globals.LogTag, "Failed to get mac address, Error - " + (WiFiError)ret);
  47                         _macAddress = "";
  48                     }
  49                     else
  50                     {
  51                         _macAddress = address;
  52                     }
  53                 }
  54                 return _macAddress;
  55             }
  56         }
  57         internal string InterfaceName
  58         {
  59             get
  60             {
  61                 string name;
  62                 int ret = Interop.WiFi.GetNetworkInterfaceName(out name);
  63                 if (ret != (int)WiFiError.None)
  64                 {
  65                     Log.Error(Globals.LogTag, "Failed to get interface name, Error - " + (WiFiError)ret);
  66                     return "";
  67                 }
  68                 return name;
  69             }
  70         }
  71         internal WiFiConnectionState ConnectionState
  72         {
  73             get
  74             {
  75                 int state;
  76                 int ret = Interop.WiFi.GetConnectionState(out state);
  77                 if (ret != (int)WiFiError.None)
  78                 {
  79                     Log.Error(Globals.LogTag, "Failed to get connection state, Error - " + (WiFiError)ret);
  80                     return WiFiConnectionState.Failure;
  81                 }
  82                 return (WiFiConnectionState)state;
  83             }
  84         }
  85         internal bool IsActivated
  86         {
  87             get
  88             {
  89                 bool active;
  90                 int ret = Interop.WiFi.IsActivated(out active);
  91                 if (ret != (int)WiFiError.None)
  92                 {
  93                     Log.Error(Globals.LogTag, "Failed to get isActive, Error - " + (WiFiError)ret);
  94                 }
  95                 return active;
  96             }
  97         }
  98
  99         internal static WiFiManagerImpl Instance
 100         {
 101             get
 102             {
 103                 return _instance;
 104             }
 105         }
 106
 107         private WiFiManagerImpl()
 108         {
 109             initialize();
 110         }
 111
 112         ~WiFiManagerImpl()
 113         {
 114             Dispose(false);
 115         }
 116
 117         public void Dispose()
 118         {
 119             Dispose(true);
 120             GC.SuppressFinalize(this);
 121         }
 122
 123         private void Dispose(bool disposing)
 124         {
 125             if (disposed)
 126                 return;
 127
 128             if (disposing)
 129             {
 130                 // Free managed objects.
 131             }
 132             //Free unmanaged objects
 133             deinitialize();
 134             RemoveAllRegisteredEvent();
 135             disposed = true;
 136         }
 137
 138         private void initialize()
 139         {
 140             int ret = Interop.WiFi.Initialize();
 141             if (ret != (int)WiFiError.None)
 142             {
 143                 Log.Error(Globals.LogTag, "Failed to initialize wifi, Error - " + (WiFiError)ret);
 144                 WiFiErrorFactory.ThrowWiFiException(ret);
 145             }
 146             string address;
 147             ret = Interop.WiFi.GetMacAddress(out address);
 148             if (ret != (int)WiFiError.None)
 149             {
 150                 Log.Error(Globals.LogTag, "Failed to get mac address, Error - " + (WiFiError)ret);
 151                 _macAddress = "";
 152             }
 153             _macAddress = address;
 154         }
 155
 156         private void deinitialize()
 157         {
 158             int ret = Interop.WiFi.Deinitialize();
 159             if (ret != (int)WiFiError.None)
 160             {
 161                 Log.Error(Globals.LogTag, "Failed to deinitialize wifi, Error - " + (WiFiError)ret);
 162                 WiFiErrorFactory.ThrowWiFiException(ret);
 163             }
 164         }
 165
 166         internal IEnumerable<WiFiAp> GetFoundAps()
 167         {
 168             List<WiFiAp> apList = new List<WiFiAp>();
 169             Interop.WiFi.HandleCallback callback = (IntPtr apHandle, IntPtr userData) =>
 170             {
 171                 if (apHandle != IntPtr.Zero)
 172                 {
 173                     IntPtr clonedHandle;
 174                     Interop.WiFi.Ap.Clone(out clonedHandle, apHandle);
 175                     WiFiAp apItem = new WiFiAp(clonedHandle);
 176                     apList.Add(apItem);
 177                     return true;
 178                 }
 179                 return false;
 180             };
 181
 182             int ret = Interop.WiFi.GetForeachFoundAps(callback, IntPtr.Zero);
 183             if (ret != (int)WiFiError.None)
 184             {
 185                 Log.Error(Globals.LogTag, "Failed to get all APs, Error - " + (WiFiError)ret);
 186                 WiFiErrorFactory.ThrowWiFiException(ret);
 187             }
 188
 189             return apList;
 190         }
 191
 192         internal IEnumerable<WiFiAp> GetFoundSpecificAps()
 193         {
 194             List<WiFiAp> apList = new List<WiFiAp>();
 195             Interop.WiFi.HandleCallback callback = (IntPtr apHandle, IntPtr userData) =>
 196             {
 197                 if (apHandle != IntPtr.Zero)
 198                 {
 199                     IntPtr clonedHandle;
 200                     Interop.WiFi.Ap.Clone(out clonedHandle, apHandle);
 201                     WiFiAp apItem = new WiFiAp(clonedHandle);
 202                     apList.Add(apItem);
 203                     return true;
 204                 }
 205                 return false;
 206
 207             };
 208
 209             int ret = Interop.WiFi.GetForeachFoundSpecificAps(callback, IntPtr.Zero);
 210             if (ret != (int)WiFiError.None)
 211             {
 212                 Log.Error(Globals.LogTag, "Failed to get specific APs, Error - " + (WiFiError)ret);
 213                 WiFiErrorFactory.ThrowWiFiException(ret);
 214             }
 215
 216             return apList;
 217         }
 218
 219         internal IEnumerable<WiFiConfiguration> GetWiFiConfigurations()
 220         {
 221             List<WiFiConfiguration> configList = new List<WiFiConfiguration>();
 222             Interop.WiFi.HandleCallback callback = (IntPtr configHandle, IntPtr userData) =>
 223             {
 224                 if (configHandle != IntPtr.Zero)
 225                 {
 226                     IntPtr clonedConfig;
 227                     Interop.WiFi.Config.Clone(configHandle, out clonedConfig);
 228                     WiFiConfiguration configItem = new WiFiConfiguration(clonedConfig);
 229                     configList.Add(configItem);
 230                     return true;
 231                 }
 232                 return false;
 233             };
 234
 235             int ret = Interop.WiFi.Config.GetForeachConfiguration(callback, IntPtr.Zero);
 236             if (ret != (int)WiFiError.None)
 237             {
 238                 Log.Error(Globals.LogTag, "Failed to get configurations, Error - " + (WiFiError)ret);
 239                 WiFiErrorFactory.ThrowWiFiException(ret);
 240             }
 241
 242             return configList;
 243         }
 244
 245         internal void SaveWiFiNetworkConfiguration(WiFiConfiguration config)
 246         {
 247             IntPtr configHandle = config.GetHandle();
 248             int ret = Interop.WiFi.Config.SaveConfiguration(configHandle);
 249             if (ret != (int)WiFiError.None)
 250             {
 251                 Log.Error(Globals.LogTag, "Failed to save configuration, Error - " + (WiFiError)ret);
 252                 WiFiErrorFactory.ThrowWiFiException(ret);
 253             }
 254         }
 255
 256         internal WiFiAp GetConnectedAp()
 257         {
 258             IntPtr apHandle;
 259
 260             int ret = Interop.WiFi.GetConnectedAp(out apHandle);
 261             if (ret != (int)WiFiError.None)
 262             {
 263                 Log.Error(Globals.LogTag, "Failed to connect with AP, Error - " + (WiFiError)ret);
 264                 WiFiErrorFactory.ThrowWiFiException(ret);
 265             }
 266             WiFiAp ap = new WiFiAp(apHandle);
 267             return ap;
 268         }
 269
 270         internal void RemoveAp(WiFiAp ap)
 271         {
 272             IntPtr apHandle = ap.GetHandle();
 273             int ret = Interop.WiFi.RemoveAp(apHandle);
 274             if (ret != (int)WiFiError.None)
 275             {
 276                 Log.Error(Globals.LogTag, "Failed to remove with AP, Error - " + (WiFiError)ret);
 277                 WiFiErrorFactory.ThrowWiFiException(ret);
 278             }
 279         }
 280
 281         internal Task ActivateAsync()
 282         {
 283             TaskCompletionSource<bool> task = new TaskCompletionSource<bool>();
 284             IntPtr id;
 285             lock (_callback_map)
 286             {
 287                 id = (IntPtr)_requestId++;
 288                 _callback_map[id] = (error, key) =>
 289                 {
 290                     Log.Debug(Globals.LogTag, "wifi activated");
 291                     if (error != (int)WiFiError.None)
 292                     {
 293                         Log.Error(Globals.LogTag, "Error occurs during WiFi activating, " + (WiFiError)error);
 294                         task.SetException(new InvalidOperationException("Error occurs during WiFi activating, " + (WiFiError)error));
 295                     }
 296                     task.SetResult(true);
 297                     lock (_callback_map)
 298                     {
 299                         _callback_map.Remove(key);
 300                     }
 301                 };
 302             }
 303             int ret = Interop.WiFi.Activate(_callback_map[id], id);
 304             if (ret != (int)WiFiError.None)
 305             {
 306                 Log.Error(Globals.LogTag, "Failed to activate wifi, Error - " + (WiFiError)ret);
 307                 WiFiErrorFactory.ThrowWiFiException(ret);
 308             }
 309             return task.Task;
 310         }
 311
 312         internal Task ActivateWithWiFiPickerTestedAsync()
 313         {
 314             TaskCompletionSource<bool> task = new TaskCompletionSource<bool>();
 315             IntPtr id;
 316             lock (_callback_map)
 317             {
 318                 id = (IntPtr)_requestId++;
 319                 _callback_map[id] = (error, key) =>
 320                 {
 321                     Log.Debug(Globals.LogTag, "Activation finished");
 322                     if (error != (int)WiFiError.None)
 323                     {
 324                         Log.Error(Globals.LogTag, "Error occurs during WiFi activating, " + (WiFiError)error);
 325                         task.SetException(new InvalidOperationException("Error occurs during WiFi activating, " + (WiFiError)error));
 326                     }
 327                     task.SetResult(true);
 328                     lock (_callback_map)
 329                     {
 330                         _callback_map.Remove(key);
 331                     }
 332                 };
 333             }
 334             int ret = Interop.WiFi.ActivateWithWiFiPickerTested(_callback_map[id], id);
 335             if (ret != (int)WiFiError.None)
 336             {
 337                 Log.Error(Globals.LogTag, "Failed to activate wifi, Error - " + (WiFiError)ret);
 338                 WiFiErrorFactory.ThrowWiFiException(ret);
 339             }
 340             return task.Task;
 341         }
 342
 343         internal Task DeactivateAsync()
 344         {
 345             TaskCompletionSource<bool> task = new TaskCompletionSource<bool>();
 346             IntPtr id;
 347             lock (_callback_map)
 348             {
 349                 id = (IntPtr)_requestId++;
 350                 _callback_map[id] = (error, key) =>
 351                 {
 352                     Log.Debug(Globals.LogTag, "Deactivation finished");
 353                     if (error != (int)WiFiError.None)
 354                     {
 355                         Log.Error(Globals.LogTag, "Error occurs during WiFi deactivating, " + (WiFiError)error);
 356                         task.SetException(new InvalidOperationException("Error occurs during WiFi deactivating, " + (WiFiError)error));
 357                     }
 358                     task.SetResult(true);
 359                     lock (_callback_map)
 360                     {
 361                         _callback_map.Remove(key);
 362                     }
 363                 };
 364             }
 365             int ret = Interop.WiFi.Deactivate(_callback_map[id], id);
 366             if (ret != (int)WiFiError.None)
 367             {
 368                 Log.Error(Globals.LogTag, "Failed to deactivate wifi, Error - " + (WiFiError)ret);
 369                 WiFiErrorFactory.ThrowWiFiException(ret);
 370             }
 371             return task.Task;
 372         }
 373
 374         internal Task ScanAsync()
 375         {
 376             TaskCompletionSource<bool> task = new TaskCompletionSource<bool>();
 377             IntPtr id;
 378             lock (_callback_map)
 379             {
 380                 id = (IntPtr)_requestId++;
 381                 _callback_map[id] = (error, key) =>
 382                 {
 383                     Log.Debug(Globals.LogTag, "Scanning finished");
 384                     if (error != (int)WiFiError.None)
 385                     {
 386                         Log.Error(Globals.LogTag, "Error occurs during WiFi scanning, " + (WiFiError)error);
 387                         task.SetException(new InvalidOperationException("Error occurs during WiFi scanning, " + (WiFiError)error));
 388                     }
 389                     task.SetResult(true);
 390                     lock (_callback_map)
 391                     {
 392                         _callback_map.Remove(key);
 393                     }
 394                 };
 395             }
 396             int ret = Interop.WiFi.Scan(_callback_map[id], id);
 397             if (ret != (int)WiFiError.None)
 398             {
 399                 Log.Error(Globals.LogTag, "Failed to scan all AP, Error - " + (WiFiError)ret);
 400                 WiFiErrorFactory.ThrowWiFiException(ret);
 401             }
 402             return task.Task;
 403         }
 404
 405         internal Task ScanSpecificApAsync(string essid)
 406         {
 407             TaskCompletionSource<bool> task = new TaskCompletionSource<bool>();
 408             IntPtr id;
 409             lock (_callback_map)
 410             {
 411                 id = (IntPtr)_requestId++;
 412                 _callback_map[id] = (error, key) =>
 413                 {
 414                     Log.Debug(Globals.LogTag, "Scanning with specific AP finished");
 415                     if (error != (int)WiFiError.None)
 416                     {
 417                         Log.Error(Globals.LogTag, "Error occurs during WiFi scanning, " + (WiFiError)error);
 418                         task.SetException(new InvalidOperationException("Error occurs during WiFi scanning, " + (WiFiError)error));
 419                     }
 420                     task.SetResult(true);
 421                     lock (_callback_map)
 422                     {
 423                         _callback_map.Remove(key);
 424                     }
 425                 };
 426             }
 427             int ret = Interop.WiFi.ScanSpecificAp(essid, _callback_map[id], id);
 428             if (ret != (int)WiFiError.None)
 429             {
 430                 Log.Error(Globals.LogTag, "Failed to scan with specific AP, Error - " + (WiFiError)ret);
 431                 WiFiErrorFactory.ThrowWiFiException(ret);
 432             }
 433             return task.Task;
 434         }
 435
 436         internal Task ConnectAsync(WiFiAp ap)
 437         {
 438             TaskCompletionSource<bool> task = new TaskCompletionSource<bool>();
 439             IntPtr id;
 440             lock (_callback_map)
 441             {
 442                 id = (IntPtr)_requestId++;
 443                 _callback_map[id] = (error, key) =>
 444                 {
 445                     Log.Debug(Globals.LogTag, "Connecting finished : " + (WiFiError)error);
 446                     if (error != (int)WiFiError.None)
 447                     {
 448                         Log.Error(Globals.LogTag, "Error occurs during WiFi connecting, " + (WiFiError)error);
 449                         task.SetException(new InvalidOperationException("Error occurs during WiFi connecting, " + (WiFiError)error));
 450                     }
 451                     task.SetResult(true);
 452                     lock (_callback_map)
 453                     {
 454                         _callback_map.Remove(key);
 455                     }
 456                 };
 457             }
 458             IntPtr apHandle = ap.GetHandle();
 459             int ret = Interop.WiFi.Connect(apHandle, _callback_map[id], id);
 460             if (ret != (int)WiFiError.None)
 461             {
 462                 Log.Error(Globals.LogTag, "Failed to connect wifi, Error - " + (WiFiError)ret);
 463                 WiFiErrorFactory.ThrowWiFiException(ret);
 464             }
 465             return task.Task;
 466         }
 467
 468         internal Task DisconnectAsync(WiFiAp ap)
 469         {
 470             TaskCompletionSource<bool> task = new TaskCompletionSource<bool>();
 471             IntPtr id;
 472             lock (_callback_map)
 473             {
 474                 id = (IntPtr)_requestId++;
 475                 _callback_map[id] = (error, key) =>
 476                 {
 477                     Log.Debug(Globals.LogTag, "Disconnecting finished");
 478                     if (error != (int)WiFiError.None)
 479                     {
 480                         Log.Error(Globals.LogTag, "Error occurs during WiFi disconnecting, " + (WiFiError)error);
 481                         task.SetException(new InvalidOperationException("Error occurs during WiFi disconnecting, " + (WiFiError)error));
 482                     }
 483                     task.SetResult(true);
 484                     lock (_callback_map)
 485                     {
 486                         _callback_map.Remove(key);
 487                     }
 488                 };
 489             }
 490             IntPtr apHandle = ap.GetHandle();
 491             int ret = Interop.WiFi.Disconnect(apHandle, _callback_map[id], id);
 492             if (ret != (int)WiFiError.None)
 493             {
 494                 Log.Error(Globals.LogTag, "Failed to disconnect wifi, Error - " + (WiFiError)ret);
 495                 WiFiErrorFactory.ThrowWiFiException(ret);
 496             }
 497             return task.Task;
 498         }
 499
 500         internal Task ConnectByWpsPbcAsync(WiFiAp ap)
 501         {
 502             TaskCompletionSource<bool> task = new TaskCompletionSource<bool>();
 503             IntPtr id;
 504             lock (_callback_map)
 505             {
 506                 id = (IntPtr)_requestId++;
 507                 _callback_map[id] = (error, key) =>
 508                 {
 509                     Log.Debug(Globals.LogTag, "Connecting by WPS PBC finished");
 510                     if (error != (int)WiFiError.None)
 511                     {
 512                         Log.Error(Globals.LogTag, "Error occurs during WiFi connecting, " + (WiFiError)error);
 513                         task.SetException(new InvalidOperationException("Error occurs during WiFi connecting, " + (WiFiError)error));
 514                     }
 515                     task.SetResult(true);
 516                     lock (_callback_map)
 517                     {
 518                         _callback_map.Remove(key);
 519                     }
 520                 };
 521             }
 522             IntPtr apHandle = ap.GetHandle();
 523             int ret = Interop.WiFi.ConnectByWpsPbc(apHandle, _callback_map[id], id);
 524             if (ret != (int)WiFiError.None)
 525             {
 526                 Log.Error(Globals.LogTag, "Failed to connect wifi, Error - " + (WiFiError)ret);
 527                 WiFiErrorFactory.ThrowWiFiException(ret);
 528             }
 529             return task.Task;
 530         }
 531
 532         internal Task ConnectByWpsPinAsync(WiFiAp ap, string pin)
 533         {
 534             TaskCompletionSource<bool> task = new TaskCompletionSource<bool>();
 535             IntPtr id;
 536             lock (_callback_map)
 537             {
 538                 id = (IntPtr)_requestId++;
 539                 _callback_map[id] = (error, key) =>
 540                 {
 541                     Log.Debug(Globals.LogTag, "Connecting by WPS PIN finished");
 542                     if (error != (int)WiFiError.None)
 543                     {
 544                         Log.Error(Globals.LogTag, "Error occurs during WiFi connecting, " + (WiFiError)error);
 545                         task.SetException(new InvalidOperationException("Error occurs during WiFi connecting, " + (WiFiError)error));
 546                     }
 547                     task.SetResult(true);
 548                     lock (_callback_map)
 549                     {
 550                         _callback_map.Remove(key);
 551                     }
 552                 };
 553             }
 554             IntPtr apHandle = ap.GetHandle();
 555             int ret = Interop.WiFi.ConnectByWpsPin(apHandle, pin, _callback_map[id], id);
 556             if (ret != (int)WiFiError.None)
 557             {
 558                 Log.Error(Globals.LogTag, "Failed to connect wifi, Error - " + (WiFiError)ret);
 559                 WiFiErrorFactory.ThrowWiFiException(ret);
 560             }
 561             return task.Task;
 562         }
 563     }
 564 }