public void Start()
{
lock (_connLocker) {
if (_leapConnection != IntPtr.Zero)
{
return;
}
eLeapRS result = LeapC.CreateConnection(out _leapConnection);
if (result != eLeapRS.eLeapRS_Success || _leapConnection == IntPtr.Zero)
{
reportAbnormalResults("LeapC CreateConnection call was ", result);
return;
}
result = LeapC.OpenConnection(_leapConnection);
if (result != eLeapRS.eLeapRS_Success)
{
reportAbnormalResults("LeapC OpenConnection call was ", result);
return;
}
_polster = new Thread(new ThreadStart(this.processMessages));
_polster.IsBackground = true;
_polster.Start();
}
}
public void Start() {
if (_isRunning)
return;
eLeapRS result;
if (_leapConnection == IntPtr.Zero) {
result = LeapC.CreateConnection(out _leapConnection);
if (result != eLeapRS.eLeapRS_Success || _leapConnection == IntPtr.Zero) {
reportAbnormalResults("LeapC CreateConnection call was ", result);
return;
}
}
result = LeapC.OpenConnection(_leapConnection);
if (result != eLeapRS.eLeapRS_Success) {
reportAbnormalResults("LeapC OpenConnection call was ", result);
return;
}
// The Allocator must persist the lifetime of the connection
if (_pLeapAllocator.allocate == null) {
_pLeapAllocator.allocate = MemoryManager.Pin;
}
if (_pLeapAllocator.deallocate == null) {
_pLeapAllocator.deallocate = MemoryManager.Unpin;
}
LeapC.SetAllocator(_leapConnection, ref _pLeapAllocator);
_isRunning = true;
AppDomain.CurrentDomain.DomainUnload += (arg1, arg2) => Dispose(true);
_polster = new Thread(processMessages) {Name = "LeapC Worker", IsBackground = true};
_polster.Start();
}
public void Start()
{
if (_isRunning)
{
return;
}
eLeapRS result;
if (_leapConnection == IntPtr.Zero)
{
if (ConnectionKey.serverNamespace == null)
{
result = LeapC.CreateConnection(out _leapConnection);
}
else
{
LEAP_CONNECTION_CONFIG config = new LEAP_CONNECTION_CONFIG();
config.size = (uint)Marshal.SizeOf(config);
config.flags = 0;
config.server_namespace = Marshal.StringToHGlobalAnsi(ConnectionKey.serverNamespace);
result = LeapC.CreateConnection(ref config, out _leapConnection);
Marshal.FreeHGlobal(config.server_namespace);
}
if (result != eLeapRS.eLeapRS_Success || _leapConnection == IntPtr.Zero)
{
reportAbnormalResults("LeapC CreateConnection call was ", result);
return;
}
}
result = LeapC.OpenConnection(_leapConnection);
if (result != eLeapRS.eLeapRS_Success)
{
reportAbnormalResults("LeapC OpenConnection call was ", result);
return;
}
// The Allocator must persist the lifetime of the connection
if (_pLeapAllocator.allocate == null)
{
_pLeapAllocator.allocate = MemoryManager.Pin;
}
if (_pLeapAllocator.deallocate == null)
{
_pLeapAllocator.deallocate = MemoryManager.Unpin;
}
LeapC.SetAllocator(_leapConnection, ref _pLeapAllocator);
_isRunning = true;
AppDomain.CurrentDomain.DomainUnload += (arg1, arg2) => Dispose(true);
_polster = new Thread(new ThreadStart(this.processMessages));
_polster.Name = "LeapC Worker";
_polster.IsBackground = true;
_polster.Start();
}
public void Start()
{
if (!_isRunning)
{
if (_leapConnection == IntPtr.Zero)
{
eLeapRS result = LeapC.CreateConnection(out _leapConnection);
reportAbnormalResults("LeapC CreateConnection call was ", result);
result = LeapC.OpenConnection(_leapConnection);
reportAbnormalResults("LeapC OpenConnection call was ", result);
}
_isRunning = true;
_polster = new Thread(new ThreadStart(this.processMessages));
_polster.IsBackground = true;
_polster.Start();
}
}
//Run in Polster thread, fills in object queues
private void processMessages()
{
try
{
eLeapRS result;
LeapInit.Dispatch <LeapEventArgs>(this, new LeapEventArgs(LeapEvent.EVENT_INIT));
while (_isRunning)
{
if (_leapConnection != IntPtr.Zero)
{
LEAP_CONNECTION_MESSAGE _msg = new LEAP_CONNECTION_MESSAGE();
uint timeout = 1000;
result = LeapC.PollConnection(_leapConnection, timeout, ref _msg);
reportAbnormalResults("LeapC PollConnection call was ", result);
if (result == eLeapRS.eLeapRS_Success)
{
switch (_msg.type)
{
case eLeapEventType.eLeapEventType_Connection:
LEAP_CONNECTION_EVENT connection_evt = LeapC.PtrToStruct <LEAP_CONNECTION_EVENT>(_msg.eventStructPtr);
handleConnection(ref connection_evt);
break;
case eLeapEventType.eLeapEventType_ConnectionLost:
LEAP_CONNECTION_LOST_EVENT connection_lost_evt = LeapC.PtrToStruct <LEAP_CONNECTION_LOST_EVENT>(_msg.eventStructPtr);
handleConnectionLost(ref connection_lost_evt);
break;
case eLeapEventType.eLeapEventType_Device:
LEAP_DEVICE_EVENT device_evt = LeapC.PtrToStruct <LEAP_DEVICE_EVENT>(_msg.eventStructPtr);
handleDevice(ref device_evt);
break;
case eLeapEventType.eLeapEventType_DeviceLost:
LEAP_DEVICE_EVENT device_lost_evt = LeapC.PtrToStruct <LEAP_DEVICE_EVENT>(_msg.eventStructPtr);
handleLostDevice(ref device_lost_evt);
break;
case eLeapEventType.eLeapEventType_DeviceFailure:
LEAP_DEVICE_FAILURE_EVENT device_failure_evt = LeapC.PtrToStruct <LEAP_DEVICE_FAILURE_EVENT>(_msg.eventStructPtr);
handleFailedDevice(ref device_failure_evt);
break;
case eLeapEventType.eLeapEventType_Tracking:
LEAP_TRACKING_EVENT tracking_evt = LeapC.PtrToStruct <LEAP_TRACKING_EVENT>(_msg.eventStructPtr);
handleTrackingMessage(ref tracking_evt);
break;
case eLeapEventType.eLeapEventType_ImageComplete:
completeCount++;
LEAP_IMAGE_COMPLETE_EVENT image_complete_evt = LeapC.PtrToStruct <LEAP_IMAGE_COMPLETE_EVENT>(_msg.eventStructPtr);
handleImageCompletion(ref image_complete_evt);
break;
case eLeapEventType.eLeapEventType_ImageRequestError:
failedCount++;
LEAP_IMAGE_FRAME_REQUEST_ERROR_EVENT failed_image_evt = LeapC.PtrToStruct <LEAP_IMAGE_FRAME_REQUEST_ERROR_EVENT>(_msg.eventStructPtr);
handleFailedImageRequest(ref failed_image_evt);
break;
case eLeapEventType.eLeapEventType_TrackedQuad:
LEAP_TRACKED_QUAD_EVENT quad_evt = LeapC.PtrToStruct <LEAP_TRACKED_QUAD_EVENT>(_msg.eventStructPtr);
handleQuadMessage(ref quad_evt);
break;
case eLeapEventType.eLeapEventType_LogEvent:
LEAP_LOG_EVENT log_evt = LeapC.PtrToStruct <LEAP_LOG_EVENT>(_msg.eventStructPtr);
reportLogMessage(ref log_evt);
break;
case eLeapEventType.eLeapEventType_PolicyChange:
LEAP_POLICY_EVENT policy_evt = LeapC.PtrToStruct <LEAP_POLICY_EVENT>(_msg.eventStructPtr);
handlePolicyChange(ref policy_evt);
break;
case eLeapEventType.eLeapEventType_ConfigChange:
LEAP_CONFIG_CHANGE_EVENT config_change_evt = LeapC.PtrToStruct <LEAP_CONFIG_CHANGE_EVENT>(_msg.eventStructPtr);
handleConfigChange(ref config_change_evt);
break;
case eLeapEventType.eLeapEventType_ConfigResponse:
handleConfigResponse(ref _msg);
break;
default:
//discard unknown message types
Logger.Log("Unhandled message type " + Enum.GetName(typeof(eLeapEventType), _msg.type));
break;
} //switch on _msg.type
} // if valid _msg.type
else if (result == eLeapRS.eLeapRS_NotConnected)
{
this.LeapConnectionLost.Dispatch <ConnectionLostEventArgs>(this, new ConnectionLostEventArgs());
result = LeapC.CreateConnection(out _leapConnection);
reportAbnormalResults("LeapC CreateConnection call was ", result);
result = LeapC.OpenConnection(_leapConnection);
reportAbnormalResults("LeapC OpenConnection call was ", result);
}
} // if have connection handle
} //while running
}
catch (Exception e)
{
Logger.Log("Exception: " + e);
}
}
