Java 类android.hardware.GeomagneticField 实例源码

public void onLocationChanged(Location location)
{
    // TODO Auto-generated method stub
    double[] getData=new double[8];
    GeomagneticField geomagneticField = new GeomagneticField((float)location.getLatitude(),
            (float)location.getLongitude(), (float)location.getAltitude(),location.getTime());

    getData[0]=location.getLatitude();
    getData[1]=location.getLongitude();
    getData[2]=location.getAltitude();
    getData[3]=location.getTime();
    //these are for attributes
    getData[4]=location.getBearing();//bearing
    getData[5]=location.getSpeed();//ground speed
    getData[6]=geomagneticField.getDeclination();//magnetic dip
    getData[7]=location.getAccuracy();//vertical and horizontal accuracy

    locationDataUpdated(getData,location.getProvider());
}

@Override
public void onLocationChanged(Location location) {

    oldLocation = this.location;
    this.location = location;

    PhoneLatitude = location.getLatitude();
    PhoneLongitude = location.getLongitude();
    PhoneAltitude = location.getAltitude();
    PhoneSpeed = location.getSpeed() * 100f;
    PhoneAccuracy = location.getAccuracy() * 100f;

    //MapCurrentPosition = new LatLng(location.getLatitude(), location.getLongitude());

    geoField = new GeomagneticField(Double.valueOf(location.getLatitude()).floatValue(), Double.valueOf(location.getLongitude()).floatValue(), Double.valueOf(location.getAltitude()).floatValue(), System.currentTimeMillis());
    Declination = geoField.getDeclination();

    if (mGPSListener != null)
        mGPSListener.onSensorsStateGPSLocationChange();
}

void locationUpdate(Location currentLocation){

        if(!currentLocation.getProvider().equals("gps")) return;

        // calculate declination at this point. This is done only once as it shouldn't change so much at similar location on earth ;)
        //only run this if first time!
        if (declination > 999){
            GeomagneticField geomagneticField = new GeomagneticField((float)currentLocation.getLatitude(),
                (float)currentLocation.getLongitude(), (float)currentLocation.getAltitude(),currentLocation.getTime());
            declination = geomagneticField.getDeclination();
        }
        float distance = currentLocation.distanceTo(geocacheLocation);
        float deviceBearing = currentLocation.getBearing();
        float azimuth = currentLocation.bearingTo(geocacheLocation);
        if(azimuth < 0) azimuth = 360 + azimuth;
        if(deviceBearing < 0) deviceBearing = 360 + deviceBearing;

        float bearing = azimuth - deviceBearing;
        if(bearing < 0) bearing = 360 + bearing;

        updateWatchWithLocation(distance, bearing, azimuth);

    }

/**
 * Gets the magnetic declination at the specified location.
 *
 * @param location Current location.
 * @return The declination of the horizontal component of the magnetic
 * field from true north, in degrees (i.e. positive means the
 * magnetic field is rotated east that much from true north).
 */
public static double getMagneticDeclination(@NonNull Location location) {
    GeomagneticField geoField = new GeomagneticField(
            (float) location.getLatitude(),
            (float) location.getLongitude(),
            (float) location.getAltitude(),
            System.currentTimeMillis()
    );

    return geoField.getDeclination();
}

/**
 * initializes a CompassAssistant with a context and a Location. If you use this constructor the
 * resulting degrees will be calculated with the declination for the given location. The compass
 * will point to the geographic north.
 * @param context the context
 * @param l the location to which the CompassAssistant should refer its pointing.
 */
public CompassAssistant(final Context context, Location l) {
    this.context = context;

    if (l != null) {
        GeomagneticField geomagneticField = new GeomagneticField((float)l.getLatitude(),
                (float)l.getLongitude(), (float)l.getAltitude(), new Date().getTime());
        declination = geomagneticField.getDeclination();
    }

    sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
    accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
    magnetometer = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);

}

