Example #1
0
 private void PollForDeviceConfig()
 {
     if (WaitingForDeviceConfig)
     {
                         #if UNITY_EDITOR
         bool complete = WearableUSBHasReceivedDeviceConfiguration();
         if (complete)
         {
             USBDeviceConfiguration config = WearableUSBGetDeviceConfiguration();
             _config.updateInterval                = WearableTools.MillisecondsToClosestSensorUpdateInterval(config.intervalMilliseconds);
             _config.accelerometer.isEnabled       = config.sensorAccelerometer != 0;
             _config.gyroscope.isEnabled           = config.sensorGyroscope != 0;
             _config.rotationNineDof.isEnabled     = config.sensorRotationNineDof != 0;
             _config.rotationSixDof.isEnabled      = config.sensorRotationSixDof != 0;
             _config.headNodGesture.isEnabled      = config.gestureHeadNod != 0;
             _config.headShakeGesture.isEnabled    = config.gestureHeadShake != 0;
             _config.doubleTapGesture.isEnabled    = config.gestureDoubleTap != 0;
             _config.touchAndHoldGesture.isEnabled = config.gestureTouchAndHold != 0;
             _config.inputGesture.isEnabled        = config.gestureInput != 0;
             _config.affirmativeGesture.isEnabled  = config.gestureAffirmative != 0;
             _config.negativeGesture.isEnabled     = config.gestureNegative != 0;
             OnReceivedDeviceConfiguration(_config.Clone());
         }
                         #endif
     }
 }
Example #2
0
        internal override void OnUpdate()
        {
            if (!_enabled)
            {
                return;
            }

            // Clear the current frames; _lastSensorFrame will retain its previous value.
            if (_currentSensorFrames.Count > 0)
            {
                _currentSensorFrames.Clear();
            }

            if (_connectedDevice == null)
            {
                return;
            }

            while (Time.unscaledTime >= _nextSensorUpdateTime)
            {
                // If it's time to emit frames, do so until we have caught up.
                float deltaTime = WearableTools.SensorUpdateIntervalToSeconds(_sensorUpdateInterval);
                _nextSensorUpdateTime += deltaTime;


                bool anySensorsEnabled = false;

                // Update all active sensors
                if (_sensorStatus[SensorId.Accelerometer])
                {
                    UpdateAccelerometerData();
                    anySensorsEnabled = true;
                }

                if (_sensorStatus[SensorId.Gyroscope])
                {
                    UpdateGyroscopeData();
                    anySensorsEnabled = true;
                }

                if (_sensorStatus[SensorId.Rotation])
                {
                    UpdateRotationSensorData();
                    anySensorsEnabled = true;
                }

                // Emit a gesture if needed
                bool gestureEmitted = UpdateGestureData();

                if (anySensorsEnabled || gestureEmitted)
                {
                    // Update the timestamp and delta-time and emit
                    _lastSensorFrame.deltaTime = deltaTime;
                    _lastSensorFrame.timestamp = _nextSensorUpdateTime;

                    _currentSensorFrames.Add(_lastSensorFrame);
                    OnSensorsOrGestureUpdated(_lastSensorFrame);
                }
            }
        }
