Question

I’m building a service that will let me know if the location hasn’t change in a period of time for a certain amount of metres.

Then thing is I have the event onLocationChanged on my Listener.. but I don’t know how to do the opposite.. that is, send a broadcast if the location is within the distance I provided after some minutes.

This is the code I have so far

LocationService

public class LocationService extends Service {

    public static final String LOC_INTENT = "com.xxx.intent.action.LOCATION";

    private Thread triggerService;
    protected LocationManager locationManager;
    protected MyLocationListener MyLocationListener;
    protected Criteria criteria;

    public static final int MIN_TIME = 300000; // 5 Minutes
    public static final long MIN_DISTANCE_MOTOR = 50; // 50 Metres

    private SharedPreferences settings;


    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId)
    {

        settings = getSharedPreferences(getString(R.string.settings_prefsName), 0);
        addLocationListener();

        return START_STICKY;
    }

    private void addLocationListener()
    {
        triggerService = new Thread(new Runnable(){
            public void run(){
                try{
                    Looper.prepare();//Initialise the current thread as a looper.
                    locationManager = (LocationManager)getSystemService(Context.LOCATION_SERVICE);

                    criteria = new Criteria();
                    criteria.setAccuracy(Criteria.ACCURACY_FINE);

                    final String PROVIDER = locationManager.getBestProvider(criteria, true);

                    updateLocation(getLastBestLocation(MIN_TIME, MIN_DISTANCE_MOTOR));

                    MyLocationListener = new MyLocationListener();
                    locationManager.requestLocationUpdates(PROVIDER, MIN_TIME, MIN_DISTANCE_MOTOR, MyLocationListener);
                    Log.d("LOC_SERVICE", "Service RUNNING! ("+PROVIDER+")");
                    Looper.loop();
                }catch(Exception ex){
                    ex.printStackTrace();
                }
            }
        }, "LocationThread");
        triggerService.start();
    }


    public Location getLastBestLocation(int minDistance, long minTime) {
        Location bestResult = null;
        float bestAccuracy = Float.MAX_VALUE;
        long bestTime = Long.MIN_VALUE;

        List<String> matchingProviders = locationManager.getAllProviders();
        for (String provider: matchingProviders) {
            Location location = locationManager.getLastKnownLocation(provider);
            if (location != null) {
                float accuracy = location.getAccuracy();
                long time = location.getTime();

                if ((time > minTime && accuracy < bestAccuracy)) {
                    bestResult = location;
                    bestAccuracy = accuracy;
                    bestTime = time;
                }
                else if (time < minTime && bestAccuracy == Float.MAX_VALUE && time > bestTime) {
                    bestResult = location;
                    bestTime = time;
                }
            }
        }

        return bestResult;
    }

    public static void updateLocation(Location location)
    {
        Context appCtx = MyApplication.getAppContext();

        double latitude, longitude;
        float speed;

        latitude = location.getLatitude();
        longitude = location.getLongitude();
        speed = location.getSpeed();

        Intent filterRes = new Intent();
        filterRes.setAction(LOC_INTENT);
        filterRes.putExtra("latitude", latitude);
        filterRes.putExtra("longitude", longitude);
        filterRes.putExtra("speed", speed);
        appCtx.sendBroadcast(filterRes);
    }


    class MyLocationListener implements LocationListener
    {

        @Override
        public void onLocationChanged(Location location)
        {
            if(settings.getBoolean("active", false))
                updateLocation(location);
        }

        @Override
        public void onProviderDisabled(String provider) {
        }

        @Override
        public void onProviderEnabled(String provider) {
        }

        @Override
        public void onStatusChanged(String provider, int status, Bundle extras) {
        }
    }

}

Answer 1

Set a timer for however long you want to test this. When it goes off, check if the last location you got in onLocationChanged is older than the timer length.

EDIT

Here is how I would imagine your service looking

Service starting

• requestLocationUpdates called with appropriate minimum time and minimum distance that that you will be notified after
• Repeating task set where you check if an update was received (check out Timer.scheduleAtFixedRate

Service running

• Perform necessary actions when your timer goes off or onLocationChanged is called

Service stopping

• Remove location updates with removeUpdates
• Stop your timer