public double[] lastKnownPosition(int fromSatellitePositioningMethodsOnly)
{
    double[] getData=new double[7];
    Location location=null;
    Location networkLastLocation=null;
    Location gpsLastLocation=null;
    try
    {
        networkLastLocation=m_locationManager.getLastKnownLocation(GPS);
        gpsLastLocation=m_locationManager.getLastKnownLocation(NETWORK);
        if(fromSatellitePositioningMethodsOnly == 1)
        {
            location=gpsLastLocation;
        }
        else
        {
            location=(networkLastLocation.getTime()>gpsLastLocation.getTime())
                                                ?networkLastLocation:gpsLastLocation;
        }

        GeomagneticField geomagneticField = new GeomagneticField((float)location.getLatitude(),
                (float)location.getLongitude(), (float)location.getAltitude(),location.getTime());

        getData[0]=location.getAltitude();
        getData[1]=location.getLatitude();
        getData[2]=location.getLongitude();
        getData[3]=location.getTime();
        getData[4]=geomagneticField.getDeclination();
        getData[5]=location.getSpeed();
        getData[6]=location.getBearing();
    }
    catch(Exception e)
    {
        Log.i("QtLocation","LastknownLocation not available");
    }

    return getData;
}

private void updateLocation(double latitude, double longitude, int zoom) {
    mLatitude = latitude;
    mLongitude = longitude;
    mZoom = zoom;

    mCoordinateDegree.setText(StringFormatter.coordinates(0, " ", latitude, longitude));
    mCoordinateDegMin.setText(StringFormatter.coordinates(1, " ", latitude, longitude));
    mCoordinateDegMinSec.setText(StringFormatter.coordinates(2, " ", latitude, longitude));
    mCoordinateUtmUps.setText(StringFormatter.coordinates(3, " ", latitude, longitude));
    mCoordinateMgrs.setText(StringFormatter.coordinates(4, " ", latitude, longitude));

    if (BuildConfig.FULL_VERSION) {
        mSunriseSunset.setLocation(latitude, longitude);
        double sunrise = mSunriseSunset.compute(true);
        double sunset = mSunriseSunset.compute(false);

        if (sunrise == Double.MAX_VALUE || sunset == Double.MAX_VALUE) {
            mSunrise.setText(R.string.never_rises);
            mSunsetTitle.setVisibility(View.GONE);
            mSunset.setVisibility(View.GONE);
        } else if (sunrise == Double.MIN_VALUE || sunset == Double.MIN_VALUE) {
            mSunset.setText(R.string.never_sets);
            mSunriseTitle.setVisibility(View.GONE);
            mSunrise.setVisibility(View.GONE);
        } else {
            mSunrise.setText(mSunriseSunset.formatTime(sunrise));
            mSunset.setText(mSunriseSunset.formatTime(sunset));
            mSunriseTitle.setVisibility(View.VISIBLE);
            mSunrise.setVisibility(View.VISIBLE);
            mSunsetTitle.setVisibility(View.VISIBLE);
            mSunset.setVisibility(View.VISIBLE);
        }

        mOffset.setText(StringFormatter.timeO((int) (mSunriseSunset.getUtcOffset() * 60)));

        GeomagneticField mag = new GeomagneticField((float) latitude, (float) longitude, 0.0f, System.currentTimeMillis());
        mDeclination.setText(String.format(Locale.getDefault(), "%+.1f\u00B0", mag.getDeclination()));
    }
}

/**
 * Sets the user's current location and time.
 */
@Override
public void setLocationAndTime(LatLong location, long timeInMillis) {
  geomagneticField = new GeomagneticField(location.getLatitude(),
          location.getLongitude(),
                                          0,
                                          timeInMillis);
}

public static float getDeclination(Location location, long timestamp) {
    if (location == null)
        return 0;

    GeomagneticField field = new GeomagneticField((float) location.getLatitude(), (float) location.getLongitude(),
            (float) location.getAltitude(), timestamp);

    return field.getDeclination();
}

private GeomagneticField getGeomagneticField(Location location)
{
    GeomagneticField geomagneticField = new GeomagneticField(
            (float)location.getLatitude(),
            (float)location.getLongitude(),
            (float)location.getAltitude(),
            System.currentTimeMillis());
    return geomagneticField;
}

public GeomagneticField getGeomagneticField() {
    Location location = getCurrentLocation();
    GeomagneticField gmf = new GeomagneticField(
            (float) location.getLatitude(),
            (float) location.getLongitude(),
            (float) location.getAltitude(), System.currentTimeMillis());
    return gmf;
}