Example #3
0
        static WearableConstants()
        {
            // Ensure that empty frame has a valid rotation quaternion
            EMPTY_FRAME = new SensorFrame
            {
                rotationNineDof = new SensorQuaternion {
                    value = Quaternion.identity
                },
                rotationSixDof = new SensorQuaternion {
                    value = Quaternion.identity
                }
            };

            CONNECTING_STATES = new List <ConnectionStatus>
            {
                ConnectionStatus.FirmwareUpdateRequired,
                ConnectionStatus.FirmwareUpdateAvailable,
                ConnectionStatus.Connecting,
                ConnectionStatus.AutoReconnect,
                ConnectionStatus.SecurePairingRequired
            };

            EMPTY_DEVICE_LIST = new Device[0];

            GESTURE_IDS                        = (GestureId[])Enum.GetValues(typeof(GestureId));
            SENSOR_IDS                         = (SensorId[])Enum.GetValues(typeof(SensorId));
            UPDATE_INTERVALS                   = (SensorUpdateInterval[])Enum.GetValues(typeof(SensorUpdateInterval));
            SIGNAL_STRENGTHS                   = (SignalStrength[])Enum.GetValues(typeof(SignalStrength));
            ACTIVE_NOISE_REDUCTION_MODES       = (ActiveNoiseReductionMode[])Enum.GetValues(typeof(ActiveNoiseReductionMode));
            EMPTY_ACTIVE_NOISE_REDUCTION_MODES = new ActiveNoiseReductionMode[0];
            DEVICE_STATUS_FLAGS                = (DeviceStatusFlags[])Enum.GetValues(typeof(DeviceStatusFlags));
            OS_PERMISSIONS                     = (OSPermission[])Enum.GetValues(typeof(OSPermission));
            OS_SERVICES                        = (OSService[])Enum.GetValues(typeof(OSService));

            DISABLED_DEVICE_CONFIG = new WearableDeviceConfig();
            DISABLED_DEVICE_CONFIG.DisableAllSensors();
            DISABLED_DEVICE_CONFIG.DisableAllGestures();

                        #pragma warning disable 618
            DISALLOWED_EDITOR_PROVIDERS  = new[] { ProviderId.BluetoothProvider };
            DISALLOWED_RUNTIME_PROVIDERS = new[] { ProviderId.USBProvider };
                        #pragma warning restore 618

            DEBUG_PROVIDER_DEFAULT_AVAILABLE_ANR_MODES = new[] {
                ActiveNoiseReductionMode.Off,
                ActiveNoiseReductionMode.Low,
                ActiveNoiseReductionMode.High
            };

            EMPTY_DEVICE_STATUS       = new DeviceStatus();
            EMPTY_DYNAMIC_DEVICE_INFO = new DynamicDeviceInfo
            {
                transmissionPeriod                       = -1,
                activeNoiseReductionMode                 = ActiveNoiseReductionMode.Invalid,
                availableActiveNoiseReductionModes       = WearableTools.GetActiveNoiseReductionModesAsInt(EMPTY_ACTIVE_NOISE_REDUCTION_MODES),
                controllableNoiseCancellationLevel       = 0,
                controllableNoiseCancellationEnabled     = false,
                totalControllableNoiseCancellationLevels = 0
            };
        }
Example #4
0
        internal override void SetDeviceConfiguration(WearableDeviceConfig config)
        {
                        #if UNITY_EDITOR
            USBDeviceConfiguration deviceConfig = new USBDeviceConfiguration
            {
                intervalMilliseconds  = (int)WearableTools.SensorUpdateIntervalToMilliseconds(config.updateInterval),
                sensorRotationNineDof = config.rotationNineDof.isEnabled ? 1 : 0,
                sensorRotationSixDof  = config.rotationSixDof.isEnabled ? 1 : 0,
                sensorGyroscope       = config.gyroscope.isEnabled ? 1 : 0,
                sensorAccelerometer   = config.accelerometer.isEnabled ? 1 : 0,
                gestureHeadNod        = config.headNodGesture.isEnabled ? 1 : 0,
                gestureHeadShake      = config.headShakeGesture.isEnabled ? 1 : 0,
                gestureDoubleTap      = config.doubleTapGesture.isEnabled ? 1 : 0,
                gestureTouchAndHold   = config.touchAndHoldGesture.isEnabled ? 1 : 0,
                gestureInput          = config.inputGesture.isEnabled ? 1 : 0,
                gestureAffirmative    = config.affirmativeGesture.isEnabled ? 1 : 0,
                gestureNegative       = config.negativeGesture.isEnabled ? 1 : 0
            };

            WearableUSBSetDeviceConfiguration(deviceConfig);
                        #endif

            // Assume the configuration succeeded, because it generally will. Failed configs will show up when we poll
            // for status flags, and adjust the internal config as necessary.
            _config = config.Clone();
        }
        internal override void SetSensorUpdateInterval(SensorUpdateInterval updateInterval)
        {
            if (_connectedDevice == null)
            {
                Debug.LogWarning(WearableConstants.SetUpdateRateWithoutDeviceWarning);
                return;
            }

            _sensorUpdateInterval = updateInterval;

            // n.b. currently, the only way to set the global update interval is along with a call to EnableSensor.
            // Until a method is added for this, a suitable workaround is to call EnableSensor on a sensor that is
            // already enabled. If no sensors are enabled, the cached value will of _sensorUpdateInterval will be
            // used the next time a sensor is enabled.
                        #if UNITY_EDITOR
            var enumerator = _sensorStatus.GetEnumerator();
            try
            {
                while (enumerator.MoveNext())
                {
                    KeyValuePair <SensorId, bool> element = enumerator.Current;
                    if (element.Value)
                    {
                        int milliseconds = (int)WearableTools.SensorUpdateIntervalToMilliseconds(_sensorUpdateInterval);
                        WearableUSBEnableSensor((int)element.Key, milliseconds);
                    }
                }
            }
            finally
            {
                enumerator.Dispose();
            }
                        #endif // UNITY_EDITOR
        }
