location/java/com/android/internal/location/NetworkLocationProvider.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2007 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.internal.location;

 import com.android.internal.location.protocol.GDebugProfile;

 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;

 import android.content.Context;
 import android.location.Criteria;
 import android.location.Location;
 import android.location.LocationManager;
 import android.location.LocationProviderImpl;
 import android.net.wifi.ScanResult;
 import android.net.wifi.WifiManager;
 import android.os.Bundle;
 import android.os.SystemClock;
 import android.os.SystemProperties;
 import android.util.Log;

 /**
  * A location provider which gets approximate location from Google's
  * database of cell-tower and wi-fi locations.
  *
  * <p> It is the responsibility of the LocationManagerService to
  * notify this class of any changes in the radio information
  * by calling {@link #updateCellState} and of data state
  * changes by calling {@link #updateNetworkState}
  *
  * <p> The LocationManagerService must also notify the provider
  * of Wifi updates using the {@link #updateWifiScanResults}
  * and {@link #updateWifiEnabledState}
  * methods.
  *
  * <p> The provider uses whichever radio is available - Cell
  * or WiFi. If neither is available, it does NOT attempt to
  * switch them on.
  *
  * {@hide}
  */
 public class NetworkLocationProvider extends LocationProviderImpl {
     private static final String TAG = "NetworkLocationProvider";

     // Wait at least 60 seconds between network queries
     private static final int MIN_NETWORK_RETRY_MILLIS = 60000;

     // Max time to wait for radio update
     private static final long MAX_TIME_TO_WAIT_FOR_RADIO = 5 * 1000; // 5 seconds

     // State of entire provider
     private int mStatus = AVAILABLE;
     private long mStatusUpdateTime = 0;

     // Network state
     private int mNetworkState = TEMPORARILY_UNAVAILABLE;

     // Cell state
     private static final int MAX_CELL_HISTORY_TO_KEEP = 4;
     private LinkedList<CellState> mCellHistory = new LinkedList<CellState>();
     private CellState mCellState = null;
     private long mLastCellStateChangeTime = 0;
     private long mLastCellLockTime = 0;

     // Wifi state
     private static final long MIN_TIME_BETWEEN_WIFI_REPORTS = 45 * 1000; // 45 seconds
     private List<ScanResult> mWifiLastScanResults = null;
     private long mLastWifiScanTriggerTime = 0;
     private long mLastWifiScanElapsedTime = 0;
     private long mLastWifiScanRealTime = 0;
     private long mWifiScanFrequency = MIN_TIME_BETWEEN_WIFI_REPORTS;
     private boolean mWifiEnabled = false;

     // Last known location state
     private Location mLocation = new Location(LocationManager.NETWORK_PROVIDER);
     private long mLastNetworkQueryTime = 0;  // Last network request, successful or not
     private long mLastSuccessfulNetworkQueryTime = 0; // Last successful network query time

     // Is provider enabled by user -- ignored by this class
     private boolean mEnabled;

     // Is provider being used by an application
     private HashSet<String> mApplications = new HashSet<String>();
     private boolean mTracking = false;

     // Location masf service
     private LocationMasfClient mMasfClient;

     // Context of location manager service
     private Context mContext;

     public static boolean isSupported() {
         // This class provides a Google-specific location feature, so it's enabled only
         // when the system property ro.com.google.locationfeatures  is set.
         if (!SystemProperties.get("ro.com.google.locationfeatures").equals("1")) {
             return false;
         }

         // Otherwise, assume cell location should work if we are not running in the emulator
         return !SystemProperties.get("ro.kernel.qemu").equals("1");
     }

     public NetworkLocationProvider(Context context, LocationMasfClient masfClient) {
         super(LocationManager.NETWORK_PROVIDER);
         mContext = context;
         mMasfClient = masfClient;
     }

     @Override
     public void updateNetworkState(int state) {
         if (state == mNetworkState) {
             return;
         }
         log("updateNetworkState(): Updating network state to " + state);
         mNetworkState = state;

         updateStatus(mNetworkState);
     }

     @Override
     public void updateCellState(CellState newState) {
         if (newState == null) {
             log("updateCellState(): Cell state is invalid");
             return;
         }

         if (mCellState != null && mCellState.equals(newState)) {
             log("updateCellState(): Cell state is the same");
             return;
         }

         // Add previous state to history
         if ((mCellState != null) && mCellState.isValid()) {
             if (mCellHistory.size() >= MAX_CELL_HISTORY_TO_KEEP) {
                 mCellHistory.remove(0);
             }
             mCellHistory.add(mCellState);
         }

         mCellState = newState;
         log("updateCellState(): Received");

         mLastCellLockTime = 0;
         mLastCellStateChangeTime = SystemClock.elapsedRealtime();
     }

     public void updateCellLockStatus(boolean acquired) {
         if (acquired) {
             mLastCellLockTime = SystemClock.elapsedRealtime();
         } else {
             mLastCellLockTime = 0;
         }
     }

     @Override
     public boolean requiresNetwork() {
         return true;
     }

     @Override
     public boolean requiresSatellite() {
         return false;
     }

     @Override
     public boolean requiresCell() {
         return true;
     }

     @Override
     public boolean hasMonetaryCost() {
         return true;
     }

     @Override
     public boolean supportsAltitude() {
         return false;
     }

     @Override
     public boolean supportsSpeed() {
         return false;
     }

     @Override
     public boolean supportsBearing() {
         return false;
     }

     @Override
     public int getPowerRequirement() {
         return Criteria.POWER_LOW;
     }

     @Override
     public void enable() {
         // Nothing else needs to be done
         mEnabled = true;
     }

     @Override
     public void disable() {
         // Nothing else needs to be done
         mEnabled = false;
     }

     @Override
     public boolean isEnabled() {
         return mEnabled;
     }

     @Override
     public int getAccuracy() {
         return Criteria.ACCURACY_COARSE;
     }

     @Override
     public int getStatus(Bundle extras) {
         return mStatus;
     }

     @Override
     public long getStatusUpdateTime() {
         return mStatusUpdateTime;
     }

     @Override
     public void setMinTime(long minTime) {
         if (minTime < MIN_TIME_BETWEEN_WIFI_REPORTS) {
             mWifiScanFrequency = MIN_TIME_BETWEEN_WIFI_REPORTS;
         } else {
             mWifiScanFrequency = minTime;
         }
         super.setMinTime(minTime);
     }

     @Override
     public boolean getLocation(Location l) {

         long now = SystemClock.elapsedRealtime();

         // Trigger a wifi scan and wait for its results if necessary
         if ((mWifiEnabled) &&
             (mWifiLastScanResults == null ||
                 ((now - mLastWifiScanElapsedTime) > mWifiScanFrequency))) {

             boolean fallback = false;

             // If scan has been recently triggered
             if (mLastWifiScanTriggerTime != 0 &&
                 ((now - mLastWifiScanTriggerTime) < mWifiScanFrequency)) {
                 if ((now - mLastWifiScanTriggerTime) > MAX_TIME_TO_WAIT_FOR_RADIO) {
                     // If no results from last trigger available, use cell results
                     // This will also trigger a new scan
                     log("getLocation(): falling back to cell");
                     fallback = true;
                 } else {
                     // Just wait for the Wifi results to be available
                     return false;
                 }
             }

             WifiManager wifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
             log("getLocation(): triggering a wifi scan");
             mLastWifiScanTriggerTime = now;
             boolean succeeded = wifiManager.startScan();
             if (!succeeded) {
                 log("getLocation(): wifi scan did not succeed");
                 // Wifi trigger failed, use cell results
                 fallback = true;
             }

             // Wait for scan results
             if (!fallback) {
                 return false;
             }
         }

         // If waiting for cell location
         if (mLastCellLockTime != 0 && ((now - mLastCellLockTime) < MAX_TIME_TO_WAIT_FOR_RADIO)) {
             return false;
         }

         // Update Location
         // 1) If there has been a cell state change
         // 2) If there was no successful reply for last network request
         if (mLastCellStateChangeTime > mLastNetworkQueryTime) {
             updateLocation();
             return false;

         } else if ((mLastNetworkQueryTime != 0)
             && (mLastNetworkQueryTime > mLastSuccessfulNetworkQueryTime)
             && ((now - mLastNetworkQueryTime) > MIN_NETWORK_RETRY_MILLIS)) {
             updateLocation();
             return false;
         }

         if (mLocation != null && mLocation.getAccuracy() > 0) {

             // We could have a Cell Id location which hasn't changed in a
             // while because we haven't switched towers so if the last location
             // time + mWifiScanFrequency is less than current time update the
             // locations time.
             long currentTime = System.currentTimeMillis();
             if ((mLocation.getTime() + mWifiScanFrequency) < currentTime) {
                 mLocation.setTime(currentTime);
             }
             l.set(mLocation);
             return true;
         } else {
             return false;
         }
     }

     @Override
     public void enableLocationTracking(boolean enable) {
         if (enable == mTracking) {
             return;
         }

         log("enableLocationTracking(): " + enable);
         mTracking = enable;

         if (!enable) {
             // When disabling the location provider, be sure to clear out old location
             clearLocation();
         } else {
             // When enabling provider, force location
             forceLocation();
         }
     }

     @Override
     public boolean isLocationTracking() {
         return mTracking;
     }

     /**
      * Notifies the provider that there are scan results available.
      *
      * @param scanResults list of wifi scan results
      */
     public void updateWifiScanResults(List<ScanResult> scanResults) {
         if (!mTracking) {
             return;
         }

         long now = SystemClock.elapsedRealtime();

         if (scanResults == null) {
             mWifiLastScanResults = null;
             mLastWifiScanElapsedTime = now;
             mLastWifiScanRealTime = System.currentTimeMillis();

             log("updateWifIScanResults(): NULL APs");

             // Force cell location since no wifi results available
             if (mWifiEnabled) {
                 mLastCellLockTime = 0;
                 mLastCellStateChangeTime = SystemClock.elapsedRealtime();
             }

         } else if ((mWifiLastScanResults == null)
             || (mWifiLastScanResults.size() <= 2 && scanResults.size() > mWifiLastScanResults.size())
             || ((now - mLastWifiScanElapsedTime) > mWifiScanFrequency)) {

             if (mWifiLastScanResults == null) {
                 mWifiLastScanResults = new ArrayList<ScanResult>();
             } else {
                 mWifiLastScanResults.clear();
             }
             mWifiLastScanResults.addAll(scanResults);
             mLastWifiScanElapsedTime = now;
             mLastWifiScanRealTime = System.currentTimeMillis();

             log("updateWifIScanResults(): " + mWifiLastScanResults.size() + " APs");
             updateLocation();

         }
     }

     /**
      * Notifies the provider if Wifi has been enabled or disabled
      * by the user
      *
      * @param enabled true if wifi is enabled; false otherwise
      */
     public void updateWifiEnabledState(boolean enabled) {
         mWifiEnabled = enabled;

         log("updateWifiEnabledState(): " + enabled);

         // Force location update
         forceLocation();
     }

     public void addListener(String[] applications) {
         if (applications != null) {
             for (String app : applications) {
                 String a = app.replaceAll("com.google.android.", "");
                 a = a.replaceAll("com.android.", "");
                 mApplications.add(a);
                 log("addListener(): " + a);
             }
         }
     }

     public void removeListener(String[] applications) {
         if (applications != null) {
             for (String app : applications) {
                 String a = app.replaceAll("com.google.android.", "");
                 a = a.replaceAll("com.android.", "");
                 mApplications.remove(a);
                 log("removeListener(): " + a);
             }
         }
     }

     private void clearLocation() {
         mLocation.setAccuracy(-1);
         updateStatus(TEMPORARILY_UNAVAILABLE);
     }

     private void forceLocation() {
         if (mWifiEnabled) {
             // Force another wifi scan
             mWifiLastScanResults = null;
             mLastWifiScanTriggerTime = 0;
             mLastWifiScanElapsedTime = 0;
             mLastWifiScanRealTime = 0;
         } else {
             // Force another cell location request
             mLastCellLockTime = 0;
             mLastCellStateChangeTime = SystemClock.elapsedRealtime();
         }
     }

     private void updateStatus(int status) {
         if (status != mStatus) {
             mStatus = status;
             mStatusUpdateTime = SystemClock.elapsedRealtime();
         }
     }

     /**
      * Gets location from the server is applications are tracking this provider
      *
      */
     private void updateLocation() {

         // If not being tracked, no need to do anything.
         if (!mTracking) {
             return;
         }

         // If network is not available, can't do anything
         if (mNetworkState != AVAILABLE) {
             return;
         }

         final long now = SystemClock.elapsedRealtime();

         // There is a pending network request
         if ((mLastNetworkQueryTime != 0) &&
             (mLastNetworkQueryTime > mLastSuccessfulNetworkQueryTime) &&
             ((now - mLastNetworkQueryTime) <= MIN_NETWORK_RETRY_MILLIS)) {
             return;
         }

         // Don't include wifi points if they're too old
         List<ScanResult> scanResults = null;
         if (mWifiEnabled && (mWifiLastScanResults != null &&
             ((now - mLastWifiScanElapsedTime) < (mWifiScanFrequency + MAX_TIME_TO_WAIT_FOR_RADIO)))) {
             scanResults = mWifiLastScanResults;
         }

         // If no valid cell information available
         boolean noCell = mCellState == null || !mCellState.isValid();

         // If no valid wifi information available
         boolean noWifi = scanResults == null || (scanResults.size() == 0);

         // If no cell-id or wi-fi update, just return invalid location
         if (noCell && noWifi) {
             clearLocation();
             return;
         }

         // What kind of a network location request was it
         int trigger;
         if (!mWifiEnabled) {
             if (!noCell) {
                 trigger = GDebugProfile.TRIGGER_CELL_AND_WIFI_CHANGE;
             } else {
                 trigger = GDebugProfile.TRIGGER_WIFI_CHANGE;
             }
         } else {
             trigger = GDebugProfile.TRIGGER_CELL_CHANGE;
         }

         try {
             mLastNetworkQueryTime = now;
             mMasfClient.getNetworkLocation(mApplications, trigger, mCellState, mCellHistory,
                 scanResults, mLastWifiScanRealTime, new Callback() {
                 public void locationReceived(Location location, boolean networkSuccessful) {
                     // If location is valid and not the same as previously known location
                     if ((location != null) && (location.getAccuracy() > 0) &&
                         (location.getTime() != mLocation.getTime())) {
                         mLocation.set(location);
                         updateStatus(AVAILABLE);
                     } else {
                         // Location is unavailable
                         clearLocation();
                     }

                     // Even if no location is available, network request could have succeeded
                     if (networkSuccessful) {
                         mLastSuccessfulNetworkQueryTime = SystemClock.elapsedRealtime();
                     }

                 }
             });
         } catch(Exception e) {
             Log.e(TAG, "updateLocation got exception:", e);
         }
     }

     public interface Callback {

         /**
          * Callback function to notify of a received network location
          *
          * @param location location object that is received. may be null if not a valid location
          * @param successful true if network query was successful, even if no location was found
          */
         void locationReceived(Location location, boolean successful);
     }

     private void log(String log) {
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, log);
         }
     }

 }
	/*
	* Copyright (C) 2007 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.internal.location;

	import com.android.internal.location.protocol.GDebugProfile;

	import java.util.ArrayList;
	import java.util.HashSet;
	import java.util.LinkedList;
	import java.util.List;

	import android.content.Context;
	import android.location.Criteria;
	import android.location.Location;
	import android.location.LocationManager;
	import android.location.LocationProviderImpl;
	import android.net.wifi.ScanResult;
	import android.net.wifi.WifiManager;
	import android.os.Bundle;
	import android.os.SystemClock;
	import android.os.SystemProperties;
	import android.util.Log;

	/**
	* A location provider which gets approximate location from Google's
	* database of cell-tower and wi-fi locations.
	*
	* <p> It is the responsibility of the LocationManagerService to
	* notify this class of any changes in the radio information
	* by calling {@link #updateCellState} and of data state
	* changes by calling {@link #updateNetworkState}
	*
	* <p> The LocationManagerService must also notify the provider
	* of Wifi updates using the {@link #updateWifiScanResults}
	* and {@link #updateWifiEnabledState}
	* methods.
	*
	* <p> The provider uses whichever radio is available - Cell
	* or WiFi. If neither is available, it does NOT attempt to
	* switch them on.
	*
	* {@hide}
	*/
	public class NetworkLocationProvider extends LocationProviderImpl {
	private static final String TAG = "NetworkLocationProvider";

	// Wait at least 60 seconds between network queries
	private static final int MIN_NETWORK_RETRY_MILLIS = 60000;

	// Max time to wait for radio update
	private static final long MAX_TIME_TO_WAIT_FOR_RADIO = 5 * 1000; // 5 seconds

	// State of entire provider
	private int mStatus = AVAILABLE;
	private long mStatusUpdateTime = 0;

	// Network state
	private int mNetworkState = TEMPORARILY_UNAVAILABLE;

	// Cell state
	private static final int MAX_CELL_HISTORY_TO_KEEP = 4;
	private LinkedList<CellState> mCellHistory = new LinkedList<CellState>();
	private CellState mCellState = null;
	private long mLastCellStateChangeTime = 0;
	private long mLastCellLockTime = 0;

	// Wifi state
	private static final long MIN_TIME_BETWEEN_WIFI_REPORTS = 45 * 1000; // 45 seconds
	private List<ScanResult> mWifiLastScanResults = null;
	private long mLastWifiScanTriggerTime = 0;
	private long mLastWifiScanElapsedTime = 0;
	private long mLastWifiScanRealTime = 0;
	private long mWifiScanFrequency = MIN_TIME_BETWEEN_WIFI_REPORTS;
	private boolean mWifiEnabled = false;

	// Last known location state
	private Location mLocation = new Location(LocationManager.NETWORK_PROVIDER);
	private long mLastNetworkQueryTime = 0; // Last network request, successful or not
	private long mLastSuccessfulNetworkQueryTime = 0; // Last successful network query time

	// Is provider enabled by user -- ignored by this class
	private boolean mEnabled;

	// Is provider being used by an application
	private HashSet<String> mApplications = new HashSet<String>();
	private boolean mTracking = false;

	// Location masf service
	private LocationMasfClient mMasfClient;

	// Context of location manager service
	private Context mContext;

	public static boolean isSupported() {
	// This class provides a Google-specific location feature, so it's enabled only
	// when the system property ro.com.google.locationfeatures is set.
	if (!SystemProperties.get("ro.com.google.locationfeatures").equals("1")) {
	return false;
	}

	// Otherwise, assume cell location should work if we are not running in the emulator
	return !SystemProperties.get("ro.kernel.qemu").equals("1");
	}

	public NetworkLocationProvider(Context context, LocationMasfClient masfClient) {
	super(LocationManager.NETWORK_PROVIDER);
	mContext = context;
	mMasfClient = masfClient;
	}

	@Override
	public void updateNetworkState(int state) {
	if (state == mNetworkState) {
	return;
	}
	log("updateNetworkState(): Updating network state to " + state);
	mNetworkState = state;

	updateStatus(mNetworkState);
	}

	@Override
	public void updateCellState(CellState newState) {
	if (newState == null) {
	log("updateCellState(): Cell state is invalid");
	return;
	}

	if (mCellState != null && mCellState.equals(newState)) {
	log("updateCellState(): Cell state is the same");
	return;
	}

	// Add previous state to history
	if ((mCellState != null) && mCellState.isValid()) {
	if (mCellHistory.size() >= MAX_CELL_HISTORY_TO_KEEP) {
	mCellHistory.remove(0);
	}
	mCellHistory.add(mCellState);
	}

	mCellState = newState;
	log("updateCellState(): Received");

	mLastCellLockTime = 0;
	mLastCellStateChangeTime = SystemClock.elapsedRealtime();
	}

	public void updateCellLockStatus(boolean acquired) {
	if (acquired) {
	mLastCellLockTime = SystemClock.elapsedRealtime();
	} else {
	mLastCellLockTime = 0;
	}
	}

	@Override
	public boolean requiresNetwork() {
	return true;
	}

	@Override
	public boolean requiresSatellite() {
	return false;
	}

	@Override
	public boolean requiresCell() {
	return true;
	}

	@Override
	public boolean hasMonetaryCost() {
	return true;
	}

	@Override
	public boolean supportsAltitude() {
	return false;
	}

	@Override
	public boolean supportsSpeed() {
	return false;
	}

	@Override
	public boolean supportsBearing() {
	return false;
	}

	@Override
	public int getPowerRequirement() {
	return Criteria.POWER_LOW;
	}

	@Override
	public void enable() {
	// Nothing else needs to be done
	mEnabled = true;
	}

	@Override
	public void disable() {
	// Nothing else needs to be done
	mEnabled = false;
	}

	@Override
	public boolean isEnabled() {
	return mEnabled;
	}

	@Override
	public int getAccuracy() {
	return Criteria.ACCURACY_COARSE;
	}

	@Override
	public int getStatus(Bundle extras) {
	return mStatus;
	}

	@Override
	public long getStatusUpdateTime() {
	return mStatusUpdateTime;
	}

	@Override
	public void setMinTime(long minTime) {
	if (minTime < MIN_TIME_BETWEEN_WIFI_REPORTS) {
	mWifiScanFrequency = MIN_TIME_BETWEEN_WIFI_REPORTS;
	} else {
	mWifiScanFrequency = minTime;
	}
	super.setMinTime(minTime);
	}

	@Override
	public boolean getLocation(Location l) {

	long now = SystemClock.elapsedRealtime();

	// Trigger a wifi scan and wait for its results if necessary
	if ((mWifiEnabled) &&
	(mWifiLastScanResults == null \|\|
	((now - mLastWifiScanElapsedTime) > mWifiScanFrequency))) {

	boolean fallback = false;

	// If scan has been recently triggered
	if (mLastWifiScanTriggerTime != 0 &&
	((now - mLastWifiScanTriggerTime) < mWifiScanFrequency)) {
	if ((now - mLastWifiScanTriggerTime) > MAX_TIME_TO_WAIT_FOR_RADIO) {
	// If no results from last trigger available, use cell results
	// This will also trigger a new scan
	log("getLocation(): falling back to cell");
	fallback = true;
	} else {
	// Just wait for the Wifi results to be available
	return false;
	}
	}

	WifiManager wifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
	log("getLocation(): triggering a wifi scan");
	mLastWifiScanTriggerTime = now;
	boolean succeeded = wifiManager.startScan();
	if (!succeeded) {
	log("getLocation(): wifi scan did not succeed");
	// Wifi trigger failed, use cell results
	fallback = true;
	}

	// Wait for scan results
	if (!fallback) {
	return false;
	}
	}

	// If waiting for cell location
	if (mLastCellLockTime != 0 && ((now - mLastCellLockTime) < MAX_TIME_TO_WAIT_FOR_RADIO)) {
	return false;
	}

	// Update Location
	// 1) If there has been a cell state change
	// 2) If there was no successful reply for last network request
	if (mLastCellStateChangeTime > mLastNetworkQueryTime) {
	updateLocation();
	return false;

	} else if ((mLastNetworkQueryTime != 0)
	&& (mLastNetworkQueryTime > mLastSuccessfulNetworkQueryTime)
	&& ((now - mLastNetworkQueryTime) > MIN_NETWORK_RETRY_MILLIS)) {
	updateLocation();
	return false;
	}

	if (mLocation != null && mLocation.getAccuracy() > 0) {

	// We could have a Cell Id location which hasn't changed in a
	// while because we haven't switched towers so if the last location
	// time + mWifiScanFrequency is less than current time update the
	// locations time.
	long currentTime = System.currentTimeMillis();
	if ((mLocation.getTime() + mWifiScanFrequency) < currentTime) {
	mLocation.setTime(currentTime);
	}
	l.set(mLocation);
	return true;
	} else {
	return false;
	}
	}

	@Override
	public void enableLocationTracking(boolean enable) {
	if (enable == mTracking) {
	return;
	}

	log("enableLocationTracking(): " + enable);
	mTracking = enable;

	if (!enable) {
	// When disabling the location provider, be sure to clear out old location
	clearLocation();
	} else {
	// When enabling provider, force location
	forceLocation();
	}
	}

	@Override
	public boolean isLocationTracking() {
	return mTracking;
	}

	/**
	* Notifies the provider that there are scan results available.
	*
	* @param scanResults list of wifi scan results
	*/
	public void updateWifiScanResults(List<ScanResult> scanResults) {
	if (!mTracking) {
	return;
	}

	long now = SystemClock.elapsedRealtime();

	if (scanResults == null) {
	mWifiLastScanResults = null;
	mLastWifiScanElapsedTime = now;
	mLastWifiScanRealTime = System.currentTimeMillis();

	log("updateWifIScanResults(): NULL APs");

	// Force cell location since no wifi results available
	if (mWifiEnabled) {
	mLastCellLockTime = 0;
	mLastCellStateChangeTime = SystemClock.elapsedRealtime();
	}

	} else if ((mWifiLastScanResults == null)
	\|\| (mWifiLastScanResults.size() <= 2 && scanResults.size() > mWifiLastScanResults.size())
	\|\| ((now - mLastWifiScanElapsedTime) > mWifiScanFrequency)) {

	if (mWifiLastScanResults == null) {
	mWifiLastScanResults = new ArrayList<ScanResult>();
	} else {
	mWifiLastScanResults.clear();
	}
	mWifiLastScanResults.addAll(scanResults);
	mLastWifiScanElapsedTime = now;
	mLastWifiScanRealTime = System.currentTimeMillis();

	log("updateWifIScanResults(): " + mWifiLastScanResults.size() + " APs");
	updateLocation();

	}
	}

	/**
	* Notifies the provider if Wifi has been enabled or disabled
	* by the user
	*
	* @param enabled true if wifi is enabled; false otherwise
	*/
	public void updateWifiEnabledState(boolean enabled) {
	mWifiEnabled = enabled;

	log("updateWifiEnabledState(): " + enabled);

	// Force location update
	forceLocation();
	}

	public void addListener(String[] applications) {
	if (applications != null) {
	for (String app : applications) {
	String a = app.replaceAll("com.google.android.", "");
	a = a.replaceAll("com.android.", "");
	mApplications.add(a);
	log("addListener(): " + a);
	}
	}
	}

	public void removeListener(String[] applications) {
	if (applications != null) {
	for (String app : applications) {
	String a = app.replaceAll("com.google.android.", "");
	a = a.replaceAll("com.android.", "");
	mApplications.remove(a);
	log("removeListener(): " + a);
	}
	}
	}

	private void clearLocation() {
	mLocation.setAccuracy(-1);
	updateStatus(TEMPORARILY_UNAVAILABLE);
	}

	private void forceLocation() {
	if (mWifiEnabled) {
	// Force another wifi scan
	mWifiLastScanResults = null;
	mLastWifiScanTriggerTime = 0;
	mLastWifiScanElapsedTime = 0;
	mLastWifiScanRealTime = 0;
	} else {
	// Force another cell location request
	mLastCellLockTime = 0;
	mLastCellStateChangeTime = SystemClock.elapsedRealtime();
	}
	}

	private void updateStatus(int status) {
	if (status != mStatus) {
	mStatus = status;
	mStatusUpdateTime = SystemClock.elapsedRealtime();
	}
	}

	/**
	* Gets location from the server is applications are tracking this provider
	*
	*/
	private void updateLocation() {

	// If not being tracked, no need to do anything.
	if (!mTracking) {
	return;
	}

	// If network is not available, can't do anything
	if (mNetworkState != AVAILABLE) {
	return;
	}

	final long now = SystemClock.elapsedRealtime();

	// There is a pending network request
	if ((mLastNetworkQueryTime != 0) &&
	(mLastNetworkQueryTime > mLastSuccessfulNetworkQueryTime) &&
	((now - mLastNetworkQueryTime) <= MIN_NETWORK_RETRY_MILLIS)) {
	return;
	}

	// Don't include wifi points if they're too old
	List<ScanResult> scanResults = null;
	if (mWifiEnabled && (mWifiLastScanResults != null &&
	((now - mLastWifiScanElapsedTime) < (mWifiScanFrequency + MAX_TIME_TO_WAIT_FOR_RADIO)))) {
	scanResults = mWifiLastScanResults;
	}

	// If no valid cell information available
	boolean noCell = mCellState == null \|\| !mCellState.isValid();

	// If no valid wifi information available
	boolean noWifi = scanResults == null \|\| (scanResults.size() == 0);

	// If no cell-id or wi-fi update, just return invalid location
	if (noCell && noWifi) {
	clearLocation();
	return;
	}

	// What kind of a network location request was it
	int trigger;
	if (!mWifiEnabled) {
	if (!noCell) {
	trigger = GDebugProfile.TRIGGER_CELL_AND_WIFI_CHANGE;
	} else {
	trigger = GDebugProfile.TRIGGER_WIFI_CHANGE;
	}
	} else {
	trigger = GDebugProfile.TRIGGER_CELL_CHANGE;
	}

	try {
	mLastNetworkQueryTime = now;
	mMasfClient.getNetworkLocation(mApplications, trigger, mCellState, mCellHistory,
	scanResults, mLastWifiScanRealTime, new Callback() {
	public void locationReceived(Location location, boolean networkSuccessful) {
	// If location is valid and not the same as previously known location
	if ((location != null) && (location.getAccuracy() > 0) &&
	(location.getTime() != mLocation.getTime())) {
	mLocation.set(location);
	updateStatus(AVAILABLE);
	} else {
	// Location is unavailable
	clearLocation();
	}

	// Even if no location is available, network request could have succeeded
	if (networkSuccessful) {
	mLastSuccessfulNetworkQueryTime = SystemClock.elapsedRealtime();
	}

	}
	});
	} catch(Exception e) {
	Log.e(TAG, "updateLocation got exception:", e);
	}
	}

	public interface Callback {

	/**
	* Callback function to notify of a received network location
	*
	* @param location location object that is received. may be null if not a valid location
	* @param successful true if network query was successful, even if no location was found
	*/
	void locationReceived(Location location, boolean successful);
	}

	private void log(String log) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, log);
	}
	}

	}