@Override
public void onOrientationChanged(final float orientationToMagneticNorth, IOrientationProvider source) {
    //note, on devices without a compass this never fires...

    //only use the compass bit if we aren't moving, since gps is more accurate when we are moving
    if (gpsspeed < 0.01) {
        GeomagneticField gf = new GeomagneticField(lat, lon, alt, timeOfFix);
        trueNorth = orientationToMagneticNorth + gf.getDeclination();
        gf = null;
        synchronized (trueNorth) {
            if (trueNorth > 360.0f) {
                trueNorth = trueNorth - 360.0f;
            }
            float actualHeading = 0f;

            //this part adjusts the desired map rotation based on device orientation and compass heading
            float t = (360 - trueNorth - this.deviceOrientation);
            if (t < 0) {
                t += 360;
            }
            if (t > 360) {
                t -= 360;
            }
            actualHeading = t;
            //help smooth everything out
            t = (int) t;
            t = t / 5;
            t = (int) t;
            t = t * 5;
            mMapView.setMapOrientation(t);
            updateDisplay(actualHeading,false);
        }
    }
}

private float calcGeoMagneticCorrection(float val) {
    if (previousCorrectionValue == 360 && getLastKnownLocation() != null) {
        OsmLocation l = getLastKnownLocation();
        GeomagneticField gf = new GeomagneticField((float) l.getLatitude(), (float) l.getLongitude(), (float) l.getAltitude(),
                System.currentTimeMillis());
        previousCorrectionValue = gf.getDeclination();
    }
    if (previousCorrectionValue != 360) {
        val += previousCorrectionValue;
    }
    return val;
}

public static float getDeclination(Location location, long timestamp) {
    if(location == null)
        return 0;
    GeomagneticField field = new GeomagneticField((float) location.getLatitude(), (float) location.getLongitude(),
            (float) location.getAltitude(), timestamp);

    return field.getDeclination();
}

@Override
public void onLocationChanged(final Location location, final boolean continous, final boolean geoid, final float smoothspeed, final float avgspeed)
{
    Log.d(TAG, "Location arrived");

    final long lastLocationMillis = location.getTime();

    if (angleMagnetic && lastLocationMillis - lastMagnetic >= magInterval)
    {
        GeomagneticField mag = new GeomagneticField((float) location.getLatitude(), (float) location.getLongitude(), (float) location.getAltitude(), System.currentTimeMillis());
        magneticDeclination = mag.getDeclination();
        lastMagnetic = lastLocationMillis;
    }

    Androzic.this.location[0] = location.getLatitude();
    Androzic.this.location[1] = location.getLongitude();

    shouldEnableFollowing = shouldEnableFollowing || lastKnownLocation == null;

    lastKnownLocation = location;
    gpsEnabled = gpsEnabled || LocationManager.GPS_PROVIDER.equals(location.getProvider());
    gpsContinous = continous;
    gpsGeoid = geoid;

    if (overlayManager.accuracyOverlay != null && location.hasAccuracy())
    {
        overlayManager.accuracyOverlay.setAccuracy(location.getAccuracy());
    }
}

public static float getDeclination(Location location, long timestamp) {

        if(location == null){
            return 0;
        }
        GeomagneticField field = new GeomagneticField((float) location.getLatitude(), (float) location.getLongitude(),
                (float) location.getAltitude(), timestamp);

        return field.getDeclination();
    }

public GeomagneticField getGeomagneticField() {
    Location location = getCurrentLocation();
    GeomagneticField gmf = new GeomagneticField(
            (float) location.getLatitude(),
            (float) location.getLongitude(),
            (float) location.getAltitude(), System.currentTimeMillis());
    return gmf;
}

/**
 * {@inheritDoc}
 */
@Override
public void onLocationChanged(Location location) {
    if (location == null) throw new NullPointerException();
    currentLocation = (location);
    gmf = new GeomagneticField((float) currentLocation.getLatitude(), (float) currentLocation.getLongitude(), (float) currentLocation.getAltitude(),
            System.currentTimeMillis());
}