Example #6
0
        private USBAppIntentProfile MakeUSBProfile(AppIntentProfile appIntentProfile)
        {
            USBAppIntentProfile usbProfile = new USBAppIntentProfile();

            if (appIntentProfile != null)
            {
                // Sensors
                usbProfile.sensorBitmask = 0;
                for (int i = 0; i < WearableConstants.SensorIds.Length; i++)
                {
                    SensorId sensor = WearableConstants.SensorIds[i];

                    // Does this profile require this sensor?
                    if (appIntentProfile.GetSensorInProfile(sensor))
                    {
                        SensorFlags sensorBit = WearableTools.GetSensorFlag(sensor);
                        usbProfile.sensorBitmask |= (int)sensorBit;
                    }
                }

                // Gestures
                usbProfile.gestureBitmask = 0;
                for (int i = 0; i < WearableConstants.GestureIds.Length; i++)
                {
                    GestureId gesture = WearableConstants.GestureIds[i];

                    // Does this profile require this gesture?
                    if (appIntentProfile.GetGestureInProfile(gesture))
                    {
                        GestureFlags gestureBit = WearableTools.GetGestureFlag(gesture);
                        usbProfile.gestureBitmask |= (int)gestureBit;
                    }
                }

                usbProfile.updateIntervalBitmask = 0;
                for (int i = 0; i < WearableConstants.UpdateIntervals.Length; i++)
                {
                    SensorUpdateInterval interval = WearableConstants.UpdateIntervals[i];

                    // Does this profile require this update interval?
                    if (appIntentProfile.GetIntervalInProfile(interval))
                    {
                        int intervalBit = WearableTools.SensorUpdateIntervalToBit(interval);
                        usbProfile.updateIntervalBitmask |= intervalBit;
                    }
                }
            }

            return(usbProfile);
        }
        internal override void OnUpdate()
        {
            if (!_enabled)
            {
                return;
            }

            if (Time.unscaledTime >= _nextSensorUpdateTime)
            {
                _nextSensorUpdateTime += WearableTools.SensorUpdateIntervalToSeconds(_sensorUpdateInterval);

                // Update all active sensors
                if (_sensorStatus[SensorId.Accelerometer])
                {
                    UpdateAccelerometerData();
                }

                if (_sensorStatus[SensorId.Gyroscope])
                {
                    UpdateGyroscopeData();
                }

                if (_sensorStatus[SensorId.Rotation] || _sensorStatus[SensorId.GameRotation])
                {
                    UpdateRotationSensorData();
                }

                UpdateGestureData();

                // Update the timestamp and delta-time, then emit the frame
                _lastSensorFrame.deltaTime = Time.unscaledTime - _lastSensorFrame.timestamp;
                _lastSensorFrame.timestamp = Time.unscaledTime;

                _currentSensorFrames.Clear();
                _currentSensorFrames.Add(_lastSensorFrame);
                OnSensorsUpdated(_lastSensorFrame);
            }
            else
            {
                // Otherwise, the list should be empty. _lastSensorFrame will retain its previous value.
                if (_currentSensorFrames.Count > 0)
                {
                    _currentSensorFrames.Clear();
                }
            }
        }
        internal override void StartSensor(SensorId sensorId)
        {
            if (_connectedDevice == null)
            {
                _sensorStatus[sensorId] = false;
                Debug.LogWarning(WearableConstants.StartSensorWithoutDeviceWarning);
                return;
            }

            if (_sensorStatus[sensorId])
            {
                return;
            }

                        #if UNITY_EDITOR
            int milliseconds = (int)WearableTools.SensorUpdateIntervalToMilliseconds(_sensorUpdateInterval);
            WearableUSBEnableSensor((int)sensorId, milliseconds);
                        #endif // UNITY_EDITOR

            _sensorStatus[sensorId] = true;
        }
Example #9
0
 /// <summary>
 /// Get a list of <see cref="ActiveNoiseReductionMode"/>s supported by the device. An empty list will be
 /// returned if the feature is not supported.
 /// </summary>
 /// <returns></returns>
 public                          ActiveNoiseReductionMode[] GetAvailableActiveNoiseReductionModes()
 {
     return(WearableTools.GetActiveNoiseReductionModesAsList(availableActiveNoiseReductionModes));
 }
