示例#1
0
  public boolean getHasCompass() {
    boolean compass = false;

    SensorManager sensorManager = TiSensorHelper.getSensorManager();
    if (sensorManager != null) {
      compass = sensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION) != null;
    } else {
      compass =
          TiSensorHelper.hasDefaultSensor(geolocationModule.getActivity(), Sensor.TYPE_ORIENTATION);
    }

    return compass;
  }
示例#2
0
  public void getCurrentHeading(final KrollFunction listener) {
    if (listener != null) {
      final SensorEventListener oneShotHeadingListener =
          new SensorEventListener() {
            public void onAccuracyChanged(Sensor sensor, int accuracy) {}

            public void onSensorChanged(SensorEvent event) {
              if (event.sensor.getType() == Sensor.TYPE_ORIENTATION) {
                long eventTimestamp = event.timestamp / 1000000;
                long actualTimestamp =
                    baseTime.getTimeInMillis() + (eventTimestamp - sensorTimerStart);

                listener.callAsync(
                    geolocationModule.getKrollObject(),
                    new Object[] {eventToHashMap(event, actualTimestamp)});
                TiSensorHelper.unregisterListener(Sensor.TYPE_ORIENTATION, this);
              }
            }
          };

      updateDeclination();
      TiSensorHelper.registerListener(
          Sensor.TYPE_ORIENTATION, oneShotHeadingListener, SensorManager.SENSOR_DELAY_UI);
    }
  }
示例#3
0
  public void onPause() {
    if (sensorAttached) {
      manageUpdateListener(false, updateListener);

      sensorHelper.detach();
      sensorAttached = false;
    }
  }
示例#4
0
  public boolean hasCompass() {
    boolean compass = false;

    SensorManager sm = sensorHelper.getSensorManager();
    if (sm != null) {
      compass = sm.getDefaultSensor(Sensor.TYPE_ORIENTATION) != null;
    }

    return compass;
  }
示例#5
0
  protected void manageUpdateListener(boolean register, SensorEventListener listener) {
    if (register) {
      if (!listeningForUpdate) {
        sensorAttached = sensorHelper.attach(proxy.getTiContext().getActivity());

        if (sensorAttached) {

          LocationManager locationManager =
              (LocationManager)
                  proxy.getTiContext().getActivity().getSystemService(Context.LOCATION_SERVICE);

          Criteria criteria = new Criteria();
          String provider = locationManager.getBestProvider(criteria, true);
          if (provider != null) {
            Location location = locationManager.getLastKnownLocation(provider);
            if (location != null) {
              geomagneticField =
                  new GeomagneticField(
                      (float) location.getLatitude(),
                      (float) location.getLongitude(),
                      (float) location.getAltitude(),
                      System.currentTimeMillis());
            }
          }
          sensorHelper.registerListener(SENSORS, listener, SensorManager.SENSOR_DELAY_UI);
          listeningForUpdate = true;
        }
      }
    } else {
      if (listeningForUpdate) {
        sensorHelper.unregisterListener(SENSORS, listener);
        if (sensorHelper.isEmpty()) {
          listeningForUpdate = false;
          sensorHelper.detach();
        }
      }
    }
  }
示例#6
0
  public void getCurrentHeading(final KrollCallback listener) {
    final SensorEventListener oneShotListener =
        new SensorEventListener() {
          public void onAccuracyChanged(Sensor sensor, int accuracy) {}

          public void onSensorChanged(SensorEvent event) {
            int type = event.sensor.getType();

            if (type == Sensor.TYPE_ORIENTATION) {
              long ts = event.timestamp / 1000000; // nanos to millis
              listener.callWithProperties(eventToTiDict(event, ts));

              sensorHelper.unregisterListener(SENSORS, this);
              manageUpdateListener(false, this);
            }
          }
        };

    manageUpdateListener(true, oneShotListener);
    sensorHelper.registerListener(SENSORS, oneShotListener, 5000);
  }
