public void connect(ConnectionCallback onComplete)
{
CallbackState state = new CallbackState(socket, onComplete);
try
{
socket.BeginConnect(ipEndPoint, ConnectCallback, state);
}
//catch (ArgumentNullException ae)
//{
// Console.WriteLine("ArgumentNullException : {0}", ae.ToString());
//}
//catch (SocketException se)
//{
// Console.WriteLine("SocketException : {0}", se.ToString());
//}
catch (Exception e)
{
Console.WriteLine("Unexpected exception : {0}", e.ToString());
var connectionResult = new ConnectionResult();
connectionResult.result = ConnectionResult.Result.FAILURE;
connectionResult.Message = e.Message;
onComplete.Invoke(connectionResult);
}
}
public WebSocketIO Connect(ConnectionCallback onSuccess, ConnectionCallbackError onError)
{
m_webSocket.OnOpen += EventHandlerOnOpen;
m_webSocket.OnClose += EventHandlerOnClose;
m_webSocket.OnMessage += EventHandlerOnMessage;
m_webSocket.OnError += EventHandlerOnError;
m_webSocket.OnOpen += OnOpen;
m_webSocket.OnClose += OnClose;
m_webSocket.Connect();
return(this);
void OnOpen(object sender, EventArgs e)
{
m_webSocket.OnOpen -= OnOpen;
m_webSocket.OnClose -= OnClose;
onSuccess?.Invoke();
}
void OnClose(object sender, CloseEventArgs e)
{
m_webSocket.OnOpen -= OnOpen;
m_webSocket.OnClose -= OnClose;
onError?.Invoke(e.Code, e.Reason, e.WasClean);
}
}
public Server(IO.Context context, ConnectionCallback callback, ITcpServerSocket socket, bool closeOnEnd = false)
{
this.callback = callback;
this.socket = socket;
this.closeOnEnd = closeOnEnd;
this.Context = context;
}
protected void UpdateConnectionStatus(int step, CableInfo info, ConnectionCallback callback)
{
if (callback != null)
{
callback(step, info);
System.Threading.Thread.Sleep(100);
}
}
public void setConnectionCallback(ISplitSensorConnectionCallback callback)
{
#if UNITY_ANDROID
if (nativeController != null)
{
var ConnectionCallback = new ConnectionCallback();
nativeController.Call("setConnectionCallback", ConnectionCallback);
}
#endif
mSplitSensorConnectionCallback = callback;
}
public Transaction(Server server, ITcpSocket socket, ConnectionCallback callback, bool closeOnEnd = false)
{
Server = server;
Socket = socket;
this.closeOnEnd = closeOnEnd;
Context = server.Context;
ConnectionCallback = callback;
gc_handle = GCHandle.Alloc(this);
Request = new Request(this, socket);
Request.Read(Close);
}
public DroidReachabilityService(IMvxMessenger messenger)
{
_messenger = messenger;
_manager = (ConnectivityManager)Application.Context.GetSystemService(Context.ConnectivityService);
if (Build.VERSION.SdkInt <= BuildVersionCodes.N)
{
var receiver = new ConnectionBroadcastReceiver(this);
#pragma warning disable CS0618 // Type or member is obsolete
Application.Context.RegisterReceiver(receiver, new IntentFilter(ConnectivityManager.ConnectivityAction));
#pragma warning restore CS0618 // Type or member is obsolete
}
else
{
var callback = new ConnectionCallback(this);
_manager.RegisterDefaultNetworkCallback(callback);
}
}
public int Init(Action <byte, DolphiimoteData> newData, Action <byte, bool> wiimoteConnectionChanged, Action <byte, DolphiimoteCapabilities> capabilitiesChanged, Action <string> newLogMessage)
{
dataCallback = (wiimote, data, user) => newData(wiimote, MarshalType <DolphiimoteData>(data));
capabilitiesCallback = (wiimote, capabilities, user) => capabilitiesChanged(wiimote, MarshalType <DolphiimoteCapabilities>(capabilities));
connectionCallback = (wiimote, status) => wiimoteConnectionChanged(wiimote, Convert.ToBoolean(status));
logCallback = (str, length) => newLogMessage(Marshal.PtrToStringAnsi(str, (int)length));
var callbacks = new DolphiimoteCallbacks
{
dataReceived = MarshalFunction(dataCallback),
capabilitiesChanged = MarshalFunction(capabilitiesCallback),
connectionChanged = MarshalFunction(connectionCallback),
onLog = MarshalFunction(logCallback),
userData = IntPtr.Zero
};
return(dolphiimoteInit(callbacks));
}
public async Task OpenAsync(ConnectionCallback callback = null)
{
try
{
await socket.ConnectTaskAsync(RemoteEndPoint).ConfigureAwait(false);
IsConnected = true;
}
catch (SocketException ex)
{
IsConnected = false;
throw new CommunicationException("Подключение не установлено.", ex);
}
if (callback != null)
{
await callback.Invoke().ConfigureAwait(false);
}
}
public static Transaction BeginTransaction(Server server, ITcpSocket socket, ConnectionCallback cb, bool closeOnEnd = false)
{
Transaction transaction = new Transaction(server, socket, cb, closeOnEnd);
return transaction;
}
/// <summary>
/// Initialize a new object of LiteServer
/// </summary>
/// <param name="port">The port to listen at</param>
public LiteServer(ushort port)
: base(new ServersProps(port))
{
Clients = new List <Client>();
this._clientDisconnected = ClientDisconnected;
}
/// <summary>
/// Recieve multiple connections, each connection is passed to the callback in a new thread. Does not return.
/// </summary>
/// <param name="callback"></param>
private void AcceptMultiple(ConnectionCallback callback)
{
while(true)
{
var comm = new TcpServerCommunicator(Port, AcceptClient());
var thread = new Thread(() => callback(comm));
thread.Start();
}
}
public static extern int SetDefaultCellularServiceProfileAsync(IntPtr handle, int Type, IntPtr profileHandle, ConnectionCallback callback, IntPtr userData);
public void setCallback(ConnectionCallback callback)
{
lock(this)
{
if(_state >= StateClosed)
{
if(callback != null)
{
_threadPool.dispatch(() =>
{
try
{
callback.closed(this);
}
catch(System.Exception ex)
{
_logger.error("connection callback exception:\n" + ex + '\n' + _desc);
}
} , this);
}
}
else
{
_callback = callback;
}
}
}
public ConnectionListener(ShowResultCallback showResult, ConnectionCallback onConnectDoneCallback)
{
mShowResultCallback = showResult;
mOnConnectDoneCallback = onConnectDoneCallback;
}
public void AddConnectionRecoverableCallbacks(ConnectionCallback mRecoverable, ConnectionCallback mRecovered)
{
mConnectionRecoverableError = mRecoverable;
mConnectionRecoverd = mRecovered;
}
public void Listen(int backlog, ConnectionCallback connectionCallback)
{
_connectionCallback = connectionCallback;
LibuvNative.uv_listen(this, backlog, ConnectionCb);
}
public static extern int CloseProfile(IntPtr handle, IntPtr profileHandle, ConnectionCallback callback, IntPtr userData);
/// <summary>
/// Creates a new instance of CustomCable.
/// </summary>
/// <param name="port"> The port the cable is connected to. </param>
/// <param name="timeoutMilliseconds"> The timeout to use for communication with the cable. </param>
public Elm327Cable(string port, int timeoutMilliseconds, ConnectionCallback callback) :
base(port, timeoutMilliseconds, 38400)
{
CableType = Type.Elm327;
IsInitialized = false; // default to false
// default cable info
CableInfo info = new CableInfo();
// set the newline character to be what elm327 uses
cableConnection.NewLine = Protocols.Elm327.EndOfLine;
info.Description = "Discovering ELM version";
UpdateConnectionStatus(1, info, callback);
// detect what type of cable is connected
string response = SendCommand(Protocols.Elm327.Reset, 1000);
if (response.Contains(Protocols.Elm327.Header))
{
Diagnostics.DiagnosticLogger.Log("Cable is ELM327 type");
string version = "NA";
// get the version number for posterity
if (response.Contains("v"))
{
int indexOfVersion = response.IndexOf("v");
version = response.Substring(indexOfVersion);
Diagnostics.DiagnosticLogger.Log("Discovered ELM version: " + version);
info.Description = "Discovered ELM version: " + version;
info.Version = version;
UpdateConnectionStatus(1, info, callback);
}
// turn echo off
Diagnostics.DiagnosticLogger.Log("Turning echo off");
info.Description = "Turning echo off";
UpdateConnectionStatus(1, info, callback);
response = SendCommand(Protocols.Elm327.EchoOff, 10000);
if (!response.Contains(Protocols.Elm327.Responses.OK))
{
Diagnostics.DiagnosticLogger.Log("Could not turn echo off");
return;
}
info.EchoOff = true;
info.Description = "Turning auto protocol on";
UpdateConnectionStatus(2, info, callback);
Diagnostics.DiagnosticLogger.Log("Turning auto protocol on");
response = SendCommand(Protocols.Elm327.SetAutoProtocol, 10000);
if (!response.Contains(Protocols.Elm327.Responses.OK))
{
Diagnostics.DiagnosticLogger.Log("Could not set protocol to Auto");
return;
}
info.Description = "Forcing search for vehicle's protocol";
UpdateConnectionStatus(2, info, callback);
Diagnostics.DiagnosticLogger.Log("Forcing a search for existing protocol");
response = SendCommand(Protocols.Elm327.ForceProtocolSearch, 10000);
if (string.IsNullOrEmpty(response))
{
Diagnostics.DiagnosticLogger.Log("Could not force an auto protocol search");
info.Description = "Error, could not force an auto protocol search";
UpdateConnectionStatus(2, info, callback);
return;
}
response = SendCommand(Protocols.Elm327.DisplayProtocol, 10000);
string chosenProtocol = response.Replace(Protocols.Elm327.Responses.Auto, string.Empty).Replace(",", string.Empty).Trim();
Diagnostics.DiagnosticLogger.Log("Protocol chosen: " + chosenProtocol);
if (!response.Contains(Protocols.Elm327.Responses.Auto))
{
Diagnostics.DiagnosticLogger.Log("Displayed protocol did not mention auto");
info.Description = "Error, displayed protocol did not mention auto";
UpdateConnectionStatus(2, info, callback);
//return;
}
Protocol = OBD2.Protocols.NameToProtocol(chosenProtocol);
info.Protocol = Protocol;
info.AutoProtocolSet = true;
info.Description = "Protocol has been chosen";
UpdateConnectionStatus(3, info, callback);
// everything is good to go
IsInitialized = true;
// fully initialized, the fourth step is the final step
info.Description = "Connected!";
UpdateConnectionStatus(4, info, callback);
}
}
public static extern int ResetProfile(IntPtr handle, int Option, int Id, ConnectionCallback callback, IntPtr userData);
public CallbackState(Socket socket, ConnectionCallback callback)
{
this.socket = socket;
this.callback = callback;
}
public ConnectionListener(ShowResultCallback showResult, ConnectionCallback onConnectDoneCallback)
{
mShowResultCallback = showResult;
mOnConnectDoneCallback = onConnectDoneCallback;
}
/// <summary>
/// Recieve multiple connections, each connection is passed to the callback in a new thread. Does not return.
/// </summary>
/// <param name="callback"></param>
public void Initialize(ConnectionCallback callback)
{
_thread = new Thread(() => AcceptMultiple(callback));
}
public void AddConnectionRecoverableCallbacks(ConnectionCallback mRecoverable, ConnectionCallback mRecovered)
{
mConnectionRecoverableError = mRecoverable;
mConnectionRecoverd = mRecovered;
}
public static extern MLResult.Code MLAppConnectRegisterConnectionCallback(ref ConnectionCallback connection_callback, ref ulong outCallbackHandle);