Example #10
0
        internal override void OnUpdate()
        {
            UpdateVirtualDeviceInfo();

            // Report found devices if searching.
            if (_searchingForDevice && Time.unscaledTime >= _nextDeviceSearchUpdateTime)
            {
                _nextDeviceSearchUpdateTime += WearableConstants.DeviceSearchUpdateIntervalInSeconds;

                if (_verbose)
                {
                    Debug.Log(WearableConstants.DebugProviderFoundDevices);
                }

                var devices = new[] { _virtualDevice };

                OnReceivedSearchDevices(devices);
            }

            // Handle connection states
            if (_connectionPhase != ConnectionPhase.Idle &&
                Time.unscaledTime >= _nextConnectionStateTime)
            {
                PerformDeviceConnection();
            }

            // Clear the current frames; _lastSensorFrame will retain its previous value.
            _currentSensorFrames.Clear();
            _currentGestureData.Clear();

            if (_connectedDevice.HasValue)
            {
                // Configuration status
                if (_waitingToSendConfigSuccess && Time.unscaledTime >= _sendConfigSuccessTime)
                {
                    _waitingToSendConfigSuccess = false;
                    OnConfigurationSucceeded();
                }

                if (_waitingToSendConfigFailure && Time.unscaledTime >= _sendConfigFailureTime)
                {
                    _waitingToSendConfigFailure = false;
                    OnConfigurationFailed(ConfigStatus.Failure, ConfigStatus.Failure);
                }

                // Device configuration requests
                if (_waitingToSendConfigRequestResponse && Time.unscaledTime >= _sendConfigRequestResponseTime)
                {
                    _waitingToSendConfigRequestResponse = false;
                    OnReceivedDeviceConfiguration(_config.Clone());
                }

                // Intent validation
                if (_waitingToSendIntentValidation && Time.unscaledTime >= _sendIntentValidationTime)
                {
                    _waitingToSendIntentValidation = false;
                    OnReceivedIntentValidationResponse(_intentResponse);
                }

                // Sensor and gesture data
                while (Time.unscaledTime >= _nextSensorUpdateTime)
                {
                    // If it's time to emit frames, do so until we have caught up.
                    float deltaTime = WearableTools.SensorUpdateIntervalToSeconds(_config.updateInterval);
                    _nextSensorUpdateTime += deltaTime;

                    // If the service is mock-suspended, don't update any data. Continue to iterate through this loop,
                    // however, so we don't fall behind when the service resumes. Drop all gestures that are pending.
                    if (_dynamicDeviceInfo.deviceStatus.ServiceSuspended)
                    {
                        _pendingGestures.Clear();
                        continue;
                    }

                    // Check if sensors need to be updated
                    bool anySensorsEnabled = _config.HasAnySensorsEnabled();

                    // Prepare the frame's timestamp for frame emission
                    if (anySensorsEnabled)
                    {
                        // Update the timestamp and delta-time
                        _lastSensorFrame.deltaTime = deltaTime;
                        _lastSensorFrame.timestamp = _nextSensorUpdateTime;

                        // Simulate movement
                        if (_simulatedMovementMode == MovementSimulationMode.ConstantRate)
                        {
                            // Calculate rotation, which is used by all sensors.
                            if (_rotationType == RotationType.Euler)
                            {
                                _rotation = Quaternion.Euler(_eulerSpinRate * _lastSensorFrame.timestamp);
                            }
                            else if (_rotationType == RotationType.AxisAngle)
                            {
                                _rotation = Quaternion.AngleAxis(
                                    _axisAngleSpinRate.w * _lastSensorFrame.timestamp,
                                    new Vector3(_axisAngleSpinRate.x, _axisAngleSpinRate.y, _axisAngleSpinRate.z).normalized);
                            }
                        }
                        else
                        {
                            _rotation = Quaternion.identity;
                        }

                        // Update all active sensors, even if motion is not simulated
                        if (_config.accelerometer.isEnabled && _virtualDevice.IsSensorAvailable(SensorId.Accelerometer))
                        {
                            UpdateAccelerometerData();
                        }

                        if (_config.gyroscope.isEnabled && _virtualDevice.IsSensorAvailable(SensorId.Gyroscope))
                        {
                            UpdateGyroscopeData();
                        }

                        if ((_config.rotationSixDof.isEnabled && _virtualDevice.IsSensorAvailable(SensorId.RotationSixDof)) ||
                            (_config.rotationNineDof.isEnabled && _virtualDevice.IsSensorAvailable(SensorId.RotationNineDof)))
                        {
                            UpdateRotationSensorData();
                        }

                        // Emit the frame
                        _currentSensorFrames.Add(_lastSensorFrame);
                        OnSensorsUpdated(_lastSensorFrame);
                    }

                    // Add any gestures simulated in the past sensor frame.
                    UpdateGestureData();
                    for (int i = 0; i < _currentGestureData.Count; i++)
                    {
                        OnGestureDetected(_currentGestureData[i].gestureId);
                    }
                }
            }

            // Allow the provider base to do its own update work
            base.OnUpdate();
        }
 /// <summary>
 /// Returns the Product <see cref="VariantType"/> of the device.
 /// </summary>
 /// <returns></returns>
 public VariantType GetVariantType()
 {
     return(WearableTools.GetVariantType(GetProductType(), variantId));
 }
 /// <summary>
 /// Returns the <see cref="ProductType"/> of the device.
 /// </summary>
 /// <returns></returns>
 public ProductType GetProductType()
 {
     return(WearableTools.GetProductType(productId));
 }
        internal override void OnUpdate()
        {
            UpdateVirtualDeviceInfo();

            if (!_enabled)
            {
                return;
            }

            // Clear the current frames; _lastSensorFrame will retain its previous value.
            if (_currentSensorFrames.Count > 0)
            {
                _currentSensorFrames.Clear();
            }

            if (_connectedDevice == null)
            {
                return;
            }

            while (Time.unscaledTime >= _nextSensorUpdateTime)
            {
                // If it's time to emit frames, do so until we have caught up.
                float deltaTime = WearableTools.SensorUpdateIntervalToSeconds(_sensorUpdateInterval);
                _nextSensorUpdateTime += deltaTime;

                // Check if sensors need to be updated
                bool anySensorsEnabled = false;
                for (int i = 0; i < WearableConstants.SensorIds.Length; i++)
                {
                    if (_sensorStatus[WearableConstants.SensorIds[i]])
                    {
                        anySensorsEnabled = true;
                        break;
                    }
                }

                // Emit a gesture if needed
                bool gestureEmitted = UpdateGestureData();

                if (anySensorsEnabled || gestureEmitted)
                {
                    // Update the timestamp and delta-time
                    _lastSensorFrame.deltaTime = deltaTime;
                    _lastSensorFrame.timestamp = _nextSensorUpdateTime;
                }

                if (anySensorsEnabled)
                {
                    if (_simulateMovement)
                    {
                        // Calculate rotation, which is used by all sensors.
                        if (_rotationType == RotationType.Euler)
                        {
                            _rotation = Quaternion.Euler(_eulerSpinRate * _lastSensorFrame.timestamp);
                        }
                        else if (_rotationType == RotationType.AxisAngle)
                        {
                            _rotation = Quaternion.AngleAxis(
                                _axisAngleSpinRate.w * _lastSensorFrame.timestamp,
                                new Vector3(_axisAngleSpinRate.x, _axisAngleSpinRate.y, _axisAngleSpinRate.z).normalized);
                        }
                    }
                    else
                    {
                        _rotation = Quaternion.identity;
                    }

                    // Update all active sensors, even if motion is not simulated
                    if (_sensorStatus[SensorId.Accelerometer])
                    {
                        UpdateAccelerometerData();
                    }

                    if (_sensorStatus[SensorId.Gyroscope])
                    {
                        UpdateGyroscopeData();
                    }

                    if (_sensorStatus[SensorId.Rotation])
                    {
                        UpdateRotationSensorData();
                    }
                }

                // Emit the frame if needed
                if (anySensorsEnabled || gestureEmitted)
                {
                    _currentSensorFrames.Add(_lastSensorFrame);
                    OnSensorsOrGestureUpdated(_lastSensorFrame);
                }
            }
        }