示例#7
0
  @Override
  public void eventListenerRemoved(String type, int count, KrollProxy proxy) {
    if (accelerometerRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        TiSensorHelper.unregisterListener(Sensor.TYPE_ACCELEROMETER, this);
        accelerometerRegistered = false;
      }
    }
    if (magneticFieldRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        TiSensorHelper.unregisterListener(Sensor.TYPE_MAGNETIC_FIELD, this);
        magneticFieldRegistered = false;
      }
    }

    if (ambiantTemperatureRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        TiSensorHelper.unregisterListener(Sensor.TYPE_AMBIENT_TEMPERATURE, this);
        ambiantTemperatureRegistered = false;
      }
    }

    if (gameRotationVectorRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        TiSensorHelper.unregisterListener(Sensor.TYPE_GAME_ROTATION_VECTOR, this);
        gameRotationVectorRegistered = false;
      }
    }

    if (geomagneticRotationVectorRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        TiSensorHelper.unregisterListener(Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR, this);
        geomagneticRotationVectorRegistered = false;
      }
    }

    if (gravityRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        TiSensorHelper.unregisterListener(Sensor.TYPE_GRAVITY, this);
        gravityRegistered = false;
      }
    }

    if (gyroscopeRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        TiSensorHelper.unregisterListener(Sensor.TYPE_GYROSCOPE, this);
        gyroscopeRegistered = false;
      }
    }

    if (gyroscopeUncalibratedRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        TiSensorHelper.unregisterListener(Sensor.TYPE_GYROSCOPE_UNCALIBRATED, this);
        gyroscopeUncalibratedRegistered = false;
      }
    }

    /*if (heartRateRegistered) {
    	if (EVENT_UPDATE.equals(type)) {
    		TiSensorHelper.unregisterListener(Sensor.TYPE_HEART_RATE, this);
    		heartRateRegistered = false;
    	}
    }*/

    if (lightRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        TiSensorHelper.unregisterListener(Sensor.TYPE_LIGHT, this);
        lightRegistered = false;
      }
    }

    if (linearAccelerationRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        TiSensorHelper.unregisterListener(Sensor.TYPE_LINEAR_ACCELERATION, this);
        linearAccelerationRegistered = false;
      }
    }

    if (magneticFieldUncalibratedRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        TiSensorHelper.unregisterListener(Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED, this);
        magneticFieldUncalibratedRegistered = false;
      }
    }

    if (orientationRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        TiSensorHelper.unregisterListener(Sensor.TYPE_ORIENTATION, this);
        orientationRegistered = false;
      }
    }

    if (pressureRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        TiSensorHelper.unregisterListener(Sensor.TYPE_PRESSURE, this);
        pressureRegistered = false;
      }
    }

    if (proximityRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        TiSensorHelper.unregisterListener(Sensor.TYPE_PROXIMITY, this);
        proximityRegistered = false;
      }
    }

    if (relativeHumidityRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        TiSensorHelper.unregisterListener(Sensor.TYPE_RELATIVE_HUMIDITY, this);
        relativeHumidityRegistered = false;
      }
    }

    if (rotationVectorRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        TiSensorHelper.unregisterListener(Sensor.TYPE_ROTATION_VECTOR, this);
        rotationVectorRegistered = false;
      }
    }

    if (significantMotionRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        TiSensorHelper.unregisterListener(Sensor.TYPE_SIGNIFICANT_MOTION, this);
        significantMotionRegistered = false;
      }
    }

    if (stepCounterRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        TiSensorHelper.unregisterListener(Sensor.TYPE_STEP_COUNTER, this);
        stepCounterRegistered = false;
      }
    }

    if (stepDetectorRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        TiSensorHelper.unregisterListener(Sensor.TYPE_STEP_DETECTOR, this);
        stepDetectorRegistered = false;
      }
    }
    setflashLightOff();
    super.eventListenerRemoved(type, count, proxy);
  }