@Override
    public void onSensorChanged(SensorEvent event) {

    // get the angle around the z-axis rotated
        if (event.sensor == mMagneticSensor) {
            System.arraycopy(event.values, 0, mLastMagnetometer, 0, event.values.length);
            mLastMagnetometerSet = true;
        } else if (event.sensor == mAccelerometer) {
            System.arraycopy(event.values, 0, mLastAccelerometer, 0, event.values.length);
            mLastAccelerometerSet = true;
        }

        if (mLastAccelerometerSet && mLastMagnetometerSet) {
            SensorManager.getRotationMatrix(mR, null, mLastAccelerometer, mLastMagnetometer);
            SensorManager.getOrientation(mR, mOrientation);
            float azimuthInRadians = mOrientation[0];

            float azimuthInDegress = (float) (Math.toDegrees(azimuthInRadians) + 360) % 360;

            mTargetDirection = azimuthInDegress;
        }

        float azimuth = -mTargetDirection;
        GeomagneticField geoField = new GeomagneticField( Double
                .valueOf( mLastLocation.getLatitude() ).floatValue(), Double
                .valueOf( mLastLocation.getLongitude() ).floatValue(),
                Double.valueOf( mLastLocation.getAltitude() ).floatValue(),
                System.currentTimeMillis() );
        if(geoField.getDeclination()<0) {
            azimuth += geoField.getDeclination(); // converts magnetic north into true north
        }else{
            azimuth -= geoField.getDeclination();
        }
        //Correct the azimuth
        azimuth = (azimuth+360) % 360;
        //get the bearing
        float y = (float)Math.sin(Math.toRadians(target.getLongitude()-mLastLocation.getLongitude())) * (float)Math.cos(Math.toRadians(target.getLatitude()));
        float x = (float)Math.cos(Math.toRadians(mLastLocation.getLatitude()))*(float)Math.sin(Math.toRadians(target.getLatitude())) -
                (float)Math.sin(Math.toRadians(mLastLocation.getLatitude()))*(float)Math.cos(Math.toRadians(target.getLatitude()))*(float)Math.cos(Math.toRadians(target.getLongitude()-mLastLocation.getLongitude()));
        float bearing = (float)Math.toDegrees(Math.atan2(y, x));
    image.setRotation(azimuth+bearing);
}

@Override
public void onLocationChanged(Location location) {
    Log.i(TAG, "position gps accuracy : " + location.getAccuracy());
    if (location.getAccuracy() > 30) {
        return;
    }
    this.location = location;
    Log.i(TAG, "locationChanged");
    Log.i(TAG, "distance jusqu'au prochain : " + location.distanceTo(current.end));
    Step old = current;
    current = getCurrentPoint(location);

    distance = Math.round(location.distanceTo(current.end));
    //Orientation

    GeomagneticField field = new GeomagneticField(
            (float) location.getLatitude(),
            (float) location.getLongitude(),
            (float) location.getAltitude(),
            System.currentTimeMillis()
    );

    // getDeclination returns degrees
    mDeclination = field.getDeclination();


    double lat1 = location.getLatitude();
    double lng1 = location.getLongitude();

    double lat2 = current.end.getLatitude();
    double lng2 = current.end.getLongitude();

    double dLon = (lng2 - lng1);
    double y = Math.sin(dLon) * Math.cos(lat2);
    double x = Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(dLon);
    angle = Math.toDegrees((Math.atan2(y, x)));


    Calendar before = Calendar.getInstance();
    before.add(Calendar.SECOND, -40);
    if (!current.equals(old) || firstime) {
        showDirection(old);
        //showDirection();
        firstime = false;
        lastShowDirection = location;
        if(!firstime && sharedPref.getBoolean(getString(R.string.pref_vibrate_key),false) && vibrator != null){
            vibrator.vibrate(500);
        }
    } else if (lastShowDirection.distanceTo(location)>50 && (!(current instanceof TransitStep) || current.end.distanceTo(location)<100)) {
        showDirection();
        lastShowDirection = location;
    } else if (!this.arrived && current.equals(itinerary.steps.getLast()) && current.end.distanceTo(location) < 10){
        //Arrivée à destination
        this.arrived = true;
        showDirection(old);
    }
    send(UPDATE_CODE, new Bundle());

}

