services/tests/servicestests/src/com/android/server/location/LocationBasedCountryDetectorTest.java - platform/frameworks/base - Git at Google

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

 import android.location.Country;
 import android.location.CountryListener;
 import android.location.Location;
 import android.location.LocationListener;
 import android.location.LocationManager;
 import android.test.AndroidTestCase;

 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
 import java.util.Timer;

 public class LocationBasedCountryDetectorTest extends AndroidTestCase {
     private static final List<String> sEnabledProviders = Arrays.asList(
             LocationManager.GPS_PROVIDER, LocationManager.PASSIVE_PROVIDER);
     private class TestCountryDetector extends LocationBasedCountryDetector {
         public static final int TOTAL_PROVIDERS = 2;
         protected Object countryFoundLocker = new Object();
         protected boolean notifyCountry = false;
         private final Location mLocation;
         private final String mCountry;
         private final long mQueryLocationTimeout;
         private Map<String, LocationListener> mListeners;

         public TestCountryDetector(String country, String provider) {
             this(country, provider, 1000 * 60 * 5);
         }

         public TestCountryDetector(String country, String provider, long queryLocationTimeout) {
             super(getContext());
             mCountry = country;
             mLocation = new Location(provider);
             mQueryLocationTimeout = queryLocationTimeout;
             mListeners = new HashMap<String, LocationListener>();
         }

         @Override
         protected String getCountryFromLocation(Location location) {
             synchronized (countryFoundLocker) {
                 if (!notifyCountry) {
                     try {
                         countryFoundLocker.wait();
                     } catch (InterruptedException e) {
                     }
                 }
             }
             if (mLocation.getProvider().endsWith(location.getProvider())) {
                 return mCountry;
             } else {
                 return null;
             }
         }

         @Override
         protected Location getLastKnownLocation() {
             return mLocation;
         }

         private Set<String> mAcceptableProviders;

         public void setAcceptableProvider(Set<String> acceptableProviders) {
             mAcceptableProviders = acceptableProviders;
         }

         @Override
         protected boolean isAcceptableProvider(String provider) {
             if (mAcceptableProviders != null) {
                 return mAcceptableProviders.contains(provider);
             } else {
                 return true;
             }
         }

         @Override
         protected void registerListener(String provider, LocationListener listener) {
             assertNotNull(provider);
             mListeners.put(provider, listener);
         }

         @Override
         protected void unregisterListener(LocationListener listener) {
             for (Entry<String, LocationListener> entry : mListeners.entrySet()) {
                 if (entry.getValue().equals(listener)) {
                     mListeners.remove(entry.getKey());
                     return;
                 }
             }
             fail("Not registered");
         }

         public Map<String, LocationListener> getListeners() {
             return mListeners;
         }

         @Override
         protected long getQueryLocationTimeout() {
             return mQueryLocationTimeout;
         }

         @Override
         protected List<String> getEnabledProviders() {
             return sEnabledProviders;
         }

         public void notifyLocationFound() {
             // Listener could be removed in the notification.
             LocationListener[] listeners = new LocationListener[mListeners.size()];
             mLocationListeners.toArray(listeners);
             for (LocationListener listener :listeners) {
                 listener.onLocationChanged(mLocation);
             }
         }

         public int getListenersCount() {
             return mListeners.size();
         }

         public void notifyCountryFound() {
             synchronized (countryFoundLocker) {
                 notifyCountry = true;
                 countryFoundLocker.notify();
             }
         }

         public Timer getTimer() {
             return mTimer;
         }

         public Thread getQueryThread() {
             return mQueryThread;
         }
     }

     private class CountryListenerImpl implements CountryListener {
         private boolean mNotified;
         private String mCountryCode;
         public void onCountryDetected(Country country) {
             mNotified = true;
             if (country != null) {
                 mCountryCode = country.getCountryIso();
             }
         }

         public boolean notified() {
             return mNotified;
         }

         public String getCountry() {
             return mCountryCode;
         }
     }

     public void testFindingCountry() {
         testFindingCountryCommon(null);
     }

     public void testFindingCountryWithAcceptableProvider() {
         testFindingCountryCommon(new HashSet<String>(Arrays.asList("passive")));
     }

     private void testFindingCountryCommon(Set<String> acceptableProviders) {
         final String country = "us";
         final String provider = "Good";
         CountryListenerImpl countryListener = new CountryListenerImpl();
         TestCountryDetector detector = new TestCountryDetector(country, provider);

         if (acceptableProviders != null) {
             detector.setAcceptableProvider(acceptableProviders);
         }

         detector.setCountryListener(countryListener);
         detector.detectCountry();

         if (acceptableProviders != null) {
             assertEquals(acceptableProviders.size(), detector.getListenersCount());
             Map<String, LocationListener> listeners = detector.getListeners();
             for (String acceptableProvider : acceptableProviders) {
                 assertTrue(listeners.containsKey(acceptableProvider));
             }
         } else {
             assertEquals(TestCountryDetector.TOTAL_PROVIDERS, detector.getListenersCount());
         }

         detector.notifyLocationFound();
         // All listeners should be unregistered
         assertEquals(0, detector.getListenersCount());
         assertNull(detector.getTimer());
         Thread queryThread = waitForQueryThreadLaunched(detector);
         detector.notifyCountryFound();
         // Wait for query thread ending
         waitForThreadEnding(queryThread);
         // QueryThread should be set to NULL
         assertNull(detector.getQueryThread());
         assertTrue(countryListener.notified());
         assertEquals(countryListener.getCountry(), country);
     }

     public void testFindingCountryCancelled() {
         final String country = "us";
         final String provider = "Good";
         CountryListenerImpl countryListener = new CountryListenerImpl();
         TestCountryDetector detector = new TestCountryDetector(country, provider);
         detector.setCountryListener(countryListener);
         detector.detectCountry();
         assertEquals(TestCountryDetector.TOTAL_PROVIDERS, detector.getListenersCount());
         detector.notifyLocationFound();
         // All listeners should be unregistered
         assertEquals(0, detector.getListenersCount());
         // The time should be stopped
         assertNull(detector.getTimer());
         Thread queryThread = waitForQueryThreadLaunched(detector);
         detector.stop();
         // There is no way to stop the thread, let's test it could be stopped, after get country
         detector.notifyCountryFound();
         // Wait for query thread ending
         waitForThreadEnding(queryThread);
         // QueryThread should be set to NULL
         assertNull(detector.getQueryThread());
         assertTrue(countryListener.notified());
         assertEquals(countryListener.getCountry(), country);
     }

     public void testFindingLocationCancelled() {
         final String country = "us";
         final String provider = "Good";
         CountryListenerImpl countryListener = new CountryListenerImpl();
         TestCountryDetector detector = new TestCountryDetector(country, provider);
         detector.setCountryListener(countryListener);
         detector.detectCountry();
         assertEquals(TestCountryDetector.TOTAL_PROVIDERS, detector.getListenersCount());
         detector.stop();
         // All listeners should be unregistered
         assertEquals(0, detector.getListenersCount());
         // The time should be stopped
         assertNull(detector.getTimer());
         // QueryThread should still be NULL
         assertNull(detector.getQueryThread());
         assertFalse(countryListener.notified());
     }

     public void testFindingLocationFailed() {
         final String country = "us";
         final String provider = "Good";
         long timeout = 1000;
         TestCountryDetector detector = new TestCountryDetector(country, provider, timeout) {
             @Override
             protected Location getLastKnownLocation() {
                 return null;
             }
         };
         CountryListenerImpl countryListener = new CountryListenerImpl();
         detector.setCountryListener(countryListener);
         detector.detectCountry();
         assertEquals(TestCountryDetector.TOTAL_PROVIDERS, detector.getListenersCount());
         waitForTimerReset(detector);
         // All listeners should be unregistered
         assertEquals(0, detector.getListenersCount());
         // QueryThread should still be NULL
         assertNull(detector.getQueryThread());
         assertTrue(countryListener.notified());
         assertNull(countryListener.getCountry());
     }

     public void testFindingCountryFailed() {
         final String country = "us";
         final String provider = "Good";
         TestCountryDetector detector = new TestCountryDetector(country, provider) {
             @Override
             protected String getCountryFromLocation(Location location) {
                 synchronized (countryFoundLocker) {
                     if (! notifyCountry) {
                         try {
                             countryFoundLocker.wait();
                         } catch (InterruptedException e) {
                         }
                     }
                 }
                 // We didn't find country.
                 return null;
             }
         };
         CountryListenerImpl countryListener = new CountryListenerImpl();
         detector.setCountryListener(countryListener);
         detector.detectCountry();
         assertEquals(TestCountryDetector.TOTAL_PROVIDERS, detector.getListenersCount());
         detector.notifyLocationFound();
         // All listeners should be unregistered
         assertEquals(0, detector.getListenersCount());
         assertNull(detector.getTimer());
         Thread queryThread = waitForQueryThreadLaunched(detector);
         detector.notifyCountryFound();
         // Wait for query thread ending
         waitForThreadEnding(queryThread);
         // QueryThread should be set to NULL
         assertNull(detector.getQueryThread());
         // CountryListener should be notified
         assertTrue(countryListener.notified());
         assertNull(countryListener.getCountry());
     }

     public void testFindingCountryWithLastKnownLocation() {
         final String country = "us";
         final String provider = "Good";
         long timeout = 1000;
         TestCountryDetector detector = new TestCountryDetector(country, provider, timeout);
         CountryListenerImpl countryListener = new CountryListenerImpl();
         detector.setCountryListener(countryListener);
         detector.detectCountry();
         assertEquals(TestCountryDetector.TOTAL_PROVIDERS, detector.getListenersCount());
         waitForTimerReset(detector);
         // All listeners should be unregistered
         assertEquals(0, detector.getListenersCount());
         Thread queryThread = waitForQueryThreadLaunched(detector);
         detector.notifyCountryFound();
         // Wait for query thread ending
         waitForThreadEnding(queryThread);
         // QueryThread should be set to NULL
         assertNull(detector.getQueryThread());
         // CountryListener should be notified
         assertTrue(countryListener.notified());
         assertEquals(countryListener.getCountry(), country);
     }

     private void waitForTimerReset(TestCountryDetector detector) {
         int count = 5;
         long interval = 1000;
         try {
             while (count-- > 0 && detector.getTimer() != null) {
                 Thread.sleep(interval);
             }
         } catch (InterruptedException e) {
         }
         Timer timer = detector.getTimer();
         assertTrue(timer == null);
     }

     private void waitForThreadEnding(Thread thread) {
         try {
             thread.join(5000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }

     private Thread waitForQueryThreadLaunched(TestCountryDetector detector) {
         int count = 5;
         long interval = 1000;
         try {
             while (count-- > 0 && detector.getQueryThread() == null) {
                 Thread.sleep(interval);
             }
         } catch (InterruptedException e) {
         }
         Thread thread = detector.getQueryThread();
         assertTrue(thread != null);
         return thread;
     }
 }
	/*
	* Copyright (C) 2010 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.server.location;

	import android.location.Country;
	import android.location.CountryListener;
	import android.location.Location;
	import android.location.LocationListener;
	import android.location.LocationManager;
	import android.test.AndroidTestCase;

	import java.util.Arrays;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Map.Entry;
	import java.util.Set;
	import java.util.Timer;

	public class LocationBasedCountryDetectorTest extends AndroidTestCase {
	private static final List<String> sEnabledProviders = Arrays.asList(
	LocationManager.GPS_PROVIDER, LocationManager.PASSIVE_PROVIDER);
	private class TestCountryDetector extends LocationBasedCountryDetector {
	public static final int TOTAL_PROVIDERS = 2;
	protected Object countryFoundLocker = new Object();
	protected boolean notifyCountry = false;
	private final Location mLocation;
	private final String mCountry;
	private final long mQueryLocationTimeout;
	private Map<String, LocationListener> mListeners;

	public TestCountryDetector(String country, String provider) {
	this(country, provider, 1000 * 60 * 5);
	}

	public TestCountryDetector(String country, String provider, long queryLocationTimeout) {
	super(getContext());
	mCountry = country;
	mLocation = new Location(provider);
	mQueryLocationTimeout = queryLocationTimeout;
	mListeners = new HashMap<String, LocationListener>();
	}

	@Override
	protected String getCountryFromLocation(Location location) {
	synchronized (countryFoundLocker) {
	if (!notifyCountry) {
	try {
	countryFoundLocker.wait();
	} catch (InterruptedException e) {
	}
	}
	}
	if (mLocation.getProvider().endsWith(location.getProvider())) {
	return mCountry;
	} else {
	return null;
	}
	}

	@Override
	protected Location getLastKnownLocation() {
	return mLocation;
	}

	private Set<String> mAcceptableProviders;

	public void setAcceptableProvider(Set<String> acceptableProviders) {
	mAcceptableProviders = acceptableProviders;
	}

	@Override
	protected boolean isAcceptableProvider(String provider) {
	if (mAcceptableProviders != null) {
	return mAcceptableProviders.contains(provider);
	} else {
	return true;
	}
	}

	@Override
	protected void registerListener(String provider, LocationListener listener) {
	assertNotNull(provider);
	mListeners.put(provider, listener);
	}

	@Override
	protected void unregisterListener(LocationListener listener) {
	for (Entry<String, LocationListener> entry : mListeners.entrySet()) {
	if (entry.getValue().equals(listener)) {
	mListeners.remove(entry.getKey());
	return;
	}
	}
	fail("Not registered");
	}

	public Map<String, LocationListener> getListeners() {
	return mListeners;
	}

	@Override
	protected long getQueryLocationTimeout() {
	return mQueryLocationTimeout;
	}

	@Override
	protected List<String> getEnabledProviders() {
	return sEnabledProviders;
	}

	public void notifyLocationFound() {
	// Listener could be removed in the notification.
	LocationListener[] listeners = new LocationListener[mListeners.size()];
	mLocationListeners.toArray(listeners);
	for (LocationListener listener :listeners) {
	listener.onLocationChanged(mLocation);
	}
	}

	public int getListenersCount() {
	return mListeners.size();
	}

	public void notifyCountryFound() {
	synchronized (countryFoundLocker) {
	notifyCountry = true;
	countryFoundLocker.notify();
	}
	}

	public Timer getTimer() {
	return mTimer;
	}

	public Thread getQueryThread() {
	return mQueryThread;
	}
	}

	private class CountryListenerImpl implements CountryListener {
	private boolean mNotified;
	private String mCountryCode;
	public void onCountryDetected(Country country) {
	mNotified = true;
	if (country != null) {
	mCountryCode = country.getCountryIso();
	}
	}

	public boolean notified() {
	return mNotified;
	}

	public String getCountry() {
	return mCountryCode;
	}
	}

	public void testFindingCountry() {
	testFindingCountryCommon(null);
	}

	public void testFindingCountryWithAcceptableProvider() {
	testFindingCountryCommon(new HashSet<String>(Arrays.asList("passive")));
	}

	private void testFindingCountryCommon(Set<String> acceptableProviders) {
	final String country = "us";
	final String provider = "Good";
	CountryListenerImpl countryListener = new CountryListenerImpl();
	TestCountryDetector detector = new TestCountryDetector(country, provider);

	if (acceptableProviders != null) {
	detector.setAcceptableProvider(acceptableProviders);
	}

	detector.setCountryListener(countryListener);
	detector.detectCountry();

	if (acceptableProviders != null) {
	assertEquals(acceptableProviders.size(), detector.getListenersCount());
	Map<String, LocationListener> listeners = detector.getListeners();
	for (String acceptableProvider : acceptableProviders) {
	assertTrue(listeners.containsKey(acceptableProvider));
	}
	} else {
	assertEquals(TestCountryDetector.TOTAL_PROVIDERS, detector.getListenersCount());
	}

	detector.notifyLocationFound();
	// All listeners should be unregistered
	assertEquals(0, detector.getListenersCount());
	assertNull(detector.getTimer());
	Thread queryThread = waitForQueryThreadLaunched(detector);
	detector.notifyCountryFound();
	// Wait for query thread ending
	waitForThreadEnding(queryThread);
	// QueryThread should be set to NULL
	assertNull(detector.getQueryThread());
	assertTrue(countryListener.notified());
	assertEquals(countryListener.getCountry(), country);
	}

	public void testFindingCountryCancelled() {
	final String country = "us";
	final String provider = "Good";
	CountryListenerImpl countryListener = new CountryListenerImpl();
	TestCountryDetector detector = new TestCountryDetector(country, provider);
	detector.setCountryListener(countryListener);
	detector.detectCountry();
	assertEquals(TestCountryDetector.TOTAL_PROVIDERS, detector.getListenersCount());
	detector.notifyLocationFound();
	// All listeners should be unregistered
	assertEquals(0, detector.getListenersCount());
	// The time should be stopped
	assertNull(detector.getTimer());
	Thread queryThread = waitForQueryThreadLaunched(detector);
	detector.stop();
	// There is no way to stop the thread, let's test it could be stopped, after get country
	detector.notifyCountryFound();
	// Wait for query thread ending
	waitForThreadEnding(queryThread);
	// QueryThread should be set to NULL
	assertNull(detector.getQueryThread());
	assertTrue(countryListener.notified());
	assertEquals(countryListener.getCountry(), country);
	}

	public void testFindingLocationCancelled() {
	final String country = "us";
	final String provider = "Good";
	CountryListenerImpl countryListener = new CountryListenerImpl();
	TestCountryDetector detector = new TestCountryDetector(country, provider);
	detector.setCountryListener(countryListener);
	detector.detectCountry();
	assertEquals(TestCountryDetector.TOTAL_PROVIDERS, detector.getListenersCount());
	detector.stop();
	// All listeners should be unregistered
	assertEquals(0, detector.getListenersCount());
	// The time should be stopped
	assertNull(detector.getTimer());
	// QueryThread should still be NULL
	assertNull(detector.getQueryThread());
	assertFalse(countryListener.notified());
	}

	public void testFindingLocationFailed() {
	final String country = "us";
	final String provider = "Good";
	long timeout = 1000;
	TestCountryDetector detector = new TestCountryDetector(country, provider, timeout) {
	@Override
	protected Location getLastKnownLocation() {
	return null;
	}
	};
	CountryListenerImpl countryListener = new CountryListenerImpl();
	detector.setCountryListener(countryListener);
	detector.detectCountry();
	assertEquals(TestCountryDetector.TOTAL_PROVIDERS, detector.getListenersCount());
	waitForTimerReset(detector);
	// All listeners should be unregistered
	assertEquals(0, detector.getListenersCount());
	// QueryThread should still be NULL
	assertNull(detector.getQueryThread());
	assertTrue(countryListener.notified());
	assertNull(countryListener.getCountry());
	}

	public void testFindingCountryFailed() {
	final String country = "us";
	final String provider = "Good";
	TestCountryDetector detector = new TestCountryDetector(country, provider) {
	@Override
	protected String getCountryFromLocation(Location location) {
	synchronized (countryFoundLocker) {
	if (! notifyCountry) {
	try {
	countryFoundLocker.wait();
	} catch (InterruptedException e) {
	}
	}
	}
	// We didn't find country.
	return null;
	}
	};
	CountryListenerImpl countryListener = new CountryListenerImpl();
	detector.setCountryListener(countryListener);
	detector.detectCountry();
	assertEquals(TestCountryDetector.TOTAL_PROVIDERS, detector.getListenersCount());
	detector.notifyLocationFound();
	// All listeners should be unregistered
	assertEquals(0, detector.getListenersCount());
	assertNull(detector.getTimer());
	Thread queryThread = waitForQueryThreadLaunched(detector);
	detector.notifyCountryFound();
	// Wait for query thread ending
	waitForThreadEnding(queryThread);
	// QueryThread should be set to NULL
	assertNull(detector.getQueryThread());
	// CountryListener should be notified
	assertTrue(countryListener.notified());
	assertNull(countryListener.getCountry());
	}

	public void testFindingCountryWithLastKnownLocation() {
	final String country = "us";
	final String provider = "Good";
	long timeout = 1000;
	TestCountryDetector detector = new TestCountryDetector(country, provider, timeout);
	CountryListenerImpl countryListener = new CountryListenerImpl();
	detector.setCountryListener(countryListener);
	detector.detectCountry();
	assertEquals(TestCountryDetector.TOTAL_PROVIDERS, detector.getListenersCount());
	waitForTimerReset(detector);
	// All listeners should be unregistered
	assertEquals(0, detector.getListenersCount());
	Thread queryThread = waitForQueryThreadLaunched(detector);
	detector.notifyCountryFound();
	// Wait for query thread ending
	waitForThreadEnding(queryThread);
	// QueryThread should be set to NULL
	assertNull(detector.getQueryThread());
	// CountryListener should be notified
	assertTrue(countryListener.notified());
	assertEquals(countryListener.getCountry(), country);
	}

	private void waitForTimerReset(TestCountryDetector detector) {
	int count = 5;
	long interval = 1000;
	try {
	while (count-- > 0 && detector.getTimer() != null) {
	Thread.sleep(interval);
	}
	} catch (InterruptedException e) {
	}
	Timer timer = detector.getTimer();
	assertTrue(timer == null);
	}

	private void waitForThreadEnding(Thread thread) {
	try {
	thread.join(5000);
	} catch (InterruptedException e) {
	e.printStackTrace();
	}
	}

	private Thread waitForQueryThreadLaunched(TestCountryDetector detector) {
	int count = 5;
	long interval = 1000;
	try {
	while (count-- > 0 && detector.getQueryThread() == null) {
	Thread.sleep(interval);
	}
	} catch (InterruptedException e) {
	}
	Thread thread = detector.getQueryThread();
	assertTrue(thread != null);
	return thread;
	}
	}