示例#8
0
  @Override
  public void eventListenerAdded(String type, int count, final KrollProxy proxy) {
    if (accelerometerEnabled && !accelerometerRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        Log.i(LCAT, "registerListener for ACCELEROMETER:");
        accelerationFilter = new MeanFilter(); // Used for gyro cals
        accelerationFilter.setWindowSize(10); // Used for gyro cals
        TiSensorHelper.registerListener(
            Sensor.TYPE_ACCELEROMETER, this, SensorManager.SENSOR_DELAY_UI);
        // TiSensorHelper.registerListener(Sensor.TYPE_MAGNETIC_FIELD, this,
        // SensorManager.SENSOR_DELAY_UI);
        accelerometerRegistered = true;
      }
    }

    if (magneticFieldEnabled && !magneticFieldRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        Log.i(LCAT, "registerListener for MAGNETIC_FIELD:");
        magneticFilter = new MeanFilter(); // Used for gyro cals
        magneticFilter.setWindowSize(10); // Used for gyro cals
        TiSensorHelper.registerListener(
            Sensor.TYPE_MAGNETIC_FIELD, this, SensorManager.SENSOR_DELAY_UI);
        magneticFieldRegistered = true;
      }
    }

    if (ambiantTemperatureEnabled && !ambiantTemperatureRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        Log.i(LCAT, "registerListener for TYPE_AMBIENT_TEMPERATURE:");
        TiSensorHelper.registerListener(
            Sensor.TYPE_AMBIENT_TEMPERATURE, this, SensorManager.SENSOR_DELAY_UI);
        ambiantTemperatureRegistered = true;
      }
    }

    if (gameRotationVectorEnabled && !gameRotationVectorRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        Log.i(LCAT, "registerListener for TYPE_GAME_ROTATION_VECTOR:");
        TiSensorHelper.registerListener(
            Sensor.TYPE_GAME_ROTATION_VECTOR, this, SensorManager.SENSOR_DELAY_UI);
        gameRotationVectorRegistered = true;
      }
    }

    if (geomagneticRotationVectorEnabled && !geomagneticRotationVectorRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        Log.i(LCAT, "registerListener for TYPE_GEOMAGNETIC_ROTATION_VECTOR:");
        TiSensorHelper.registerListener(
            Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR, this, SensorManager.SENSOR_DELAY_UI);
        geomagneticRotationVectorRegistered = true;
      }
    }

    if (gravityEnabled && !gravityRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        Log.i(LCAT, "registerListener for TYPE_GRAVITY:");
        TiSensorHelper.registerListener(Sensor.TYPE_GRAVITY, this, SensorManager.SENSOR_DELAY_UI);
        gravityRegistered = true;
      }
    }

    if (gyroscopeEnabled && !gyroscopeRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        Log.i(LCAT, "registerListener for TYPE_GYROSCOPE:");
        initGyroMaths();
        TiSensorHelper.registerListener(Sensor.TYPE_GYROSCOPE, this, SensorManager.SENSOR_DELAY_UI);
        gyroscopeRegistered = true;
      }
    }

    if (gyroscopeUncalibratedEnabled && !gyroscopeUncalibratedRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        Log.i(LCAT, "registerListener for TYPE_GYROSCOPE_UNCALIBRATED:");
        TiSensorHelper.registerListener(
            Sensor.TYPE_GYROSCOPE_UNCALIBRATED, this, SensorManager.SENSOR_DELAY_UI);
        gyroscopeUncalibratedRegistered = true;
      }
    }

    /*if (heartRateEnabled && !heartRateRegistered) {
    	if (EVENT_UPDATE.equals(type)) {
    		Log.i(LCAT, "registerListener for TYPE_HEART_RATE:");
    		TiSensorHelper.registerListener(Sensor.TYPE_HEART_RATE, this, SensorManager.SENSOR_DELAY_UI);
    		heartRateRegistered = true;
    	}
    }*/

    if (lightEnabled && !lightRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        Log.i(LCAT, "registerListener for TYPE_LIGHT:");
        TiSensorHelper.registerListener(Sensor.TYPE_LIGHT, this, SensorManager.SENSOR_DELAY_UI);
        lightRegistered = true;
      }
    }

    if (linearAccelerationEnabled && !linearAccelerationRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        Log.i(LCAT, "registerListener for TYPE_LINEAR_ACCELERATION:");
        TiSensorHelper.registerListener(
            Sensor.TYPE_LINEAR_ACCELERATION, this, SensorManager.SENSOR_DELAY_UI);
        linearAccelerationRegistered = true;
      }
    }

    if (magneticFieldUncalibratedEnabled && !magneticFieldUncalibratedRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        Log.i(LCAT, "registerListener for TYPE_MAGNETIC_FIELD_UNCALIBRATED:");
        TiSensorHelper.registerListener(
            Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED, this, SensorManager.SENSOR_DELAY_UI);
        magneticFieldUncalibratedRegistered = true;
      }
    }

    if (orientationEnabled && !orientationRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        Log.i(LCAT, "registerListener for TYPE_ORIENTATION:");
        TiSensorHelper.registerListener(
            Sensor.TYPE_ORIENTATION, this, SensorManager.SENSOR_DELAY_UI);
        orientationRegistered = true;
      }
    }

    if (pressureEnabled && !pressureRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        Log.i(LCAT, "registerListener for TYPE_PRESSURE:");
        TiSensorHelper.registerListener(Sensor.TYPE_PRESSURE, this, SensorManager.SENSOR_DELAY_UI);
        pressureRegistered = true;
      }
    }

    if (proximityEnabled && !proximityRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        Log.i(LCAT, "registerListener for TYPE_PROXIMITY:");
        TiSensorHelper.registerListener(Sensor.TYPE_PROXIMITY, this, SensorManager.SENSOR_DELAY_UI);
        proximityRegistered = true;
      }
    }

    if (relativeHumidityEnabled && !relativeHumidityRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        Log.i(LCAT, "registerListener for TYPE_RELATIVE_HUMIDITY:");
        TiSensorHelper.registerListener(
            Sensor.TYPE_RELATIVE_HUMIDITY, this, SensorManager.SENSOR_DELAY_UI);
        relativeHumidityRegistered = true;
      }
    }

    if (rotationVectorEnabled && !rotationVectorRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        Log.i(LCAT, "registerListener for TYPE_ROTATION_VECTOR:");
        TiSensorHelper.registerListener(
            Sensor.TYPE_ROTATION_VECTOR, this, SensorManager.SENSOR_DELAY_UI);
        rotationVectorRegistered = true;
      }
    }

    if (significantMotionEnabled && !significantMotionRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        Log.i(LCAT, "registerListener for TYPE_SIGNIFICANT_MOTION:");
        mSensor = sensorManager.getDefaultSensor(Sensor.TYPE_SIGNIFICANT_MOTION);
        mTriggerEventListener =
            new TriggerEventListener() {
              @Override
              public void onTrigger(TriggerEvent event) {
                KrollDict data = new KrollDict();
                data.put("sType", Sensor.TYPE_SIGNIFICANT_MOTION);
                significantMotionValues = event.values.clone();
                data.put("motion", significantMotionValues[0]);
                fireEvent(EVENT_UPDATE, data);
                sensorManager.requestTriggerSensor(mTriggerEventListener, mSensor);
              }
            };
        sensorManager.requestTriggerSensor(mTriggerEventListener, mSensor);
        significantMotionRegistered = true;
      }
    }

    if (stepCounterEnabled && !stepCounterRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        Log.i(LCAT, "registerListener for TYPE_STEP_COUNTER:");
        TiSensorHelper.registerListener(
            Sensor.TYPE_STEP_COUNTER, this, SensorManager.SENSOR_DELAY_FASTEST);
        stepCounterRegistered = true;
      }
    }

    if (stepDetectorEnabled && !stepDetectorRegistered) {
      if (EVENT_UPDATE.equals(type)) {
        Log.i(LCAT, "registerListener for TYPE_STEP_DETECTOR:");
        TiSensorHelper.registerListener(
            Sensor.TYPE_STEP_DETECTOR, this, SensorManager.SENSOR_DELAY_FASTEST);
        stepDetectorRegistered = true;
      }
    }
    super.eventListenerAdded(type, count, proxy);
  }
示例#9
0
 public void unregisterListener() {
   TiSensorHelper.unregisterListener(Sensor.TYPE_ORIENTATION, this);
 }
示例#10
0
 public void registerListener() {
   updateDeclination();
   TiSensorHelper.registerListener(Sensor.TYPE_ORIENTATION, this, SensorManager.SENSOR_DELAY_UI);
 }