Example #14
0
        public override string ToString()
        {
            const string ItemSeparator  = ", ";
            const string NoneLabel      = "None";
            const string SensorsLabel   = "Sensors: ";
            const string GesturesLabel  = "Gestures: ";
            const string IntervalsLabel = "Intervals: ";
            const string IntervalFormat = "{0}ms";

            if (_stringBuilder == null)
            {
                _stringBuilder = new StringBuilder();
            }
            else
            {
                _stringBuilder.Length = 0;
            }

            _stringBuilder.Append(SensorsLabel);
            for (int i = 0; i < _sensors.Count; i++)
            {
                SensorId id = _sensors[i];

                _stringBuilder.Append(_sensors[i].ToString());

                if (i != _sensors.Count - 1)
                {
                    _stringBuilder.Append(ItemSeparator);
                }
            }

            if (_sensors.Count == 0)
            {
                _stringBuilder.Append(NoneLabel);
            }

            _stringBuilder.AppendLine();
            _stringBuilder.Append(IntervalsLabel);
            for (int i = 0; i < _intervals.Count; i++)
            {
                _stringBuilder.AppendFormat(
                    IntervalFormat,
                    ((int)WearableTools.SensorUpdateIntervalToMilliseconds(_intervals[i])).ToString());

                if (i != _intervals.Count - 1)
                {
                    _stringBuilder.Append(ItemSeparator);
                }
            }

            if (_intervals.Count == 0)
            {
                _stringBuilder.Append(NoneLabel);
            }

            _stringBuilder.AppendLine();
            _stringBuilder.Append(GesturesLabel);
            for (int i = 0; i < _gestures.Count; i++)
            {
                _stringBuilder.Append(_gestures[i].ToString());

                if (i != _gestures.Count - 1)
                {
                    _stringBuilder.Append(ItemSeparator);
                }
            }

            if (_gestures.Count == 0)
            {
                _stringBuilder.Append(NoneLabel);
            }

            return(_stringBuilder.ToString());
        }