@Override
public void onLocationChanged(Location location) {
  if (location == null || isQuitting) {
    return;
  }

  long now = System.currentTimeMillis();
  if (currentLocation != null) {
    // Never overwrite recent GPS location with a NETWORK location
    if (location.getProvider().equals(LocationManager.NETWORK_PROVIDER) &&
        currentLocation.getProvider().equals(LocationManager.GPS_PROVIDER) &&
        now < lastGpsTime + GPS_EXPIRATION) {
      return;
    }
    // Ignore updates that come out of order from the same location provider
    if (location.getProvider().equals(currentLocation.getProvider()) &&
        location.getTime() < currentLocation.getTime()) {
      return;
    }
  }
  // Update magnetic declination once every minute
  // -- diff between "true north" and magnetic north in degrees
  if (declinationTime + 60000 < now) {
    declinationTime = now;
    GeomagneticField magneticField = new GeomagneticField(
        (float) location.getLatitude(), (float) location.getLongitude(),
        location.hasAltitude() ? (float) location.getAltitude() : 100f, // use 100m if not known
        declinationTime);
    compassDeclination = Float.valueOf(magneticField.getDeclination());
  }
  // If there is no bearing (lack of motion or network location), use latest compass heading
  if (!location.hasBearing() || !location.hasSpeed() || location.getSpeed() < 0.5f) {
    location.setBearing(compassHeading);
  }

  // Apply geoid height correction to altitude, if reported
  if (location.hasAltitude() && GeoidHeightEstimator.isInitialized()) {
    int geoidCm =
        GeoidHeightEstimator.computeGeoidHeight(location.getLatitude(), location.getLongitude());
    location.setAltitude(location.getAltitude() - Math.round(geoidCm / 100f));
  }

  // Update current location
  if (currentLocation != null) {
    currentLocation.set(location);
  } else {
    currentLocation = new Location(location);
  }

  if (location.getProvider().equals(LocationManager.GPS_PROVIDER)) {
    lastGpsTime = now;
  }
  updateSpeedAndAltitude(location);
}

/**
 * Updates the cached instance of the geomagnetic field after a location change.
 */
private void updateGeomagneticField() {
    mGeomagneticField = new GeomagneticField((float) mLocation.getLatitude(),
            (float) mLocation.getLongitude(), (float) mLocation.getAltitude(),
            mLocation.getTime());
}

/**
 * Handles compass rotation.
 */
@Override
public final void onSensorChanged(SensorEvent event) {
    if(event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
        gravity = event.values.clone();
    } else if(event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) {
        geomagnetic = event.values.clone();
    }

    if(gravity != null && geomagnetic != null) {
        float[] R = new float[9];
        float[] I = new float[9];

        boolean success = SensorManager.getRotationMatrix(R, I, gravity, geomagnetic);
        if(success) {
            final float[] orientation = new float[3];
            SensorManager.getOrientation(R, orientation);
            float azimuth = (float) (Math.toDegrees(orientation[0]) + 360) % 360;

            if(currentLocation != null) {
                final float smoothedLatitude = smoothSensorValues(
                        oldLatitude, (float) currentLocation.getLatitude(), 1 / 3f);
                final float smoothedLongitude = smoothSensorValues(
                        oldLongitude, (float) currentLocation.getLongitude(), 1 / 3f);
                final float smoothedAltitude = smoothSensorValues(
                        oldAltitude, (float) currentLocation.getAltitude(), 1 / 3f);

                GeomagneticField geomagneticField = new GeomagneticField(
                        smoothedLatitude,
                        smoothedLongitude,
                        smoothedAltitude,
                        System.currentTimeMillis()
                );
                azimuth -= geomagneticField.getDeclination();

                final float bearing = currentLocation.bearingTo(geocacheLocation);

                final float newDirectionRaw = (360 - (azimuth-bearing)) % 360;

                final float newDirection = smoothSensorValues(oldDirection, newDirectionRaw, 1 / 5f);

                //Set old values to current values (for smoothing)
                oldDirection = newDirection;
                oldLatitude = smoothedLatitude;
                oldLongitude = smoothedLongitude;
                oldAltitude = smoothedAltitude;

                //Send direction update to Android Wear if update interval has passed
                final long currentTime = System.currentTimeMillis();
                if((currentTime - prevTime) > COMPASS_UPDATE_INTERVAL) {
                    onDirectionUpdateListener.onDirectionUpdate(newDirection);
                    prevTime = currentTime;
                }
            }
        }
    }
}

