packages/FusedLocation/src/com/android/location/fused/FusionEngine.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2012 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.location.fused;

 import java.io.FileDescriptor;
 import java.io.PrintWriter;
 import java.util.HashMap;

 import com.android.location.provider.LocationProviderBase;
 import com.android.location.provider.LocationRequestUnbundled;
 import com.android.location.provider.ProviderRequestUnbundled;

 import android.content.Context;
 import android.location.Location;
 import android.location.LocationListener;
 import android.location.LocationManager;
 import android.os.Bundle;
 import android.os.Looper;
 import android.os.Parcelable;
 import android.os.SystemClock;
 import android.os.WorkSource;
 import android.util.Log;

 public class FusionEngine implements LocationListener {
     public interface Callback {
         public void reportLocation(Location location);
     }

     private static final String TAG = "FusedLocation";
     private static final String NETWORK = LocationManager.NETWORK_PROVIDER;
     private static final String GPS = LocationManager.GPS_PROVIDER;
     private static final String FUSED = LocationProviderBase.FUSED_PROVIDER;

     public static final long SWITCH_ON_FRESHNESS_CLIFF_NS = 11 * 1000000000; // 11 seconds

     private final Context mContext;
     private final LocationManager mLocationManager;
     private final Looper mLooper;

     // all fields are only used on mLooper thread. except for in dump() which is not thread-safe
     private Callback mCallback;
     private Location mFusedLocation;
     private Location mGpsLocation;
     private Location mNetworkLocation;

     private boolean mEnabled;
     private ProviderRequestUnbundled mRequest;

     private final HashMap<String, ProviderStats> mStats = new HashMap<String, ProviderStats>();

     public FusionEngine(Context context, Looper looper) {
         mContext = context;
         mLocationManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
         mNetworkLocation = new Location("");
         mNetworkLocation.setAccuracy(Float.MAX_VALUE);
         mGpsLocation = new Location("");
         mGpsLocation.setAccuracy(Float.MAX_VALUE);
         mLooper = looper;

         mStats.put(GPS, new ProviderStats());
         mStats.get(GPS).available = mLocationManager.isProviderEnabled(GPS);
         mStats.put(NETWORK, new ProviderStats());
         mStats.get(NETWORK).available = mLocationManager.isProviderEnabled(NETWORK);

     }

     public void init(Callback callback) {
         Log.i(TAG, "engine started (" + mContext.getPackageName() + ")");
         mCallback = callback;
     }

     /**
      * Called to stop doing any work, and release all resources
      * This can happen when a better fusion engine is installed
      * in a different package, and this one is no longer needed.
      * Called on mLooper thread
      */
     public void deinit() {
         mRequest = null;
         disable();
         Log.i(TAG, "engine stopped (" + mContext.getPackageName() + ")");
     }

     /** Called on mLooper thread */
     public void enable() {
         mEnabled = true;
         updateRequirements();
     }

     /** Called on mLooper thread */
     public void disable() {
         mEnabled = false;
         updateRequirements();
     }

     /** Called on mLooper thread */
     public void setRequest(ProviderRequestUnbundled request, WorkSource source) {
         mRequest = request;
         mEnabled = request.getReportLocation();
         updateRequirements();
     }

     private static class ProviderStats {
         public boolean available;
         public boolean requested;
         public long requestTime;
         public long minTime;
         @Override
         public String toString() {
             StringBuilder s = new StringBuilder();
             s.append(available ? "AVAILABLE" : "UNAVAILABLE");
             s.append(requested ? " REQUESTED" : " ---");
             return s.toString();
         }
     }

     private void enableProvider(String name, long minTime) {
         ProviderStats stats = mStats.get(name);

         if (stats.available) {
             if (!stats.requested) {
                 stats.requestTime = SystemClock.elapsedRealtime();
                 stats.requested = true;
                 stats.minTime = minTime;
                 mLocationManager.requestLocationUpdates(name, minTime, 0, this, mLooper);
             } else if (stats.minTime != minTime) {
                 stats.minTime = minTime;
                 mLocationManager.requestLocationUpdates(name, minTime, 0, this, mLooper);
             }
         }
     }

     private void disableProvider(String name) {
         ProviderStats stats = mStats.get(name);

         if (stats.requested) {
             stats.requested = false;
             mLocationManager.removeUpdates(this);  //TODO GLOBAL
         }
     }

     private void updateRequirements() {
         if (mEnabled == false || mRequest == null) {
             mRequest = null;
             disableProvider(NETWORK);
             disableProvider(GPS);
             return;
         }

         long networkInterval = Long.MAX_VALUE;
         long gpsInterval = Long.MAX_VALUE;
         for (LocationRequestUnbundled request : mRequest.getLocationRequests()) {
             switch (request.getQuality()) {
                 case LocationRequestUnbundled.ACCURACY_FINE:
                 case LocationRequestUnbundled.POWER_HIGH:
                     if (request.getInterval() < gpsInterval) {
                         gpsInterval = request.getInterval();
                     }
                     if (request.getInterval() < networkInterval) {
                         networkInterval = request.getInterval();
                     }
                     break;
                 case LocationRequestUnbundled.ACCURACY_BLOCK:
                 case LocationRequestUnbundled.ACCURACY_CITY:
                 case LocationRequestUnbundled.POWER_LOW:
                     if (request.getInterval() < networkInterval) {
                         networkInterval = request.getInterval();
                     }
                     break;
             }
         }

         if (gpsInterval < Long.MAX_VALUE) {
             enableProvider(GPS, gpsInterval);
         } else {
             disableProvider(GPS);
         }
         if (networkInterval < Long.MAX_VALUE) {
             enableProvider(NETWORK, networkInterval);
         } else {
             disableProvider(NETWORK);
         }
     }

     /**
      * Test whether one location (a) is better to use than another (b).
      */
     private static boolean isBetterThan(Location locationA, Location locationB) {
       if (locationA == null) {
         return false;
       }
       if (locationB == null) {
         return true;
       }
       // A provider is better if the reading is sufficiently newer.  Heading
       // underground can cause GPS to stop reporting fixes.  In this case it's
       // appropriate to revert to cell, even when its accuracy is less.
       if (locationA.getElapsedRealtimeNanos() > locationB.getElapsedRealtimeNanos() + SWITCH_ON_FRESHNESS_CLIFF_NS) {
         return true;
       }

       // A provider is better if it has better accuracy.  Assuming both readings
       // are fresh (and by that accurate), choose the one with the smaller
       // accuracy circle.
       if (!locationA.hasAccuracy()) {
         return false;
       }
       if (!locationB.hasAccuracy()) {
         return true;
       }
       return locationA.getAccuracy() < locationB.getAccuracy();
     }

     private void updateFusedLocation() {
         // may the best location win!
         if (isBetterThan(mGpsLocation, mNetworkLocation)) {
             mFusedLocation = new Location(mGpsLocation);
         } else {
             mFusedLocation = new Location(mNetworkLocation);
         }
         mFusedLocation.setProvider(FUSED);
         if (mNetworkLocation != null) {
             // copy NO_GPS_LOCATION extra from mNetworkLocation into mFusedLocation
             Bundle srcExtras = mNetworkLocation.getExtras();
             if (srcExtras != null) {
                 Parcelable srcParcelable =
                         srcExtras.getParcelable(LocationProviderBase.EXTRA_NO_GPS_LOCATION);
                 if (srcParcelable instanceof Location) {
                     Bundle dstExtras = mFusedLocation.getExtras();
                     if (dstExtras == null) {
                         dstExtras = new Bundle();
                         mFusedLocation.setExtras(dstExtras);
                     }
                     dstExtras.putParcelable(LocationProviderBase.EXTRA_NO_GPS_LOCATION,
                             (Location) srcParcelable);
                 }
             }
         }

         if (mCallback != null) {
           mCallback.reportLocation(mFusedLocation);
         } else {
           Log.w(TAG, "Location updates received while fusion engine not started");
         }
     }

     /** Called on mLooper thread */
     @Override
     public void onLocationChanged(Location location) {
         if (GPS.equals(location.getProvider())) {
             mGpsLocation = location;
             updateFusedLocation();
         } else if (NETWORK.equals(location.getProvider())) {
             mNetworkLocation = location;
             updateFusedLocation();
         }
     }

     /** Called on mLooper thread */
     @Override
     public void onStatusChanged(String provider, int status, Bundle extras) {  }

     /** Called on mLooper thread */
     @Override
     public void onProviderEnabled(String provider) {
         ProviderStats stats = mStats.get(provider);
         if (stats == null) return;

         stats.available = true;
     }

     /** Called on mLooper thread */
     @Override
     public void onProviderDisabled(String provider) {
         ProviderStats stats = mStats.get(provider);
         if (stats == null) return;

         stats.available = false;
     }

     public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
         StringBuilder s = new StringBuilder();
         s.append("mEnabled=" + mEnabled).append(' ').append(mRequest).append('\n');
         s.append("fused=").append(mFusedLocation).append('\n');
         s.append(String.format("gps %s\n", mGpsLocation));
         s.append("    ").append(mStats.get(GPS)).append('\n');
         s.append(String.format("net %s\n", mNetworkLocation));
         s.append("    ").append(mStats.get(NETWORK)).append('\n');
         pw.append(s);
     }

     /** Called on mLooper thread */
     public void switchUser() {
         // reset state to prevent location data leakage
         mFusedLocation = null;
         mGpsLocation = null;
         mNetworkLocation = null;
     }
 }
	/*
	* Copyright (C) 2012 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.location.fused;

	import java.io.FileDescriptor;
	import java.io.PrintWriter;
	import java.util.HashMap;

	import com.android.location.provider.LocationProviderBase;
	import com.android.location.provider.LocationRequestUnbundled;
	import com.android.location.provider.ProviderRequestUnbundled;

	import android.content.Context;
	import android.location.Location;
	import android.location.LocationListener;
	import android.location.LocationManager;
	import android.os.Bundle;
	import android.os.Looper;
	import android.os.Parcelable;
	import android.os.SystemClock;
	import android.os.WorkSource;
	import android.util.Log;

	public class FusionEngine implements LocationListener {
	public interface Callback {
	public void reportLocation(Location location);
	}

	private static final String TAG = "FusedLocation";
	private static final String NETWORK = LocationManager.NETWORK_PROVIDER;
	private static final String GPS = LocationManager.GPS_PROVIDER;
	private static final String FUSED = LocationProviderBase.FUSED_PROVIDER;

	public static final long SWITCH_ON_FRESHNESS_CLIFF_NS = 11 * 1000000000; // 11 seconds

	private final Context mContext;
	private final LocationManager mLocationManager;
	private final Looper mLooper;

	// all fields are only used on mLooper thread. except for in dump() which is not thread-safe
	private Callback mCallback;
	private Location mFusedLocation;
	private Location mGpsLocation;
	private Location mNetworkLocation;

	private boolean mEnabled;
	private ProviderRequestUnbundled mRequest;

	private final HashMap<String, ProviderStats> mStats = new HashMap<String, ProviderStats>();

	public FusionEngine(Context context, Looper looper) {
	mContext = context;
	mLocationManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
	mNetworkLocation = new Location("");
	mNetworkLocation.setAccuracy(Float.MAX_VALUE);
	mGpsLocation = new Location("");
	mGpsLocation.setAccuracy(Float.MAX_VALUE);
	mLooper = looper;

	mStats.put(GPS, new ProviderStats());
	mStats.get(GPS).available = mLocationManager.isProviderEnabled(GPS);
	mStats.put(NETWORK, new ProviderStats());
	mStats.get(NETWORK).available = mLocationManager.isProviderEnabled(NETWORK);

	}

	public void init(Callback callback) {
	Log.i(TAG, "engine started (" + mContext.getPackageName() + ")");
	mCallback = callback;
	}

	/**
	* Called to stop doing any work, and release all resources
	* This can happen when a better fusion engine is installed
	* in a different package, and this one is no longer needed.
	* Called on mLooper thread
	*/
	public void deinit() {
	mRequest = null;
	disable();
	Log.i(TAG, "engine stopped (" + mContext.getPackageName() + ")");
	}

	/** Called on mLooper thread */
	public void enable() {
	mEnabled = true;
	updateRequirements();
	}

	/** Called on mLooper thread */
	public void disable() {
	mEnabled = false;
	updateRequirements();
	}

	/** Called on mLooper thread */
	public void setRequest(ProviderRequestUnbundled request, WorkSource source) {
	mRequest = request;
	mEnabled = request.getReportLocation();
	updateRequirements();
	}

	private static class ProviderStats {
	public boolean available;
	public boolean requested;
	public long requestTime;
	public long minTime;
	@Override
	public String toString() {
	StringBuilder s = new StringBuilder();
	s.append(available ? "AVAILABLE" : "UNAVAILABLE");
	s.append(requested ? " REQUESTED" : " ---");
	return s.toString();
	}
	}

	private void enableProvider(String name, long minTime) {
	ProviderStats stats = mStats.get(name);

	if (stats.available) {
	if (!stats.requested) {
	stats.requestTime = SystemClock.elapsedRealtime();
	stats.requested = true;
	stats.minTime = minTime;
	mLocationManager.requestLocationUpdates(name, minTime, 0, this, mLooper);
	} else if (stats.minTime != minTime) {
	stats.minTime = minTime;
	mLocationManager.requestLocationUpdates(name, minTime, 0, this, mLooper);
	}
	}
	}

	private void disableProvider(String name) {
	ProviderStats stats = mStats.get(name);

	if (stats.requested) {
	stats.requested = false;
	mLocationManager.removeUpdates(this); //TODO GLOBAL
	}
	}

	private void updateRequirements() {
	if (mEnabled == false \|\| mRequest == null) {
	mRequest = null;
	disableProvider(NETWORK);
	disableProvider(GPS);
	return;
	}

	long networkInterval = Long.MAX_VALUE;
	long gpsInterval = Long.MAX_VALUE;
	for (LocationRequestUnbundled request : mRequest.getLocationRequests()) {
	switch (request.getQuality()) {
	case LocationRequestUnbundled.ACCURACY_FINE:
	case LocationRequestUnbundled.POWER_HIGH:
	if (request.getInterval() < gpsInterval) {
	gpsInterval = request.getInterval();
	}
	if (request.getInterval() < networkInterval) {
	networkInterval = request.getInterval();
	}
	break;
	case LocationRequestUnbundled.ACCURACY_BLOCK:
	case LocationRequestUnbundled.ACCURACY_CITY:
	case LocationRequestUnbundled.POWER_LOW:
	if (request.getInterval() < networkInterval) {
	networkInterval = request.getInterval();
	}
	break;
	}
	}

	if (gpsInterval < Long.MAX_VALUE) {
	enableProvider(GPS, gpsInterval);
	} else {
	disableProvider(GPS);
	}
	if (networkInterval < Long.MAX_VALUE) {
	enableProvider(NETWORK, networkInterval);
	} else {
	disableProvider(NETWORK);
	}
	}

	/**
	* Test whether one location (a) is better to use than another (b).
	*/
	private static boolean isBetterThan(Location locationA, Location locationB) {
	if (locationA == null) {
	return false;
	}
	if (locationB == null) {
	return true;
	}
	// A provider is better if the reading is sufficiently newer. Heading
	// underground can cause GPS to stop reporting fixes. In this case it's
	// appropriate to revert to cell, even when its accuracy is less.
	if (locationA.getElapsedRealtimeNanos() > locationB.getElapsedRealtimeNanos() + SWITCH_ON_FRESHNESS_CLIFF_NS) {
	return true;
	}

	// A provider is better if it has better accuracy. Assuming both readings
	// are fresh (and by that accurate), choose the one with the smaller
	// accuracy circle.
	if (!locationA.hasAccuracy()) {
	return false;
	}
	if (!locationB.hasAccuracy()) {
	return true;
	}
	return locationA.getAccuracy() < locationB.getAccuracy();
	}

	private void updateFusedLocation() {
	// may the best location win!
	if (isBetterThan(mGpsLocation, mNetworkLocation)) {
	mFusedLocation = new Location(mGpsLocation);
	} else {
	mFusedLocation = new Location(mNetworkLocation);
	}
	mFusedLocation.setProvider(FUSED);
	if (mNetworkLocation != null) {
	// copy NO_GPS_LOCATION extra from mNetworkLocation into mFusedLocation
	Bundle srcExtras = mNetworkLocation.getExtras();
	if (srcExtras != null) {
	Parcelable srcParcelable =
	srcExtras.getParcelable(LocationProviderBase.EXTRA_NO_GPS_LOCATION);
	if (srcParcelable instanceof Location) {
	Bundle dstExtras = mFusedLocation.getExtras();
	if (dstExtras == null) {
	dstExtras = new Bundle();
	mFusedLocation.setExtras(dstExtras);
	}
	dstExtras.putParcelable(LocationProviderBase.EXTRA_NO_GPS_LOCATION,
	(Location) srcParcelable);
	}
	}
	}

	if (mCallback != null) {
	mCallback.reportLocation(mFusedLocation);
	} else {
	Log.w(TAG, "Location updates received while fusion engine not started");
	}
	}

	/** Called on mLooper thread */
	@Override
	public void onLocationChanged(Location location) {
	if (GPS.equals(location.getProvider())) {
	mGpsLocation = location;
	updateFusedLocation();
	} else if (NETWORK.equals(location.getProvider())) {
	mNetworkLocation = location;
	updateFusedLocation();
	}
	}

	/** Called on mLooper thread */
	@Override
	public void onStatusChanged(String provider, int status, Bundle extras) { }

	/** Called on mLooper thread */
	@Override
	public void onProviderEnabled(String provider) {
	ProviderStats stats = mStats.get(provider);
	if (stats == null) return;

	stats.available = true;
	}

	/** Called on mLooper thread */
	@Override
	public void onProviderDisabled(String provider) {
	ProviderStats stats = mStats.get(provider);
	if (stats == null) return;

	stats.available = false;
	}

	public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
	StringBuilder s = new StringBuilder();
	s.append("mEnabled=" + mEnabled).append(' ').append(mRequest).append('\n');
	s.append("fused=").append(mFusedLocation).append('\n');
	s.append(String.format("gps %s\n", mGpsLocation));
	s.append(" ").append(mStats.get(GPS)).append('\n');
	s.append(String.format("net %s\n", mNetworkLocation));
	s.append(" ").append(mStats.get(NETWORK)).append('\n');
	pw.append(s);
	}

	/** Called on mLooper thread */
	public void switchUser() {
	// reset state to prevent location data leakage
	mFusedLocation = null;
	mGpsLocation = null;
	mNetworkLocation = null;
	}
	}