private void UpdateProximityStateToConnection(PLTProximityType proximitytype) { lock (m_lastproximitystateLock) { m_lastproximitystate.m_proximity = proximitytype; } if (m_activeConnection != null) // todo only do this if subscribed to relevant service? { PLTServiceSubscription subscr = m_activeConnection.getSubscription(PLTService.PROXIMITY_SVC); if (subscr != null) { lock (m_lastproximitystateLock) { subscr.LastData = m_lastproximitystate; } // if it is an on change subscription, beam to connected app now // otherwise will happen in the PLTConnection's periodic timer if (subscr.m_mode == PLTMode.On_Change) { m_callbackhandler.infoUpdated(m_activeConnection, new PLTInfo(PLTService.PROXIMITY_SVC, subscr.LastData)); } } } }
private void UpdateWearingStateToConnection(WearingStateArgs e) { lock (m_lastwornstateLock) { m_lastwornstate.m_worn = e.m_worn; m_lastwornstate.m_isInitialStateEvent = e.m_isInitialStateEvent; } if (m_activeConnection != null) // todo only do this if subscribed to relevant service? { PLTServiceSubscription subscr = m_activeConnection.getSubscription(PLTService.WEARING_STATE_SVC); if (subscr != null) { lock (m_lastwornstateLock) { subscr.LastData = m_lastwornstate; } // if it is an on change subscription, beam to connected app now // otherwise will happen in the PLTConnection's periodic timer if (subscr.m_mode == PLTMode.On_Change) { m_callbackhandler.infoUpdated(m_activeConnection, new PLTInfo(PLTService.WEARING_STATE_SVC, subscr.LastData)); } } } }
void m_spokes_BatteryLevelChanged(object sender, EventArgs e) { if (m_headsetinrange) { Interop.Plantronics.DeviceBatteryLevel batlev = m_spokes.GetBatteryLevel(); lock (m_lastbattstateLock) { m_lastbattstate.m_batterylevel = (PLTBatteryLevel)batlev; } if (m_activeConnection != null) // todo only do this if subscribed to relevant service? { PLTServiceSubscription subscr = m_activeConnection.getSubscription(PLTService.CHARGESTATE_SVC); if (subscr != null) { lock (m_lastwornstateLock) { subscr.LastData = m_lastbattstate; } // if it is an on change subscription, beam to connected app now // otherwise will happen in the PLTConnection's periodic timer if (subscr.m_mode == PLTMode.On_Change) { m_callbackhandler.infoUpdated(m_activeConnection, new PLTInfo(PLTService.CHARGESTATE_SVC, subscr.LastData)); } } } } }
private void UpdateMobileCallerIdToConnection(string mobilecallid) { lock (m_lastcalleridLock) { m_lastcallerid.m_calltype = PLTCallerIdType.Mobile; // only this supported at present m_lastcallerid.m_callerid = mobilecallid; } if (m_activeConnection != null) // todo only do this if subscribed to relevant service? { PLTServiceSubscription subscr = m_activeConnection.getSubscription(PLTService.CALLERID_SVC); if (subscr != null) { lock (m_lastcalleridLock) { subscr.LastData = m_lastcallerid; } // if it is an on change subscription, beam to connected app now // otherwise will happen in the PLTConnection's periodic timer if (subscr.m_mode == PLTMode.On_Change) { m_callbackhandler.infoUpdated(m_activeConnection, new PLTInfo(PLTService.CALLERID_SVC, subscr.LastData)); } } } }
private void UpdateCallStateToConnection(PLTCallStateType calltype, PLTCallState callstate, int callid = 0, string callsource = "", bool incoming = false) { lock (m_lastcallstateLock) { m_lastcallstate.m_callstatetype = calltype; m_lastcallstate.m_callstate = callstate; m_lastcallstate.m_callid = callid; m_lastcallstate.m_callsource = callsource; m_lastcallstate.m_incoming = incoming; } if (m_activeConnection != null) // todo only do this if subscribed to relevant service? { PLTServiceSubscription subscr = m_activeConnection.getSubscription(PLTService.CALLSTATE_SVC); if (subscr != null) { lock (m_lastcallstateLock) { subscr.LastData = m_lastcallstate; } // if it is an on change subscription, beam to connected app now // otherwise will happen in the PLTConnection's periodic timer if (subscr.m_mode == PLTMode.On_Change) { m_callbackhandler.infoUpdated(m_activeConnection, new PLTInfo(PLTService.CALLSTATE_SVC, subscr.LastData)); } } } }
private void UpdateDockedStateToConnection(bool docked, bool initial) { lock (m_lastdockstateLock) { m_lastdockstate.m_isdocked = docked; m_lastdockstate.m_isinitialstatus = initial; } if (m_activeConnection != null) // todo only do this if subscribed to relevant service? { PLTServiceSubscription subscr = m_activeConnection.getSubscription(PLTService.DOCKSTATE_SVC); if (subscr != null) { lock (m_lastdockstateLock) { subscr.LastData = m_lastdockstate; } // if it is an on change subscription, beam to connected app now // otherwise will happen in the PLTConnection's periodic timer if (subscr.m_mode == PLTMode.On_Change) { m_callbackhandler.infoUpdated(m_activeConnection, new PLTInfo(PLTService.DOCKSTATE_SVC, subscr.LastData)); } } } }
internal PLTServiceSubscription getSubscription(PLTService pLTService) { PLTServiceSubscription retval = null; lock (m_subscribedServicesLock) { foreach (PLTServiceSubscription subscr in m_subscribedServices) { if (subscr.m_service == pLTService) { retval = subscr; break; } } } return(retval); }
internal void subscribe(PLTService aService, PLTMode aMode, int aPeriodmilliseconds = 0) { // cannot subscribe to same service twice if (isSubscribed(aService)) { return; } bool doSubscribe = false; object lastData = null; // work out if we can/should subscribe to the service switch (aService) { case PLTService.MOTION_TRACKING_SVC: // TODO add to Spokes knowledge of which device // has motion tracking. For now just assume all // devices do. doSubscribe = true; break; case PLTService.MOTION_STATE_SVC: // TODO: does the headset provide this info? throw new Exception("Sorry, motion state service is not yet implemented."); doSubscribe = false; break; case PLTService.SENSOR_CAL_STATE_SVC: doSubscribe = true; break; case PLTService.PEDOMETER_SVC: doSubscribe = true; break; case PLTService.TAP_SVC: if (aMode == PLTMode.On_Change) { doSubscribe = true; } else { throw new Exception("Sorry, tap service only supports PLTMode.On_Change mode (not PLTMode.Periodic)."); } break; case PLTService.WEARING_STATE_SVC: if (m_spokes.DeviceCapabilities.HasWearingSensor) { doSubscribe = true; lock (m_pltlabsapi.m_lastwornstateLock) { lastData = m_pltlabsapi.m_lastwornstate; } } else { throw new Exception("Sorry, device does not have a wearing sensor. Unable to subscribe to wearing sensor data."); } break; case PLTService.FREE_FALL_SVC: if (aMode == PLTMode.On_Change) { doSubscribe = true; } else { throw new Exception("Sorry, tap service only supports PLTMode.On_Change mode (not PLTMode.Periodic)."); } break; case PLTService.PROXIMITY_SVC: // Don't bother checking m_spokes.DeviceCapabilities.HasProximity, as this is // generally populated with correct value later asyncronously if enable proximity call // succeeded doSubscribe = true; lock (m_pltlabsapi.m_lastproximitystateLock) { lastData = m_pltlabsapi.m_lastproximitystate; } break; case PLTService.CALLERID_SVC: doSubscribe = true; lock (m_pltlabsapi.m_lastcalleridLock) { lastData = m_pltlabsapi.m_lastcallerid; } break; case PLTService.CALLSTATE_SVC: if (aMode == PLTMode.On_Change) { doSubscribe = true; lock (m_pltlabsapi.m_lastcallstateLock) { lastData = m_pltlabsapi.m_lastcallstate; } } else { throw new Exception("Sorry, call state only supports PLTMode.On_Change mode (not PLTMode.Periodic)."); } break; case PLTService.DOCKSTATE_SVC: doSubscribe = true; lock (m_pltlabsapi.m_lastdockstateLock) { lastData = m_pltlabsapi.m_lastdockstate; } break; case PLTService.CHARGESTATE_SVC: // todo consider not making wireless devices subcribe - no battery doSubscribe = true; lock (m_pltlabsapi.m_lastbattstateLock) { lastData = m_pltlabsapi.m_lastbattstate; } break; //case PLTService.TEMPERATURE_SVC: // doSubscribe = true; // break; } if (doSubscribe) { PLTServiceSubscription subscr; subscr = new PLTServiceSubscription(this, aService, aMode, aPeriodmilliseconds, lastData); lock (m_subscribedServicesLock) { m_subscribedServices.Add(subscr); } // NOTE: for SOME services we want to ship the last known value right // away to connected app, because for those services such as wearing sensor // the last known value will be the "initial" value. (Does not apply to // headtracking). if (aService == PLTService.WEARING_STATE_SVC || aService == PLTService.CHARGESTATE_SVC ) { ShipLastKnownDataToAppForService(aService, subscr); } } }
// a periodic service subscription timer has fired // ship the last known data to the connected app internal void ServiceTimerElapsed(PLTService aService, PLTServiceSubscription aSubscription, object lastSubscriptionData) { ShipLastKnownDataToAppForService(aService, aSubscription); }
// Pass lastSubscriptionData to contain reference to last value for this subscription // or NULL where no value is available (for instance with wearing sensor before // a subcription has been made). private void ShipLastKnownDataToAppForService(PLTService aService, PLTServiceSubscription aSubscription) { if (m_pltlabsapi. m_callbackhandler != null && m_pltlabsapi.m_activeConnection != null && aSubscription != null) { // now work out if we should send the last known value (applies to some services // e.g. wearing sensor, so app can receive initial value) switch (aService) { case PLTService.MOTION_TRACKING_SVC: m_pltlabsapi. m_callbackhandler.infoUpdated( m_pltlabsapi.m_activeConnection, new PLTInfo(aService, (PLTMotionTrackingData)aSubscription.LastData)); break; case PLTService.MOTION_STATE_SVC: m_pltlabsapi. m_callbackhandler.infoUpdated( m_pltlabsapi.m_activeConnection, new PLTInfo(aService, (PLTMoving)aSubscription.LastData)); break; case PLTService.SENSOR_CAL_STATE_SVC: m_pltlabsapi. m_callbackhandler.infoUpdated( m_pltlabsapi.m_activeConnection, new PLTInfo(aService, (PLTSensorCal)aSubscription.LastData)); break; case PLTService.PEDOMETER_SVC: m_pltlabsapi. m_callbackhandler.infoUpdated( m_pltlabsapi.m_activeConnection, new PLTInfo(aService, (PLTPedometerCount)aSubscription.LastData)); break; case PLTService.TAP_SVC: m_pltlabsapi. m_callbackhandler.infoUpdated( m_pltlabsapi.m_activeConnection, new PLTInfo(aService, (PLTTapInfo)aSubscription.LastData)); break; case PLTService.WEARING_STATE_SVC: m_pltlabsapi. m_callbackhandler.infoUpdated( m_pltlabsapi.m_activeConnection, new PLTInfo(aService, (PLTWearingState)aSubscription.LastData)); break; case PLTService.FREE_FALL_SVC: m_pltlabsapi. m_callbackhandler.infoUpdated( m_pltlabsapi.m_activeConnection, new PLTInfo(aService, (PLTFreeFall)aSubscription.LastData)); break; case PLTService.PROXIMITY_SVC: m_pltlabsapi. m_callbackhandler.infoUpdated( m_pltlabsapi.m_activeConnection, new PLTInfo(aService, (PLTProximityType)aSubscription.LastData)); break; case PLTService.CALLERID_SVC: m_pltlabsapi. m_callbackhandler.infoUpdated( m_pltlabsapi.m_activeConnection, new PLTInfo(aService, (PLTCallerId)aSubscription.LastData)); break; case PLTService.CALLSTATE_SVC: m_pltlabsapi. m_callbackhandler.infoUpdated( m_pltlabsapi.m_activeConnection, new PLTInfo(aService, (PLTCallStateInfo)aSubscription.LastData)); break; case PLTService.DOCKSTATE_SVC: m_pltlabsapi. m_callbackhandler.infoUpdated( m_pltlabsapi.m_activeConnection, new PLTInfo(aService, (PLTDock)aSubscription.LastData)); break; case PLTService.CHARGESTATE_SVC: m_pltlabsapi.m_callbackhandler.infoUpdated( m_pltlabsapi.m_activeConnection, new PLTInfo(aService, (PLTBatteryState)aSubscription.LastData)); break; //case PLTService.TEMPERATURE_SVC: // m_pltlabsapi. // m_callbackhandler.infoUpdated( // m_pltlabsapi.m_activeConnection, new PLTInfo(aService, (PLTTemperature)aSubscription.LastData)); // break; } } }
/// <summary> /// This is a method used by the internals of the PLTLabsAPI DLL to receive /// Motion Tracking events from the headset and then distribute them to /// applications that are subscribed to those data services. /// *** DO NOT CALL THIS METHOD *** /// </summary> /// <param name="headsetData">The data received from headset *** DO NOT CALL THIS METHOD ***</param> public void HeadsetTrackingUpdate(HeadsetTrackingData headsetData) { // todo, if registered for various services (headtracking, pedometer etc ) // then send back the data to the infoUpdated callback!!! if (m_activeConnection != null) // todo only do this if subscribed to relevant service? { m_activeConnection.vermaj = headsetData.vermaj; m_activeConnection.vermin = headsetData.vermin; // MOTION_TRACKING_SVC data for motion tracking service... PLTServiceSubscription subscr = m_activeConnection.getSubscription(PLTService.MOTION_TRACKING_SVC); if (subscr != null) { PLTMotionTrackingData data = new PLTMotionTrackingData(); data.m_rawreport = headsetData.rawreport; // avoid NaN conditions! if (Double.IsNaN(headsetData.psi_heading)) { headsetData.psi_heading = 0.0; } if (Double.IsNaN(headsetData.theta_pitch)) { headsetData.theta_pitch = 0.0; } if (Double.IsNaN(headsetData.phi_roll)) { headsetData.phi_roll = 0.0; } data.m_orientation[0] = headsetData.psi_heading; data.m_orientation[1] = headsetData.theta_pitch; data.m_orientation[2] = headsetData.phi_roll; data.m_calquaternion[0] = headsetData.quatcalib_q0; data.m_calquaternion[1] = headsetData.quatcalib_q1; data.m_calquaternion[2] = headsetData.quatcalib_q2; data.m_calquaternion[3] = headsetData.quatcalib_q3; data.m_rawquaternion[0] = headsetData.quatraw_q0; data.m_rawquaternion[1] = headsetData.quatraw_q1; data.m_rawquaternion[2] = headsetData.quatraw_q2; data.m_rawquaternion[3] = headsetData.quatraw_q3; // tell app what the quaternion processing config was: data.m_format_config = QuaternionProcessor.m_doCalibrate ? PLTConfiguration.MotionSvc_Offset_Calibrated : PLTConfiguration.MotionSvc_Offset_Raw; data.m_offset_config = QuaternionProcessor.m_doOrientation ? PLTConfiguration.MotionSvc_Format_Orientation : PLTConfiguration.MotionSvc_Format_Quaternion; subscr.LastData = data; if (subscr.m_mode == PLTMode.On_Change) { m_callbackhandler.infoUpdated(m_activeConnection, new PLTInfo(PLTService.MOTION_TRACKING_SVC, data)); } } // MOTION_STATE_SVC // TODO: I don't think this data is available // SENSOR_CAL_STATE_SVC data for sensor cal state service... subscr = m_activeConnection.getSubscription(PLTService.SENSOR_CAL_STATE_SVC); if (subscr != null) { PLTSensorCal data = new PLTSensorCal(); data.m_isgyrocal = headsetData.gyrocalib == 3; data.m_ismagnetometercal = headsetData.magnetometercalib == 3; subscr.LastData = data; if (subscr.m_mode == PLTMode.On_Change) { m_callbackhandler.infoUpdated(m_activeConnection, new PLTInfo(PLTService.SENSOR_CAL_STATE_SVC, data)); } } // PEDOMETER_SVC subscr = m_activeConnection.getSubscription(PLTService.PEDOMETER_SVC); if (subscr != null) { PLTPedometerCount data = new PLTPedometerCount(); data.m_pedometercount = headsetData.pedometersteps; subscr.LastData = data; if (subscr.m_mode == PLTMode.On_Change) { m_callbackhandler.infoUpdated(m_activeConnection, new PLTInfo(PLTService.PEDOMETER_SVC, data)); } } // TAP_SVC subscr = m_activeConnection.getSubscription(PLTService.TAP_SVC); if (subscr != null) { PLTTapInfo data = new PLTTapInfo(); data.m_tapcount = headsetData.taps; data.m_tapdirection = (PLTTapDirection)headsetData.tapdir; subscr.LastData = data; if (subscr.m_mode == PLTMode.On_Change) { m_callbackhandler.infoUpdated(m_activeConnection, new PLTInfo(PLTService.TAP_SVC, data)); } } // FREE_FALL_SVC subscr = m_activeConnection.getSubscription(PLTService.FREE_FALL_SVC); if (subscr != null) { PLTFreeFall data = new PLTFreeFall(); data.m_isinfreefall = headsetData.freefall; subscr.LastData = data; if (subscr.m_mode == PLTMode.On_Change) { m_callbackhandler.infoUpdated(m_activeConnection, new PLTInfo(PLTService.FREE_FALL_SVC, data)); } } //// TEMPERATURE_SVC //subscr = // m_activeConnection.getSubscription(PLTService.TEMPERATURE_SVC); //if (subscr != null) //{ // PLTTemperature data = new PLTTemperature(); // data.m_temperature = headsetData.temperature; // subscr.LastData = data; // if (subscr.m_mode == PLTMode.On_Change) // { // m_callbackhandler.infoUpdated(m_activeConnection, new PLTInfo(PLTService.TEMPERATURE_SVC, data)); // } //} } }