public static float getLocationDeclination(Location location) {
    return new GeomagneticField((float) location.getLatitude(), (float) location.getLongitude(), (float) location.getAltitude(), location.getTime())
            .getDeclination();
}

/**
 * Updates the cached instance of the geomagnetic field after a location change.
 */
private void updateGeomagneticField() {
    mGeomagneticField = new GeomagneticField((float) mLocation.getLatitude(), (float) mLocation.getLongitude(), (float) mLocation.getAltitude(),
            mLocation.getTime());
}

/**
 * Updates the cached instance of the geomagnetic field after a location change.
 */
private void updateGeomagneticField() {
    mGeomagneticField = new GeomagneticField((float) mLocation.getLatitude(),
            (float) mLocation.getLongitude(), (float) mLocation.getAltitude(),
            mLocation.getTime());
}

/**
 * Updates the cached instance of the geomagnetic field after a location change.
 */
private void updateGeomagneticField() {
    mGeomagneticField = new GeomagneticField((float) mLocation.getLatitude(),
            (float) mLocation.getLongitude(), (float) mLocation.getAltitude(),
            mLocation.getTime());
}

/**
 * Updates the cached instance of the geomagnetic field after a location change.
 */
private void updateGeomagneticField() {
    mGeomagneticField = new GeomagneticField((float) mLocation.getLatitude(),
            (float) mLocation.getLongitude(), (float) mLocation.getAltitude(),
            mLocation.getTime());
}

/**
 * Updates the cached instance of the geomagnetic field after a location change.
 */
private void updateGeomagneticField() {
    mGeomagneticField = new GeomagneticField((float) mLocation.getLatitude(),
            (float) mLocation.getLongitude(), (float) mLocation.getAltitude(),
            mLocation.getTime());
}

/**
 * Updates the cached instance of the geomagnetic field after a location change.
 */
private void updateGeomagneticField() {
    mGeomagneticField = new GeomagneticField((float) mLocation.getLatitude(),
            (float) mLocation.getLongitude(), (float) mLocation.getAltitude(),
            mLocation.getTime());
}

/**
 * Updates the cached instance of the geomagnetic field after a location change.
 */
private void updateGeomagneticField() {
    mGeomagneticField = new GeomagneticField((float) mLocation.getLatitude(),
            (float) mLocation.getLongitude(), (float) mLocation.getAltitude(),
            mLocation.getTime());
}

public void locationChanged(Location location) {
    // geomagnetic offset
    if (location.hasAltitude()) {
        GeomagneticField geoField = new GeomagneticField(
                Double.valueOf(location.getLatitude()).floatValue(),
                Double.valueOf(location.getLongitude()).floatValue(),
                Double.valueOf(location.getAltitude()).floatValue(),
                System.currentTimeMillis());
        differenceToTrueNorth = geoField.getDeclination();
    }

    // load bearing values of GPS and compass
    int bearingOfGPS = bearingOfMagneticField[0];
    if (location.hasBearing())
        bearingOfGPS = (int) location.getBearing();

    // if the application was put into background, use GPS as bearing source and remember
    // the priour bearing source, so that we can switch back imediately when the app comes
    // into foreground again
    if (globalData.applicationInBackground()) {
        if (lastBearingSource == null) {
            lastBearingSource = settingsManager.getBearingSource();
            settingsManager.setBearingSource(SettingsManager.BearingSource.GPS);
        }
    } else {
        if (lastBearingSource != null) {
            settingsManager.setBearingSource(lastBearingSource);
            lastBearingSource = null;
        }

        // check, if the diff between the location bearing value and the current compass is
        // smaller than the defined threshold
        // 0 <= diff <= 180
        int diff = Math.abs(bearingOfGPS - bearingOfMagneticField[0]);
        if (diff > 180)
            diff = 360 - diff;
        if (location.hasSpeed() && location.getSpeed() > 3.0) {
            if (diff < smallThresholdValue || diff > 180-smallThresholdValue) {
                if (matchCounter > 0)
                    matchCounter -= 1;
            } else if (diff > bigThresholdValueDrive && diff < 180-bigThresholdValueDrive) {
                if (matchCounter < maxNumberOfMatches)
                    matchCounter += 1;
            }
        } else {
            if (diff < smallThresholdValue) {
                if (matchCounter > 0)
                    matchCounter -= 1;
            } else if (diff > bigThresholdValueWalk) {
                if (matchCounter < maxNumberOfMatches)
                    matchCounter += 1;
            }
        }

        if (matchCounter == 0 && settingsManager.useGPSAsBearingSource()) {
            settingsManager.setBearingSource(SettingsManager.BearingSource.COMPASS);
            messageToast.setText(
                    mContext.getResources().getString(R.string.messageSwitchedToCompass));
            messageToast.show();
        }
        if (matchCounter == maxNumberOfMatches && settingsManager.useCompassAsBearingSource()) {
            settingsManager.setBearingSource(SettingsManager.BearingSource.GPS);
            messageToast.setText(
                    mContext.getResources().getString(R.string.messageSwitchedToGPS));
            messageToast.show();
        }
    }

    if (settingsManager.useGPSAsBearingSource()
            && bearingOfGPS != bearingOfDevice) {
        bearingOfDevice = bearingOfGPS;
        if (sListener != null)
            sListener.compassValueChanged(bearingOfDevice);
    }
}