Example #15
0
        public override string ToString()
        {
            const string ITEM_SEPARATOR  = ", ";
            const string NONE_LABEL      = "None";
            const string SENSORS_LABEL   = "Sensors: ";
            const string GESTURES_LABEL  = "Gestures: ";
            const string INTERVALS_LABEL = "Intervals: ";
            const string INTERVAL_FORMAT = "{0}ms";

            if (_stringBuilder == null)
            {
                _stringBuilder = new StringBuilder();
            }
            else
            {
                _stringBuilder.Length = 0;
            }

            _stringBuilder.Append(SENSORS_LABEL);
            for (int i = 0; i < _sensors.Count; i++)
            {
                SensorId id = _sensors[i];

                _stringBuilder.Append(_sensors[i].ToString());

                if (i != _sensors.Count - 1)
                {
                    _stringBuilder.Append(ITEM_SEPARATOR);
                }
            }

            if (_sensors.Count == 0)
            {
                _stringBuilder.Append(NONE_LABEL);
            }

            _stringBuilder.AppendLine();
            _stringBuilder.Append(INTERVALS_LABEL);
            for (int i = 0; i < _intervals.Count; i++)
            {
                _stringBuilder.AppendFormat(
                    INTERVAL_FORMAT,
                    ((int)WearableTools.SensorUpdateIntervalToMilliseconds(_intervals[i])).ToString());

                if (i != _intervals.Count - 1)
                {
                    _stringBuilder.Append(ITEM_SEPARATOR);
                }
            }

            if (_intervals.Count == 0)
            {
                _stringBuilder.Append(NONE_LABEL);
            }

            _stringBuilder.AppendLine();
            _stringBuilder.Append(GESTURES_LABEL);
            for (int i = 0; i < _gestures.Count; i++)
            {
                _stringBuilder.Append(_gestures[i].ToString());

                if (i != _gestures.Count - 1)
                {
                    _stringBuilder.Append(ITEM_SEPARATOR);
                }
            }

            if (_gestures.Count == 0)
            {
                _stringBuilder.Append(NONE_LABEL);
            }

            return(_stringBuilder.ToString());
        }
Example #16
0
        /// <summary>
        /// Returns true if a device supports using a gesture with <see cref="GestureId"/>
        /// <paramref name="gestureId"/>, otherwise false if it does not.
        /// </summary>
        /// <param name="gestureId"></param>
        /// <returns></returns>
        public bool IsGestureAvailable(GestureId gestureId)
        {
            var gestureFlag = WearableTools.GetGestureFlag(gestureId);

            return((availableGestures & gestureFlag) == gestureFlag);
        }
Example #17
0
        /// <summary>
        /// Returns true if a device supports using a sensor with <see cref="SensorId"/>
        /// <paramref name="sensorId"/>, otherwise false if it does not.
        /// </summary>
        /// <param name="sensorId"></param>
        /// <returns></returns>
        public bool IsSensorAvailable(SensorId sensorId)
        {
            var sensorFlag = WearableTools.GetSensorFlag(sensorId);

            return((availableSensors & sensorFlag) == sensorFlag);
        }