<ItemGroup>
<ProjectReference Include="..\Tizen\Tizen.csproj" />
<ProjectReference Include="..\Tizen.Log\Tizen.Log.csproj" />
+ <ProjectReference Include="..\Tizen.Applications.Common\Tizen.Applications.Common.csproj" />
</ItemGroup>
</Project>
using System.Runtime.InteropServices;
using System.Collections;
using System.Threading;
+using Tizen.Applications;
namespace Tizen.Network.Connection
{
class HandleHolder
{
private IntPtr Handle;
- private int tid;
+ private int _tid;
public HandleHolder()
{
- tid = Thread.CurrentThread.ManagedThreadId;
- Log.Info(Globals.LogTag, "PInvoke connection_destroy for Thread " + tid);
- int ret = Interop.Connection.Create(tid, out Handle);
+ _tid = Thread.CurrentThread.ManagedThreadId;
+ Log.Info(Globals.LogTag, "PInvoke connection_create for Thread " + _tid);
+ int ret = Interop.Connection.Create(_tid, out Handle);
Log.Info(Globals.LogTag, "Handle: " + Handle);
if(ret != (int)ConnectionError.None)
{
private void Destroy()
{
- Log.Info(Globals.LogTag, "PInvoke connection_destroy for Thread " + tid);
- Interop.Connection.Destroy(tid, Handle);
+
+ Log.Info(Globals.LogTag, "PInvoke connection_destroy for Thread " + _tid);
+ Interop.Connection.Destroy(_tid, Handle);
if (Handle != IntPtr.Zero)
{
Handle = IntPtr.Zero;
private Interop.Connection.ConnectionAddressChangedCallback _proxyAddressChangedCallback;
private Interop.Connection.EthernetCableStateChangedCallback _ethernetCableStateChangedCallback;
+ private TizenSynchronizationContext context = new TizenSynchronizationContext();
+
internal static ConnectionInternalManager Instance
{
get
~ConnectionInternalManager()
{
+ UnregisterEvents();
}
internal IntPtr GetHandle()
{
add
{
- if (_ConnectionTypeChanged == null)
+ context.Post((x) =>
{
- ConnectionTypeChangedStart();
- }
-
- _ConnectionTypeChanged += value;
+ if (_ConnectionTypeChanged == null)
+ {
+ try
+ {
+ ConnectionTypeChangedStart();
+ }
+ catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on adding ConnectionTypeChanged\n" + e.ToString());
+ return;
+ }
+ }
+ _ConnectionTypeChanged += value;
+ }, null);
}
remove
{
- _ConnectionTypeChanged -= value;
- if (_ConnectionTypeChanged == null)
+ context.Post((x) =>
{
- ConnectionTypeChangedStop();
- }
+ _ConnectionTypeChanged -= value;
+ if (_ConnectionTypeChanged == null)
+ {
+ try
+ {
+ ConnectionTypeChangedStop();
+ }
+ catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on removing ConnectionTypeChanged\n" + e.ToString());
+ }
+ }
+ }, null);
}
}
private void ConnectionTypeChangedStart()
{
+ Log.Info(Globals.LogTag, "Register ConnectionTypeChanged");
_connectionTypeChangedCallback = (ConnectionType type, IntPtr user_data) =>
{
if (_ConnectionTypeChanged != null)
private void ConnectionTypeChangedStop()
{
+ Log.Info(Globals.LogTag, "Unregister ConnectionTypeChanged");
int ret = Interop.Connection.UnsetTypeChangedCallback(GetHandle());
if ((ConnectionError)ret != ConnectionError.None)
{
{
add
{
- if (_EthernetCableStateChanged == null)
+ context.Post((x) =>
{
- EthernetCableStateChangedStart();
- }
- _EthernetCableStateChanged += value;
+ if (_EthernetCableStateChanged == null)
+ {
+ try
+ {
+ EthernetCableStateChangedStart();
+ }
+ catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on adding EthernetCableStateChanged\n" + e.ToString());
+ return;
+ }
+ }
+ _EthernetCableStateChanged += value;
+ }, null);
}
remove
{
- _EthernetCableStateChanged -= value;
- if (_EthernetCableStateChanged == null)
+ context.Post((x) =>
{
- EthernetCableStateChangedStop();
- }
+ _EthernetCableStateChanged -= value;
+ if (_EthernetCableStateChanged == null)
+ {
+ try
+ {
+ EthernetCableStateChangedStop();
+ }
+ catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on removing EthernetCableStateChanged\n" + e.ToString());
+ }
+ }
+ }, null);
}
}
private void EthernetCableStateChangedStart()
{
+ Log.Info(Globals.LogTag, "Register EthernetCableStateChanged");
_ethernetCableStateChangedCallback = (EthernetCableState state, IntPtr user_data) =>
{
if (_EthernetCableStateChanged != null)
private void EthernetCableStateChangedStop()
{
+ Log.Info(Globals.LogTag, "Unregister EthernetCableStateChanged");
int ret = Interop.Connection.UnsetEthernetCableStateChagedCallback(GetHandle());
if ((ConnectionError)ret != ConnectionError.None)
{
{
add
{
- if (_IPAddressChanged == null)
+ context.Post((x) =>
{
- IPAddressChangedStart();
- }
- _IPAddressChanged += value;
+ if (_IPAddressChanged == null)
+ {
+ try
+ {
+ IPAddressChangedStart();
+ }
+ catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on adding IPAddressChanged\n" + e.ToString());
+ return;
+ }
+ }
+ _IPAddressChanged += value;
+ }, null);
}
remove
{
- _IPAddressChanged -= value;
- if (_IPAddressChanged == null)
+ context.Post((x) =>
{
- IPAddressChangedStop();
- }
+ _IPAddressChanged -= value;
+ if (_IPAddressChanged == null)
+ {
+ try
+ {
+ IPAddressChangedStop();
+ }
+ catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on removing IPAddressChanged\n" + e.ToString());
+ }
+ }
+ }, null);
}
}
private void IPAddressChangedStart()
{
+ Log.Info(Globals.LogTag, "Register IPAddressChanged");
_connectionAddressChangedCallback = (IntPtr IPv4, IntPtr IPv6, IntPtr UserData) =>
{
if (_IPAddressChanged != null)
private void IPAddressChangedStop()
{
+ Log.Info(Globals.LogTag, "Unregister IPAddressChanged");
int ret = Interop.Connection.UnsetIPAddressChangedCallback(GetHandle());
if ((ConnectionError)ret != ConnectionError.None)
{
{
add
{
- //Console.WriteLine("ProxyAddressChanged Add **");
- if (_ProxyAddressChanged == null)
+ context.Post((x) =>
{
- ProxyAddressChangedStart();
- }
-
- _ProxyAddressChanged += value;
+ if (_ProxyAddressChanged == null)
+ {
+ try
+ {
+ ProxyAddressChangedStart();
+ }
+ catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on adding ProxyAddressChanged\n" + e.ToString());
+ return;
+ }
+ }
+ _ProxyAddressChanged += value;
+ }, null);
}
remove
{
- //Console.WriteLine("ProxyAddressChanged Remove");
- _ProxyAddressChanged -= value;
- if (_ProxyAddressChanged == null)
+ context.Post((x) =>
{
- ProxyAddressChangedStop();
- }
+ _ProxyAddressChanged -= value;
+ if (_ProxyAddressChanged == null)
+ {
+ try
+ {
+ ProxyAddressChangedStop();
+ }
+ catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on removing ProxyAddressChanged\n" + e.ToString());
+ }
+ }
+ }, null);
}
}
private void ProxyAddressChangedStart()
{
+ Log.Info(Globals.LogTag, "Register ProxyAddressChanged");
_proxyAddressChangedCallback = (IntPtr IPv4, IntPtr IPv6, IntPtr UserData) =>
{
if (_ProxyAddressChanged != null)
private void ProxyAddressChangedStop()
{
+ Log.Info(Globals.LogTag, "Unregister ProxyAddressChanged");
int ret = Interop.Connection.UnsetProxyAddressChangedCallback(GetHandle());
if ((ConnectionError)ret != ConnectionError.None)
{
internal Task SetDefaultCellularProfile(CellularServiceType type, ConnectionProfile profile)
{
- Log.Debug(Globals.LogTag, "SetDefaultCellularProfile");
+ Log.Info(Globals.LogTag, "SetDefaultCellularProfile");
if (profile != null)
{
TaskCompletionSource<bool> task = new TaskCompletionSource<bool>();
Interop.Connection.ConnectionCallback Callback = (ConnectionError Result, IntPtr Data) =>
{
+ Log.Info(Globals.LogTag, "SetDefaultCellularProfile done " + profile.Name);
if (Result != ConnectionError.None)
{
Log.Error(Globals.LogTag, "Error occurs during set default cellular profile, " + Result);
}
};
- int ret = Interop.Connection.SetDefaultCellularServiceProfileAsync(GetHandle(), (int)type, profile.ProfileHandle, Callback, (IntPtr)0);
- if ((ConnectionError)ret != ConnectionError.None)
+ context.Post((x) =>
{
- Log.Error(Globals.LogTag, "It failed to set default cellular profile, " + (ConnectionError)ret);
- ConnectionErrorFactory.CheckFeatureUnsupportedException(ret, "http://tizen.org/feature/network.telephony");
- ConnectionErrorFactory.CheckHandleNullException(ret, (GetHandle() == IntPtr.Zero || profile.ProfileHandle == IntPtr.Zero), "Connection or Profile Handle may have been disposed or released");
- ConnectionErrorFactory.ThrowConnectionException(ret);
- }
+ Log.Info(Globals.LogTag, "Interop.Connection.SetDefaultCellularServiceProfileAsync " + profile.Name);
+ try
+ {
+ int ret = Interop.Connection.SetDefaultCellularServiceProfileAsync(GetHandle(), (int)type, profile.ProfileHandle, Callback, (IntPtr)0);
+
+ if ((ConnectionError)ret != ConnectionError.None)
+ {
+ Log.Error(Globals.LogTag, "It failed to set default cellular profile, " + (ConnectionError)ret);
+ ConnectionErrorFactory.CheckFeatureUnsupportedException(ret, "http://tizen.org/feature/network.telephony");
+ ConnectionErrorFactory.CheckHandleNullException(ret, (GetHandle() == IntPtr.Zero || profile.ProfileHandle == IntPtr.Zero), "Connection or Profile Handle may have been disposed or released");
+ ConnectionErrorFactory.ThrowConnectionException(ret);
+ }
+ } catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on SetDefaultCellularServiceProfileAsync\n" + e.ToString());
+ task.SetException(e);
+ }
+ }, null);
return task.Task;
}
-
else
{
throw new ArgumentNullException("Profile is null");
internal Task OpenProfileAsync(ConnectionProfile profile)
{
- Log.Debug(Globals.LogTag, "OpenProfileAsync");
+ Log.Info(Globals.LogTag, "OpenProfileAsync");
if (profile != null)
{
- Log.Debug(Globals.LogTag, "OpenProfileAsync " + profile.Name);
+ Log.Info(Globals.LogTag, "OpenProfileAsync " + profile.Name);
TaskCompletionSource<bool> task = new TaskCompletionSource<bool>();
Interop.Connection.ConnectionCallback Callback = (ConnectionError Result, IntPtr Data) =>
{
- Log.Debug(Globals.LogTag, "Connected " + profile.Name);
+ Log.Info(Globals.LogTag, "OpenProfileAsync done " + profile.Name);
if (Result != ConnectionError.None)
{
Log.Error(Globals.LogTag, "Error occurs during connecting profile, " + Result);
}
};
- int ret = Interop.Connection.OpenProfile(GetHandle(), profile.ProfileHandle, Callback, IntPtr.Zero);
- if ((ConnectionError)ret != ConnectionError.None)
+ context.Post((x) =>
{
- Log.Error(Globals.LogTag, "It failed to connect profile, " + (ConnectionError)ret);
- ConnectionErrorFactory.CheckFeatureUnsupportedException(ret, "http://tizen.org/feature/network.telephony " + "http://tizen.org/feature/network.wifi " + "http://tizen.org/feature/network.tethering.bluetooth");
- ConnectionErrorFactory.CheckHandleNullException(ret, (GetHandle() == IntPtr.Zero || profile.ProfileHandle == IntPtr.Zero), "Connection or Profile Handle may have been disposed or released");
- ConnectionErrorFactory.ThrowConnectionException(ret);
- }
+ Log.Info(Globals.LogTag, "Interop.Connection.OpenProfile " + profile.Name);
+ try
+ {
+ int ret = Interop.Connection.OpenProfile(GetHandle(), profile.ProfileHandle, Callback, IntPtr.Zero);
+ if ((ConnectionError)ret != ConnectionError.None)
+ {
+ Log.Error(Globals.LogTag, "It failed to connect profile, " + (ConnectionError)ret);
+ ConnectionErrorFactory.CheckFeatureUnsupportedException(ret, "http://tizen.org/feature/network.telephony " + "http://tizen.org/feature/network.wifi " + "http://tizen.org/feature/network.tethering.bluetooth");
+ ConnectionErrorFactory.CheckHandleNullException(ret, (GetHandle() == IntPtr.Zero || profile.ProfileHandle == IntPtr.Zero), "Connection or Profile Handle may have been disposed or released");
+ ConnectionErrorFactory.ThrowConnectionException(ret);
+ }
+ }
+ catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on OpenProfile\n" + e.ToString());
+ task.SetException(e);
+ }
+ }, null);
return task.Task;
}
internal Task CloseProfileAsync(ConnectionProfile profile)
{
- Log.Debug(Globals.LogTag, "CloseProfileAsync");
+ Log.Info(Globals.LogTag, "CloseProfileAsync");
if (profile != null)
{
- Log.Debug(Globals.LogTag, "CloseProfileAsync " + profile.Name);
+ Log.Info(Globals.LogTag, "CloseProfileAsync " + profile.Name);
TaskCompletionSource<bool> task = new TaskCompletionSource<bool>();
Interop.Connection.ConnectionCallback Callback = (ConnectionError Result, IntPtr Data) =>
{
+ Log.Info(Globals.LogTag, "CloseProfileAsync done " + profile.Name);
if (Result != ConnectionError.None)
{
Log.Error(Globals.LogTag, "Error occurs during disconnecting profile, " + Result);
}
};
- int ret = Interop.Connection.CloseProfile(GetHandle(), profile.ProfileHandle, Callback, IntPtr.Zero);
- if ((ConnectionError)ret != ConnectionError.None)
+ context.Post((x) =>
{
- Log.Error(Globals.LogTag, "It failed to disconnect profile, " + (ConnectionError)ret);
- ConnectionErrorFactory.CheckFeatureUnsupportedException(ret, "http://tizen.org/feature/network.telephony " + "http://tizen.org/feature/network.wifi " + "http://tizen.org/feature/network.tethering.bluetooth");
- ConnectionErrorFactory.CheckPermissionDeniedException(ret, "(http://tizen.org/privilege/network.set)");
- ConnectionErrorFactory.CheckHandleNullException(ret, (GetHandle() == IntPtr.Zero || profile.ProfileHandle == IntPtr.Zero), "Connection or Profile Handle may have been disposed or released");
- ConnectionErrorFactory.ThrowConnectionException(ret);
- }
+ Log.Info(Globals.LogTag, "Interop.Connection.CloseProfile " + profile.Name);
+ try
+ {
+ int ret = Interop.Connection.CloseProfile(GetHandle(), profile.ProfileHandle, Callback, IntPtr.Zero);
+ if ((ConnectionError)ret != ConnectionError.None)
+ {
+ Log.Error(Globals.LogTag, "It failed to disconnect profile, " + (ConnectionError)ret);
+ ConnectionErrorFactory.CheckFeatureUnsupportedException(ret, "http://tizen.org/feature/network.telephony " + "http://tizen.org/feature/network.wifi " + "http://tizen.org/feature/network.tethering.bluetooth");
+ ConnectionErrorFactory.CheckPermissionDeniedException(ret, "(http://tizen.org/privilege/network.set)");
+ ConnectionErrorFactory.CheckHandleNullException(ret, (GetHandle() == IntPtr.Zero || profile.ProfileHandle == IntPtr.Zero), "Connection or Profile Handle may have been disposed or released");
+ ConnectionErrorFactory.ThrowConnectionException(ret);
+ }
+ }
+ catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on CloseProfile\n" + e.ToString());
+ task.SetException(e);
+ }
+ }, null);
return task.Task;
}
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
+using Tizen.Applications;
namespace Tizen.Network.Connection
{
private Interop.ConnectionProfile.ProfileStateChangedCallback _profileChangedCallback;
+ private TizenSynchronizationContext context = new TizenSynchronizationContext();
+
internal IntPtr GetHandle()
{
return ProfileHandle;
{
add
{
- Log.Debug(Globals.LogTag, "ProfileStateChanged add");
- if (_ProfileStateChanged == null)
+ Log.Info(Globals.LogTag, "ProfileStateChanged add");
+ context.Post((x) =>
{
- ProfileStateChangedStart();
- }
- _ProfileStateChanged += value;
+ if (_ProfileStateChanged == null)
+ {
+ ProfileStateChangedStart();
+ }
+ _ProfileStateChanged += value;
+ }, null);
}
remove
{
- Log.Debug(Globals.LogTag, "ProfileStateChanged remove");
- _ProfileStateChanged -= value;
- if (_ProfileStateChanged == null)
+ Log.Info(Globals.LogTag, "ProfileStateChanged remove");
+ context.Post((x) =>
{
- ProfileStateChangedStop();
- }
+ _ProfileStateChanged -= value;
+ if (_ProfileStateChanged == null)
+ {
+ ProfileStateChangedStop();
+ }
+ }, null);
}
}
{
_profileChangedCallback = (ProfileState state, IntPtr userData) =>
{
+ Log.Info(Globals.LogTag, "***** MOON ProfileStateChanged occur");
if (_ProfileStateChanged != null)
{
_ProfileStateChanged(null, new ProfileStateEventArgs(state));
}
};
- Log.Debug(Globals.LogTag, "ProfileStateChangedStart");
+ Log.Info(Globals.LogTag, "ProfileStateChangedStart");
int ret = Interop.ConnectionProfile.SetStateChangeCallback(ProfileHandle, _profileChangedCallback, IntPtr.Zero);
if ((ConnectionError)ret != ConnectionError.None)
{
private void ProfileStateChangedStop()
{
- Log.Debug(Globals.LogTag, "ProfileStateChangedStop");
+ Log.Info(Globals.LogTag, "ProfileStateChangedStop");
int ret = Interop.ConnectionProfile.UnsetStateChangeCallback(ProfileHandle);
if ((ConnectionError)ret != ConnectionError.None)
{
if (disposed)
return;
- if (disposing)
- {
- // Free managed objects.
- UnregisterEvents();
- Destroy();
- }
+ // Free unmanaged objects
+ UnregisterEvents();
+ Destroy();
disposed = true;
}
<ItemGroup>
<ProjectReference Include="..\Tizen.Network.Connection\Tizen.Network.Connection.csproj" />
+ <ProjectReference Include="..\Tizen.Applications.Common\Tizen.Applications.Common.csproj" />
</ItemGroup>
</Project>
using System;
using System.Threading.Tasks;
using System.Collections.Generic;
-using System.ComponentModel;
+using Tizen.Applications;
namespace Tizen.Network.WiFi
{
private WiFiSecurity _security;
private bool _disposed = false;
+ private TizenSynchronizationContext context = new TizenSynchronizationContext();
+ private static TizenSynchronizationContext s_context = new TizenSynchronizationContext();
+
/// <summary>
/// The network information of the access point (AP).
/// </summary>
if (_disposed)
return;
- if (disposing)
- {
- Interop.WiFi.AP.Destroy(_apHandle);
- _apHandle = IntPtr.Zero;
- }
+ Interop.WiFi.AP.Destroy(_apHandle);
+ _apHandle = IntPtr.Zero;
_disposed = true;
}
/// <exception cref="InvalidOperationException">Thrown when the method failed due to an invalid operation.</exception>
public Task ConnectAsync()
{
- Log.Debug(Globals.LogTag, "ConnectAsync");
+ Log.Info(Globals.LogTag, "ConnectAsync");
if (_disposed)
{
throw new ObjectDisposedException("Invalid AP instance (Object may have been disposed or released)");
id = (IntPtr)_requestId++;
_callback_map[id] = (error, key) =>
{
- Log.Debug(Globals.LogTag, "Connecting finished : " + (WiFiError)error);
+ Log.Info(Globals.LogTag, "ConnectAsync done " + (WiFiError)error);
if (error != (int)WiFiError.None)
{
Log.Error(Globals.LogTag, "Error occurs during WiFi connecting, " + (WiFiError)error);
};
}
- int ret = Interop.WiFi.Connect(WiFiManagerImpl.Instance.GetSafeHandle(), _apHandle, _callback_map[id], id);
- if (ret != (int)WiFiError.None)
+ context.Post((x) =>
{
- Log.Error(Globals.LogTag, "Failed to connect wifi, Error - " + (WiFiError)ret);
- WiFiErrorFactory.ThrowWiFiException(ret, WiFiManagerImpl.Instance.GetSafeHandle().DangerousGetHandle(), _apHandle);
- }
+ Log.Info(Globals.LogTag, "Interop.WiFi.Connect");
+ try
+ {
+ int ret = Interop.WiFi.Connect(WiFiManagerImpl.Instance.GetSafeHandle(), _apHandle, _callback_map[id], id);
+ if (ret != (int)WiFiError.None)
+ {
+ Log.Error(Globals.LogTag, "Failed to connect wifi, Error - " + (WiFiError)ret);
+ WiFiErrorFactory.ThrowWiFiException(ret, WiFiManagerImpl.Instance.GetSafeHandle().DangerousGetHandle(), _apHandle);
+ }
+ }
+ catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on ConnectAsync\n" + e.ToString());
+ task.SetException(e);
+ }
+ }, null);
return task.Task;
}
/// <exception cref="InvalidOperationException">Thrown when the method failed due to an invalid operation.</exception>
public Task ConnectWpsAsync(WpsInfo info)
{
- Log.Debug(Globals.LogTag, "ConnectWpsAsync");
+ Log.Info(Globals.LogTag, "ConnectWpsAsync");
if (_disposed)
{
throw new ObjectDisposedException("Invalid AP instance (Object may have been disposed or released)");
id = (IntPtr)_requestId++;
_callback_map[id] = (error, key) =>
{
- Log.Debug(Globals.LogTag, "Connecting by WPS finished");
+ Log.Info(Globals.LogTag, "ConnectWpsAsync done");
if (error != (int)WiFiError.None)
{
Log.Error(Globals.LogTag, "Error occurs during WiFi connecting, " + (WiFiError)error);
};
}
- int ret = -1;
- if (info.GetType() == typeof(WpsPbcInfo))
- {
- ret = Interop.WiFi.ConnectByWpsPbc(WiFiManagerImpl.Instance.GetSafeHandle(), _apHandle, _callback_map[id], id);
- }
-
- else if (info.GetType() == typeof(WpsPinInfo))
+ context.Post((x) =>
{
- WpsPinInfo pinInfo = (WpsPinInfo)info;
- if (pinInfo.GetWpsPin() == null)
+ try
{
- throw new ArgumentNullException("Wps pin should not be null");
- }
+ int ret = -1;
+ if (info.GetType() == typeof(WpsPbcInfo))
+ {
+ Log.Info(Globals.LogTag, "Interop.WiFi.ConnectByWpsPb");
+ ret = Interop.WiFi.ConnectByWpsPbc(WiFiManagerImpl.Instance.GetSafeHandle(), _apHandle, _callback_map[id], id);
+ }
+ else if (info.GetType() == typeof(WpsPinInfo))
+ {
+ WpsPinInfo pinInfo = (WpsPinInfo)info;
+ if (pinInfo.GetWpsPin() == null)
+ {
+ throw new ArgumentNullException("Wps pin should not be null");
+ }
+
+ if (pinInfo.GetWpsPin().Length == 0 || pinInfo.GetWpsPin().Length > 8)
+ {
+ throw new ArgumentOutOfRangeException("Wps pin should not be empty or more than 7 characters");
+ }
+
+ Log.Info(Globals.LogTag, "Interop.WiFi.ConnectByWpsPin");
+ ret = Interop.WiFi.ConnectByWpsPin(WiFiManagerImpl.Instance.GetSafeHandle(), _apHandle, pinInfo.GetWpsPin(), _callback_map[id], id);
+ }
- if (pinInfo.GetWpsPin().Length == 0 || pinInfo.GetWpsPin().Length > 8)
+ if (ret != (int)WiFiError.None)
+ {
+ Log.Error(Globals.LogTag, "Failed to connect wifi, Error - " + (WiFiError)ret);
+ WiFiErrorFactory.ThrowWiFiException(ret, WiFiManagerImpl.Instance.GetSafeHandle().DangerousGetHandle(), _apHandle);
+ }
+ }
+ catch (Exception e)
{
- throw new ArgumentOutOfRangeException("Wps pin should not be empty or more than 7 characters");
+ Log.Error(Globals.LogTag, "Exception on ConnectWpsAsync\n" + e.ToString());
+ task.SetException(e);
}
-
- ret = Interop.WiFi.ConnectByWpsPin(WiFiManagerImpl.Instance.GetSafeHandle(), _apHandle, pinInfo.GetWpsPin(), _callback_map[id], id);
- }
-
- if (ret != (int)WiFiError.None)
- {
- Log.Error(Globals.LogTag, "Failed to connect wifi, Error - " + (WiFiError)ret);
- WiFiErrorFactory.ThrowWiFiException(ret, WiFiManagerImpl.Instance.GetSafeHandle().DangerousGetHandle(), _apHandle);
- }
+ }, null);
return task.Task;
}
/// <exception cref="InvalidOperationException">Thrown when the method failed due to an invalid operation.</exception>
public static Task<WiFiAP> ConnectWpsWithoutSsidAsync(WpsInfo info)
{
+ Log.Info(Globals.LogTag, "ConnectWpsWithoutSsidAsync");
TaskCompletionSource<WiFiAP> task = new TaskCompletionSource<WiFiAP>();
IntPtr id;
lock (s_callbackMap)
id = (IntPtr)s_requestId++;
s_callbackMap[id] = (error, key) =>
{
- Log.Debug(Globals.LogTag, "Connecting by WPS finished");
+ Log.Info(Globals.LogTag, "ConnectWpsWithoutSsidAsync done");
if (error != (int)WiFiError.None)
{
Log.Error(Globals.LogTag, "Error occurs during WiFi connecting, " + (WiFiError)error);
};
}
- int ret = -1;
- if (info.GetType() == typeof(WpsPbcInfo))
- {
- ret = Interop.WiFi.ConnectByWpsPbcWithoutSsid(WiFiManagerImpl.Instance.GetSafeHandle(), s_callbackMap[id], id);
- }
-
- else if (info.GetType() == typeof(WpsPinInfo))
+ s_context.Post((x) =>
{
- WpsPinInfo pinInfo = (WpsPinInfo)info;
- if (pinInfo.GetWpsPin() == null)
+ try
{
- throw new ArgumentNullException("Wps pin should not be null");
- }
+ int ret = -1;
+ if (info.GetType() == typeof(WpsPbcInfo))
+ {
+ Log.Info(Globals.LogTag, "Interop.WiFi.ConnectByWpsPbcWithoutSsid");
+ ret = Interop.WiFi.ConnectByWpsPbcWithoutSsid(WiFiManagerImpl.Instance.GetSafeHandle(), s_callbackMap[id], id);
+ }
+ else if (info.GetType() == typeof(WpsPinInfo))
+ {
+ WpsPinInfo pinInfo = (WpsPinInfo)info;
+ if (pinInfo.GetWpsPin() == null)
+ {
+ throw new ArgumentNullException("Wps pin should not be null");
+ }
+
+ if (pinInfo.GetWpsPin().Length != 4 && pinInfo.GetWpsPin().Length != 8)
+ {
+ throw new ArgumentOutOfRangeException("Wps pin should be of 4 or 8 characters long");
+ }
+
+ Log.Info(Globals.LogTag, "Interop.WiFi.ConnectByWpsPinWithoutSsid");
+ ret = Interop.WiFi.ConnectByWpsPinWithoutSsid(WiFiManagerImpl.Instance.GetSafeHandle(), pinInfo.GetWpsPin(), s_callbackMap[id], id);
+ }
- if (pinInfo.GetWpsPin().Length != 4 && pinInfo.GetWpsPin().Length != 8)
+ if (ret != (int)WiFiError.None)
+ {
+ Log.Error(Globals.LogTag, "Failed to connect wifi, Error - " + (WiFiError)ret);
+ WiFiErrorFactory.ThrowWiFiException(ret, WiFiManagerImpl.Instance.GetSafeHandle().DangerousGetHandle());
+ }
+ }
+ catch (Exception e)
{
- throw new ArgumentOutOfRangeException("Wps pin should be of 4 or 8 characters long");
+ Log.Error(Globals.LogTag, "Exception on ConnectWpsWithoutSsidAsync\n" + e.ToString());
+ task.SetException(e);
}
-
- ret = Interop.WiFi.ConnectByWpsPinWithoutSsid(WiFiManagerImpl.Instance.GetSafeHandle(), pinInfo.GetWpsPin(), s_callbackMap[id], id);
- }
-
- if (ret != (int)WiFiError.None)
- {
- Log.Error(Globals.LogTag, "Failed to connect wifi, Error - " + (WiFiError)ret);
- WiFiErrorFactory.ThrowWiFiException(ret, WiFiManagerImpl.Instance.GetSafeHandle().DangerousGetHandle());
- }
+ }, null);
return task.Task;
}
id = (IntPtr)_requestId++;
_callback_map[id] = (error, key) =>
{
- Log.Debug(Globals.LogTag, "Disconnecting finished");
+ Log.Info(Globals.LogTag, "DisconnectAsync done");
if (error != (int)WiFiError.None)
{
Log.Error(Globals.LogTag, "Error occurs during WiFi disconnecting, " + (WiFiError)error);
}
};
}
- int ret = Interop.WiFi.Disconnect(WiFiManagerImpl.Instance.GetSafeHandle(), _apHandle, _callback_map[id], id);
- if (ret != (int)WiFiError.None)
+
+ context.Post((x) =>
{
- Log.Error(Globals.LogTag, "Failed to disconnect wifi, Error - " + (WiFiError)ret);
- WiFiErrorFactory.ThrowWiFiException(ret, WiFiManagerImpl.Instance.GetSafeHandle().DangerousGetHandle(), _apHandle);
- }
+ Log.Info(Globals.LogTag, "Interop.WiFi.Disconnect");
+ try
+ {
+ int ret = Interop.WiFi.Disconnect(WiFiManagerImpl.Instance.GetSafeHandle(), _apHandle, _callback_map[id], id);
+ if (ret != (int)WiFiError.None)
+ {
+ Log.Error(Globals.LogTag, "Failed to disconnect wifi, Error - " + (WiFiError)ret);
+ WiFiErrorFactory.ThrowWiFiException(ret, WiFiManagerImpl.Instance.GetSafeHandle().DangerousGetHandle(), _apHandle);
+ }
+ }
+ catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on Disconnect\n" + e.ToString());
+ task.SetException(e);
+ }
+ }, null);
+
return task.Task;
}
if (_disposed)
return;
- if (disposing)
- {
- Interop.WiFi.Config.Destroy(_configHandle);
- _configHandle = IntPtr.Zero;
- }
+ Interop.WiFi.Config.Destroy(_configHandle);
+ _configHandle = IntPtr.Zero;
_disposed = true;
}
[EditorBrowsable(EditorBrowsableState.Never)]
public sealed class SafeWiFiManagerHandle : SafeHandle
{
- private int tid;
+ private int _tid;
internal SafeWiFiManagerHandle() : base(IntPtr.Zero, true)
{
/// </summary>
protected override bool ReleaseHandle()
{
- Interop.WiFi.Deinitialize(tid, this.handle);
+ Interop.WiFi.Deinitialize(_tid, this.handle);
this.SetHandle(IntPtr.Zero);
return true;
}
- internal int TID
+ internal void SetTID(int id)
{
- set
- {
- tid = value;
- Log.Info(Globals.LogTag, "New Handle for Thread " + tid);
- }
+ _tid = id;
+ Log.Info(Globals.LogTag, "New Handle for Thread " + _tid);
}
}
using System.Threading;
using System.Threading.Tasks;
using System.Runtime.InteropServices;
+using Tizen.Applications;
namespace Tizen.Network.WiFi
{
{
private static readonly Lazy<WiFiManagerImpl> _instance =
new Lazy<WiFiManagerImpl>(() => new WiFiManagerImpl());
- private Dictionary<IntPtr, Interop.WiFi.VoidCallback> _callback_map = new Dictionary<IntPtr, Interop.WiFi.VoidCallback>();
+
+ private TizenSynchronizationContext context = new TizenSynchronizationContext();
+
+ private Dictionary<IntPtr, Interop.WiFi.VoidCallback> _callback_map =
+ new Dictionary<IntPtr, Interop.WiFi.VoidCallback>();
+
private int _requestId = 0;
private string _macAddress;
{
get
{
+ Log.Info(Globals.LogTag, "IsActive");
bool active;
int ret = Interop.WiFi.IsActive(GetSafeHandle(), out active);
if (ret != (int)WiFiError.None)
Log.Error(Globals.LogTag, "Failed to initialize wifi, Error - " + (WiFiError)ret);
WiFiErrorFactory.ThrowWiFiException(ret, "http://tizen.org/privilege/network.get");
}
- handle.TID = tid;
+ handle.SetTID(tid);
return handle;
}
id = (IntPtr)_requestId++;
_callback_map[id] = (error, key) =>
{
- Log.Info(Globals.LogTag, "wifi activated");
+ Log.Info(Globals.LogTag, "ActivateAsync done");
if (error != (int)WiFiError.None)
{
Log.Error(Globals.LogTag, "Error occurs during WiFi activating, " + (WiFiError)error);
}
};
}
- int ret = Interop.WiFi.Activate(GetSafeHandle(), _callback_map[id], id);
- if (ret != (int)WiFiError.None)
+
+ context.Post((x) =>
{
- Log.Error(Globals.LogTag, "Failed to activate wifi, Error - " + (WiFiError)ret);
- WiFiErrorFactory.ThrowWiFiException(ret, GetSafeHandle().DangerousGetHandle());
- }
+ Log.Info(Globals.LogTag, "Interop.WiFi.ActivateAsync");
+ try
+ {
+ int ret = Interop.WiFi.Activate(GetSafeHandle(), _callback_map[id], id);
+ if (ret != (int)WiFiError.None)
+ {
+ Log.Error(Globals.LogTag, "Failed to activate wifi, Error - " + (WiFiError)ret);
+ WiFiErrorFactory.ThrowWiFiException(ret, GetSafeHandle().DangerousGetHandle());
+ }
+ }
+ catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on ActivateAsync\n" + e.ToString());
+ task.SetException(e);
+ }
+ }, null);
+
return task.Task;
}
internal Task ActivateWithWiFiPickerTestedAsync()
{
- Log.Debug(Globals.LogTag, "ActivateWithWiFiPickerTestedAsync");
+ Log.Info(Globals.LogTag, "ActivateWithWiFiPickerTestedAsync");
TaskCompletionSource<bool> task = new TaskCompletionSource<bool>();
IntPtr id;
lock (_callback_map)
id = (IntPtr)_requestId++;
_callback_map[id] = (error, key) =>
{
- Log.Debug(Globals.LogTag, "Activation finished");
+ Log.Info(Globals.LogTag, "ActivateWithWiFiPickerTestedAsync done");
if (error != (int)WiFiError.None)
{
Log.Error(Globals.LogTag, "Error occurs during WiFi activating, " + (WiFiError)error);
}
};
}
- int ret = Interop.WiFi.ActivateWithWiFiPickerTested(GetSafeHandle(), _callback_map[id], id);
- if (ret != (int)WiFiError.None)
+
+ context.Post((x) =>
{
- Log.Error(Globals.LogTag, "Failed to activate wifi, Error - " + (WiFiError)ret);
- WiFiErrorFactory.ThrowWiFiException(ret, GetSafeHandle().DangerousGetHandle());
- }
+ Log.Info(Globals.LogTag, "Interop.WiFi.ActivateWithWiFiPickerTestedAsync");
+ try
+ {
+ int ret = Interop.WiFi.ActivateWithWiFiPickerTested(GetSafeHandle(), _callback_map[id], id);
+ if (ret != (int)WiFiError.None)
+ {
+ Log.Error(Globals.LogTag, "Failed to activate wifi, Error - " + (WiFiError)ret);
+ WiFiErrorFactory.ThrowWiFiException(ret, GetSafeHandle().DangerousGetHandle());
+ }
+ }
+ catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on ActivateWithWiFiPickerTestedAsync\n" + e.ToString());
+ task.SetException(e);
+ }
+ }, null);
+
return task.Task;
}
id = (IntPtr)_requestId++;
_callback_map[id] = (error, key) =>
{
- Log.Info(Globals.LogTag, "Deactivation finished");
+ Log.Info(Globals.LogTag, "DeactivateAsync done");
if (error != (int)WiFiError.None)
{
Log.Error(Globals.LogTag, "Error occurs during WiFi deactivating, " + (WiFiError)error);
}
};
}
- int ret = Interop.WiFi.Deactivate(GetSafeHandle(), _callback_map[id], id);
- if (ret != (int)WiFiError.None)
+
+ context.Post((x) =>
{
- Log.Error(Globals.LogTag, "Failed to deactivate wifi, Error - " + (WiFiError)ret);
- WiFiErrorFactory.ThrowWiFiException(ret, GetSafeHandle().DangerousGetHandle());
- }
- return task.Task;
+ Log.Info(Globals.LogTag, "Interop.WiFi.Deactivate");
+ try
+ {
+ int ret = Interop.WiFi.Deactivate(GetSafeHandle(), _callback_map[id], id);
+ if (ret != (int)WiFiError.None)
+ {
+ Log.Error(Globals.LogTag, "Failed to deactivate wifi, Error - " + (WiFiError)ret);
+ WiFiErrorFactory.ThrowWiFiException(ret, GetSafeHandle().DangerousGetHandle());
+ }
+ }
+ catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on Deactivate\n" + e.ToString());
+ task.SetException(e);
+ }
+ }, null);
+
+ return task.Task;
}
internal Task ScanAsync()
id = (IntPtr)_requestId++;
_callback_map[id] = (error, key) =>
{
- Log.Info(Globals.LogTag, "Scanning finished");
+ Log.Info(Globals.LogTag, "ScanAsync done");
if (error != (int)WiFiError.None)
{
Log.Error(Globals.LogTag, "Error occurs during WiFi scanning, " + (WiFiError)error);
}
};
}
- int ret = Interop.WiFi.Scan(GetSafeHandle(), _callback_map[id], id);
- if (ret != (int)WiFiError.None)
+
+ context.Post((x) =>
{
- Log.Error(Globals.LogTag, "Failed to scan all AP, Error - " + (WiFiError)ret);
- WiFiErrorFactory.ThrowWiFiException(ret, GetSafeHandle().DangerousGetHandle());
- }
+ Log.Info(Globals.LogTag, "Interop.WiFi.Scan");
+ try
+ {
+ int ret = Interop.WiFi.Scan(GetSafeHandle(), _callback_map[id], id);
+ if (ret != (int)WiFiError.None)
+ {
+ Log.Error(Globals.LogTag, "Failed to scan all AP, Error - " + (WiFiError)ret);
+ WiFiErrorFactory.ThrowWiFiException(ret, GetSafeHandle().DangerousGetHandle());
+ }
+ }
+ catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on Scan\n" + e.ToString());
+ task.SetException(e);
+ }
+ }, null);
+
return task.Task;
}
id = (IntPtr)_requestId++;
_callback_map[id] = (error, key) =>
{
- Log.Info(Globals.LogTag, "Scanning with specific AP finished");
+ Log.Info(Globals.LogTag, "ScanSpecificAPAsync Done " + essid);
if (error != (int)WiFiError.None)
{
Log.Error(Globals.LogTag, "Error occurs during WiFi scanning, " + (WiFiError)error);
}
};
}
- int ret = Interop.WiFi.ScanSpecificAP(GetSafeHandle(), essid, _callback_map[id], id);
- if (ret != (int)WiFiError.None)
+
+ context.Post((x) =>
{
- Log.Error(Globals.LogTag, "Failed to scan with specific AP, Error - " + (WiFiError)ret);
- WiFiErrorFactory.ThrowWiFiException(ret, GetSafeHandle().DangerousGetHandle());
- }
+ Log.Info(Globals.LogTag, "Interop.WiFi.ScanSpecificAPAsync");
+ try
+ {
+ int ret = Interop.WiFi.ScanSpecificAP(GetSafeHandle(), essid, _callback_map[id], id);
+ if (ret != (int)WiFiError.None)
+ {
+ Log.Error(Globals.LogTag, "Failed to scan with specific AP, Error - " + (WiFiError)ret);
+ WiFiErrorFactory.ThrowWiFiException(ret, GetSafeHandle().DangerousGetHandle());
+ }
+ }
+ catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on ScanSpecificAPAsync\n" + e.ToString());
+ task.SetException(e);
+ }
+ }, null);
+
return task.Task;
}
using System;
using System.Threading.Tasks;
+using System.Threading;
+using Tizen.Applications;
namespace Tizen.Network.WiFi
{
{
add
{
- if (_deviceStateChanged == null)
+ context.Post((x) =>
{
- RegisterDeviceStateChangedEvent();
- }
- _deviceStateChanged += value;
+ if (_deviceStateChanged == null)
+ {
+ try
+ {
+ RegisterDeviceStateChangedEvent();
+ } catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on adding DeviceStateChanged\n" + e.ToString());
+ return;
+ }
+ }
+ _deviceStateChanged += value;
+ }, null);
}
remove
{
- _deviceStateChanged -= value;
- if (_deviceStateChanged == null)
+ context.Post((x) =>
{
- UnregisterDeviceStateChangedEvent();
- }
+ _deviceStateChanged -= value;
+ if (_deviceStateChanged == null)
+ {
+ try
+ {
+ UnregisterDeviceStateChangedEvent();
+ }
+ catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on removing DeviceStateChanged\n" + e.ToString());
+ }
+ }
+ }, null);
}
}
{
add
{
- if (_connectionStateChanged == null)
+ context.Post((x) =>
{
- RegisterConnectionStateChangedEvent();
- }
- _connectionStateChanged += value;
+ if (_connectionStateChanged == null)
+ {
+ try
+ {
+ RegisterConnectionStateChangedEvent();
+ }
+ catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on adding ConnectionStateChanged\n" + e.ToString());
+ return;
+ }
+ }
+ _connectionStateChanged += value;
+ }, null);
}
remove
{
- _connectionStateChanged -= value;
- if (_connectionStateChanged == null)
+ context.Post((x) =>
{
- UnregisterConnectionStateChangedEvent();
- }
+ _connectionStateChanged -= value;
+ if (_connectionStateChanged == null)
+ {
+ try
+ {
+ UnregisterConnectionStateChangedEvent();
+ }
+ catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on removing ConnectionStateChanged\n" + e.ToString());
+ }
+ }
+ }, null);
}
}
{
add
{
- if (_rssiLevelChanged == null)
+ context.Post((x) =>
{
- RegisterRssiLevelChangedEvent();
- }
- _rssiLevelChanged += value;
+ if (_rssiLevelChanged == null)
+ {
+ try
+ {
+ RegisterRssiLevelChangedEvent();
+ }
+ catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on adding RssiLevelChanged\n" + e.ToString());
+ return;
+ }
+ }
+ _rssiLevelChanged += value;
+ }, null);
}
remove
{
- _rssiLevelChanged -= value;
- if (_rssiLevelChanged == null)
+ context.Post((x) =>
{
- UnregisterRssiLevelChangedEvent();
- }
+ _rssiLevelChanged -= value;
+ if (_rssiLevelChanged == null)
+ {
+ try
+ {
+ UnregisterRssiLevelChangedEvent();
+ }
+ catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on removing RssiLevelChanged\n" + e.ToString());
+ }
+ }
+ }, null);
}
}
{
add
{
- if (_backgroundScanFinished == null)
+ context.Post((x) =>
{
- RegisterBackgroundScanFinishedEvent();
- }
- _backgroundScanFinished += value;
+ if (_backgroundScanFinished == null)
+ {
+ try
+ {
+ RegisterBackgroundScanFinishedEvent();
+ }
+ catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on adding BackgroundScanFinished\n" + e.ToString());
+ return;
+ }
+ }
+ _backgroundScanFinished += value;
+ }, null);
}
remove
{
- _backgroundScanFinished -= value;
- if (_backgroundScanFinished == null)
+ context.Post((x) =>
{
- UnregisterBackgroundScanFinishedEvent();
- }
+ _backgroundScanFinished -= value;
+ if (_backgroundScanFinished == null)
+ {
+ try
+ {
+ UnregisterBackgroundScanFinishedEvent();
+ }
+ catch (Exception e)
+ {
+ Log.Error(Globals.LogTag, "Exception on removing BackgroundScanFinished\n" + e.ToString());
+ }
+ }
+ }, null);
}
}
private void RegisterDeviceStateChangedEvent()
{
+ Log.Info(Globals.LogTag, "RegisterDeviceStateChangedEvent in Thread " + Thread.CurrentThread.ManagedThreadId);
_deviceChangedCallback = (int deviceState, IntPtr userDate) =>
{
WiFiDeviceState state = (WiFiDeviceState)deviceState;
private void UnregisterDeviceStateChangedEvent()
{
+ Log.Info(Globals.LogTag, "UnregisterDeviceStateChangedEvent in Thread " + Thread.CurrentThread.ManagedThreadId);
int ret = Interop.WiFi.UnsetDeviceStateChangedCallback(GetSafeHandle());
if (ret != (int)WiFiError.None)
{
projects / platform / core / csapi / tizenfx.git / commitdiff