public void onClick(View v)
    {
        try
        {
            Androzic application = Androzic.getApplication();
            Waypoint waypoint = new Waypoint();
            View view = getView();
            waypoint.name = ((TextView) view.findViewById(R.id.name_text)).getText().toString();
            double distance = Integer.parseInt(((TextView) view.findViewById(R.id.distance_text)).getText().toString());
            double bearing = Double.parseDouble(((TextView) view.findViewById(R.id.bearing_text)).getText().toString());
            int src = ((Spinner) view.findViewById(R.id.source_spinner)).getSelectedItemPosition();
            int df = ((Spinner) view.findViewById(R.id.distance_spinner)).getSelectedItemPosition();
            int bf = ((Spinner) view.findViewById(R.id.bearing_spinner)).getSelectedItemPosition();
            double[] loc;
            if (src > 0)
            {
                 loc = new double[2];
                 loc[0] = waypoints.get(src-1).latitude;
                 loc[1] = waypoints.get(src-1).longitude;
            }
            else
            {
                loc = application.getLocation();
            }

            if (df == 0)
            {
                distance = distance / StringFormatter.distanceFactor * 1000;
            }
            else
            {
                distance = distance / StringFormatter.distanceShortFactor;
            }
      bearing = bearing * StringFormatter.angleFactor;
            if (bf == 1)
            {
                GeomagneticField mag = new GeomagneticField((float) loc[0], (float) loc[1], 0.0f, System.currentTimeMillis());
                bearing += mag.getDeclination();
       if (bearing > 360d)
        bearing -= 360d;
            }
            double[] prj = Geo.projection(loc[0], loc[1], distance, bearing);
            waypoint.latitude = prj[0];
            waypoint.longitude = prj[1];
            waypoint.date = Calendar.getInstance().getTime();
            application.addWaypoint(waypoint);

            getTargetFragment().onActivityResult(getTargetRequestCode(), Activity.RESULT_OK, null);
dismiss();
        }
        catch (Exception e)
        {
            Toast.makeText(getActivity(), "Invalid input", Toast.LENGTH_LONG).show();
            e.printStackTrace();
        }
    }

public double getDeclination(double lat, double lon)
{
    GeomagneticField mag = new GeomagneticField((float) lat, (float) lon, 0.0f, System.currentTimeMillis());
    return mag.getDeclination();
}

/**
 * Updates the cached instance of the geomagnetic field after a location change.
 */
private void updateGeomagneticField() {
    mGeomagneticField = new GeomagneticField((float) mLocation.getLatitude(),
            (float) mLocation.getLongitude(), (float) mLocation.getAltitude(),
            mLocation.getTime());
}

/**
 * 
 * @return GeomagneticField
 */
GeomagneticField getGeomagneticField();

/**
 * 
 * @return GeomagneticField
 */
GeomagneticField getGeomagneticField();