core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/ConnectivityManagerTestActivity.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.connectivitymanagertest;

 import android.app.Activity;
 import android.content.Context;
 import android.content.BroadcastReceiver;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.os.Bundle;
 import android.provider.Settings;
 import android.util.Log;
 import java.util.List;
 import android.widget.LinearLayout;
 import android.net.ConnectivityManager;
 import android.net.NetworkInfo;
 import android.net.NetworkInfo.State;

 import android.net.wifi.WifiConfiguration;
 import android.net.wifi.WifiManager;
 import android.net.wifi.WifiInfo;
 import android.net.wifi.ScanResult;
 import android.net.wifi.WifiConfiguration.KeyMgmt;


 /**
  * An activity registered with connectivity manager broadcast
  * provides network connectivity information and
  * can be used to set device states: Cellular, Wifi, Airplane mode.
  */
 public class ConnectivityManagerTestActivity extends Activity {

     public static final String LOG_TAG = "ConnectivityManagerTestActivity";
     public static final int WAIT_FOR_SCAN_RESULT = 5 * 1000; //5 seconds
     public static final int WIFI_SCAN_TIMEOUT = 20 * 1000;
     public ConnectivityReceiver mConnectivityReceiver = null;
     public WifiReceiver mWifiReceiver = null;
     /*
      * Track network connectivity information
      */
     public State mState;
     public NetworkInfo mNetworkInfo;
     public NetworkInfo mOtherNetworkInfo;
     public boolean mIsFailOver;
     public String mReason;
     public boolean mScanResultIsAvailable = false;
     public ConnectivityManager mCM;
     public Object wifiObject = new Object();
     public Object connectivityObject = new Object();
     public int mWifiState;
     public NetworkInfo mWifiNetworkInfo;
     public String mBssid;

     /*
      * Control Wifi States
      */
     public WifiManager mWifiManager;

     /*
      * Verify connectivity state
      */
     public static final int NUM_NETWORK_TYPES = ConnectivityManager.MAX_NETWORK_TYPE + 1;
     NetworkState[] connectivityState = new NetworkState[NUM_NETWORK_TYPES];

     /**
      * A wrapper of a broadcast receiver which provides network connectivity information
      * for all kinds of network: wifi, mobile, etc.
      */
     private class ConnectivityReceiver extends BroadcastReceiver {
         @Override
         public void onReceive(Context context, Intent intent) {
             Log.v(LOG_TAG, "ConnectivityReceiver: onReceive() is called with " + intent);
             String action = intent.getAction();
             if (!action.equals(ConnectivityManager.CONNECTIVITY_ACTION)) {
                 Log.v("ConnectivityReceiver", "onReceive() called with " + intent);
                 return;
             }

             boolean noConnectivity =
                 intent.getBooleanExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY, false);

             if (noConnectivity) {
                 mState = State.DISCONNECTED;
             } else {
                 mState = State.CONNECTED;
             }

             mNetworkInfo = (NetworkInfo)
                 intent.getParcelableExtra(ConnectivityManager.EXTRA_NETWORK_INFO);

             mOtherNetworkInfo = (NetworkInfo)
                 intent.getParcelableExtra(ConnectivityManager.EXTRA_OTHER_NETWORK_INFO);

             mReason = intent.getStringExtra(ConnectivityManager.EXTRA_REASON);
             mIsFailOver = intent.getBooleanExtra(ConnectivityManager.EXTRA_IS_FAILOVER, false);

             Log.v(LOG_TAG, "mNetworkInfo: " + mNetworkInfo.toString());
             if (mOtherNetworkInfo != null) {
                 Log.v(LOG_TAG, "mOtherNetworkInfo: " + mOtherNetworkInfo.toString());
             }
             recordNetworkState(mNetworkInfo.getType(), mNetworkInfo.getState());
             if (mOtherNetworkInfo != null) {
                 recordNetworkState(mOtherNetworkInfo.getType(), mOtherNetworkInfo.getState());
             }
             notifyNetworkConnectivityChange();
         }
     }

     private class WifiReceiver extends BroadcastReceiver {
         @Override
         public void onReceive(Context context, Intent intent) {
             String action = intent.getAction();
             Log.v("WifiReceiver", "onReceive() is calleld with " + intent);
             if (action.equals(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION)) {
                 notifyScanResult();
             } else if (action.equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) {
                 mWifiNetworkInfo =
                     (NetworkInfo) intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
                 Log.v(LOG_TAG, "mWifiNetworkInfo: " + mWifiNetworkInfo.toString());
                 if (mWifiNetworkInfo.getState() == State.CONNECTED) {
                     mBssid = intent.getStringExtra(WifiManager.EXTRA_BSSID);
                 }
                 notifyWifiState();
             } else if (action.equals(WifiManager.WIFI_STATE_CHANGED_ACTION)) {
                 mWifiState = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE,
                                                 WifiManager.WIFI_STATE_UNKNOWN);
                 notifyWifiState();
             }
             else {
                 return;
             }
         }
     }

     public ConnectivityManagerTestActivity() {
         mState = State.UNKNOWN;
     }

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         Log.v(LOG_TAG, "onCreate, inst=" + Integer.toHexString(hashCode()));

         // Create a simple layout
         LinearLayout contentView = new LinearLayout(this);
         contentView.setOrientation(LinearLayout.VERTICAL);
         setContentView(contentView);
         setTitle("ConnectivityManagerTestActivity");


         // register a connectivity receiver for CONNECTIVITY_ACTION;
         mConnectivityReceiver = new ConnectivityReceiver();
         registerReceiver(mConnectivityReceiver,
                 new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION));

         mWifiReceiver = new WifiReceiver();
         IntentFilter mIntentFilter = new IntentFilter();
         mIntentFilter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);
         mIntentFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
         mIntentFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
         registerReceiver(mWifiReceiver, mIntentFilter);

         // Get an instance of ConnectivityManager
         mCM = (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
         // Get an instance of WifiManager
         mWifiManager =(WifiManager)getSystemService(Context.WIFI_SERVICE);
         initializeNetworkStates();

         if (mWifiManager.isWifiEnabled()) {
             Log.v(LOG_TAG, "Clear Wifi before we start the test.");
             clearWifi();
         }
      }

     // for each network type, initialize network states to UNKNOWN, and no verification flag is set
     public void initializeNetworkStates() {
         for (int networkType = NUM_NETWORK_TYPES - 1; networkType >=0; networkType--) {
             connectivityState[networkType] =  new NetworkState();
             Log.v(LOG_TAG, "Initialize network state for " + networkType + ": " +
                     connectivityState[networkType].toString());
         }
     }

     // deposit a network state
     public void recordNetworkState(int networkType, State networkState) {
         Log.v(LOG_TAG, "record network state for network " +  networkType +
                 ", state is " + networkState);
         connectivityState[networkType].recordState(networkState);
     }

     // set the state transition criteria
     public void setStateTransitionCriteria(int networkType, State initState,
             int transitionDir, State targetState) {
         connectivityState[networkType].setStateTransitionCriteria(
                 initState, transitionDir, targetState);
     }

     // Validate the states recorded
     public boolean validateNetworkStates(int networkType) {
         Log.v(LOG_TAG, "validate network state for " + networkType + ": ");
         return connectivityState[networkType].validateStateTransition();
     }

     // return result from network state validation
     public String getTransitionFailureReason(int networkType) {
         Log.v(LOG_TAG, "get network state transition failure reason for " + networkType + ": " +
                 connectivityState[networkType].toString());
         return connectivityState[networkType].getReason();
     }

     private void notifyNetworkConnectivityChange() {
         synchronized(connectivityObject) {
             Log.v(LOG_TAG, "notify network connectivity changed");
             connectivityObject.notifyAll();
         }
     }
     private void notifyScanResult() {
         synchronized (this) {
             Log.v(LOG_TAG, "notify that scan results are available");
             this.notify();
         }
     }

     public void notifyWifiState() {
         synchronized (wifiObject) {
             Log.v(LOG_TAG, "notify wifi state changed");
             wifiObject.notify();
         }
     }

     // Return true if device is currently connected to mobile network
     public boolean isConnectedToMobile() {
         return (mNetworkInfo.getType() == ConnectivityManager.TYPE_MOBILE);
     }

     // Return true if device is currently connected to Wifi
     public boolean isConnectedToWifi() {
         return (mNetworkInfo.getType() == ConnectivityManager.TYPE_WIFI);
     }

     public boolean enableWifi() {
         return mWifiManager.setWifiEnabled(true);
     }

     /**
      * Associate the device to given SSID
      * If the device is already associated with a WiFi, disconnect and forget it,
      * We don't verify whether the connection is successful or not, leave this to the test
      */
     public boolean connectToWifi(String knownSSID) {
         //If Wifi is not enabled, enable it
         if (!mWifiManager.isWifiEnabled()) {
             Log.v(LOG_TAG, "Wifi is not enabled, enable it");
             mWifiManager.setWifiEnabled(true);
         }

         List<ScanResult> netList = mWifiManager.getScanResults();
         if (netList == null) {
             // if no scan results are available, start active scan
             mWifiManager.startScanActive();
             mScanResultIsAvailable = false;
             long startTime = System.currentTimeMillis();
             while (!mScanResultIsAvailable) {
                 if ((System.currentTimeMillis() - startTime) > WIFI_SCAN_TIMEOUT) {
                     return false;
                 }
                 // wait for the scan results to be available
                 synchronized (this) {
                     // wait for the scan result to be available
                     try {
                         this.wait(WAIT_FOR_SCAN_RESULT);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                     if ((mWifiManager.getScanResults() == null) ||
                             (mWifiManager.getScanResults().size() <= 0)) {
                         continue;
                     }
                     mScanResultIsAvailable = true;
                 }
             }
         }

         netList = mWifiManager.getScanResults();
         for (int i = 0; i < netList.size(); i++) {
             ScanResult sr= netList.get(i);
             if (sr.SSID.equals(knownSSID)) {
                 Log.v(LOG_TAG, "found " + knownSSID + " in the scan result list");
                 WifiConfiguration config = new WifiConfiguration();
                 config.SSID = convertToQuotedString(sr.SSID);
                 config.allowedKeyManagement.set(KeyMgmt.NONE);
                 int networkId = mWifiManager.addNetwork(config);
                 // Connect to network by disabling others.
                 mWifiManager.enableNetwork(networkId, true);
                 mWifiManager.saveConfiguration();
                 mWifiManager.reconnect();
                 break;
            }
         }

         List<WifiConfiguration> netConfList = mWifiManager.getConfiguredNetworks();
         if (netConfList.size() <= 0) {
             Log.v(LOG_TAG, knownSSID + " is not available");
             return false;
         }
         return true;
     }

     /*
      * Disconnect from the current AP
      */
     public boolean disconnectAP() {
         if (mWifiManager.isWifiEnabled()) {
             //remove the current network Id
             WifiInfo curWifi = mWifiManager.getConnectionInfo();
             if (curWifi == null) {
                 return false;
             }
             int curNetworkId = curWifi.getNetworkId();
             mWifiManager.removeNetwork(curNetworkId);
             mWifiManager.saveConfiguration();

             // remove other saved networks
             List<WifiConfiguration> netConfList = mWifiManager.getConfiguredNetworks();
             if (netConfList != null) {
                 Log.v(LOG_TAG, "remove configured network ids");
                 for (int i = 0; i < netConfList.size(); i++) {
                     WifiConfiguration conf = new WifiConfiguration();
                     conf = netConfList.get(i);
                     mWifiManager.removeNetwork(conf.networkId);
                 }
             }
         }
         mWifiManager.saveConfiguration();
         return true;
     }
     /**
      * Disable Wifi
      * @return true if Wifi is disabled successfully
      */
     public boolean disableWifi() {
         return mWifiManager.setWifiEnabled(false);
     }

     /**
      * Disconnect from the current Wifi and clear the configuration list
      */
     public boolean clearWifi() {
             if (!disconnectAP()) {
                 return false;
             }
             // Disable Wifi
             if (!mWifiManager.setWifiEnabled(false)) {
                 return false;
             }
             // Wait for the actions to be completed
             try {
                 Thread.sleep(5*1000);
             } catch (InterruptedException e) {}
         return true;
     }

     /**
      * Set airplane mode
      */
     public void setAirplaneMode(Context context, boolean enableAM) {
         //set the airplane mode
         Settings.System.putInt(context.getContentResolver(), Settings.System.AIRPLANE_MODE_ON,
                 enableAM ? 1 : 0);
         // Post the intent
         Intent intent = new Intent(Intent.ACTION_AIRPLANE_MODE_CHANGED);
         intent.putExtra("state", enableAM);
         context.sendBroadcast(intent);
     }

     protected static String convertToQuotedString(String string) {
         return "\"" + string + "\"";
     }

     @Override
     protected void onDestroy() {
         super.onDestroy();

         //Unregister receiver
         if (mConnectivityReceiver != null) {
             unregisterReceiver(mConnectivityReceiver);
         }
         if (mWifiReceiver != null) {
             unregisterReceiver(mWifiReceiver);
         }
         Log.v(LOG_TAG, "onDestroy, inst=" + Integer.toHexString(hashCode()));
     }
 }
	/*
	* 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.connectivitymanagertest;

	import android.app.Activity;
	import android.content.Context;
	import android.content.BroadcastReceiver;
	import android.content.Intent;
	import android.content.IntentFilter;
	import android.os.Bundle;
	import android.provider.Settings;
	import android.util.Log;
	import java.util.List;
	import android.widget.LinearLayout;
	import android.net.ConnectivityManager;
	import android.net.NetworkInfo;
	import android.net.NetworkInfo.State;

	import android.net.wifi.WifiConfiguration;
	import android.net.wifi.WifiManager;
	import android.net.wifi.WifiInfo;
	import android.net.wifi.ScanResult;
	import android.net.wifi.WifiConfiguration.KeyMgmt;


	/**
	* An activity registered with connectivity manager broadcast
	* provides network connectivity information and
	* can be used to set device states: Cellular, Wifi, Airplane mode.
	*/
	public class ConnectivityManagerTestActivity extends Activity {

	public static final String LOG_TAG = "ConnectivityManagerTestActivity";
	public static final int WAIT_FOR_SCAN_RESULT = 5 * 1000; //5 seconds
	public static final int WIFI_SCAN_TIMEOUT = 20 * 1000;
	public ConnectivityReceiver mConnectivityReceiver = null;
	public WifiReceiver mWifiReceiver = null;
	/*
	* Track network connectivity information
	*/
	public State mState;
	public NetworkInfo mNetworkInfo;
	public NetworkInfo mOtherNetworkInfo;
	public boolean mIsFailOver;
	public String mReason;
	public boolean mScanResultIsAvailable = false;
	public ConnectivityManager mCM;
	public Object wifiObject = new Object();
	public Object connectivityObject = new Object();
	public int mWifiState;
	public NetworkInfo mWifiNetworkInfo;
	public String mBssid;

	/*
	* Control Wifi States
	*/
	public WifiManager mWifiManager;

	/*
	* Verify connectivity state
	*/
	public static final int NUM_NETWORK_TYPES = ConnectivityManager.MAX_NETWORK_TYPE + 1;
	NetworkState[] connectivityState = new NetworkState[NUM_NETWORK_TYPES];

	/**
	* A wrapper of a broadcast receiver which provides network connectivity information
	* for all kinds of network: wifi, mobile, etc.
	*/
	private class ConnectivityReceiver extends BroadcastReceiver {
	@Override
	public void onReceive(Context context, Intent intent) {
	Log.v(LOG_TAG, "ConnectivityReceiver: onReceive() is called with " + intent);
	String action = intent.getAction();
	if (!action.equals(ConnectivityManager.CONNECTIVITY_ACTION)) {
	Log.v("ConnectivityReceiver", "onReceive() called with " + intent);
	return;
	}

	boolean noConnectivity =
	intent.getBooleanExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY, false);

	if (noConnectivity) {
	mState = State.DISCONNECTED;
	} else {
	mState = State.CONNECTED;
	}

	mNetworkInfo = (NetworkInfo)
	intent.getParcelableExtra(ConnectivityManager.EXTRA_NETWORK_INFO);

	mOtherNetworkInfo = (NetworkInfo)
	intent.getParcelableExtra(ConnectivityManager.EXTRA_OTHER_NETWORK_INFO);

	mReason = intent.getStringExtra(ConnectivityManager.EXTRA_REASON);
	mIsFailOver = intent.getBooleanExtra(ConnectivityManager.EXTRA_IS_FAILOVER, false);

	Log.v(LOG_TAG, "mNetworkInfo: " + mNetworkInfo.toString());
	if (mOtherNetworkInfo != null) {
	Log.v(LOG_TAG, "mOtherNetworkInfo: " + mOtherNetworkInfo.toString());
	}
	recordNetworkState(mNetworkInfo.getType(), mNetworkInfo.getState());
	if (mOtherNetworkInfo != null) {
	recordNetworkState(mOtherNetworkInfo.getType(), mOtherNetworkInfo.getState());
	}
	notifyNetworkConnectivityChange();
	}
	}

	private class WifiReceiver extends BroadcastReceiver {
	@Override
	public void onReceive(Context context, Intent intent) {
	String action = intent.getAction();
	Log.v("WifiReceiver", "onReceive() is calleld with " + intent);
	if (action.equals(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION)) {
	notifyScanResult();
	} else if (action.equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) {
	mWifiNetworkInfo =
	(NetworkInfo) intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
	Log.v(LOG_TAG, "mWifiNetworkInfo: " + mWifiNetworkInfo.toString());
	if (mWifiNetworkInfo.getState() == State.CONNECTED) {
	mBssid = intent.getStringExtra(WifiManager.EXTRA_BSSID);
	}
	notifyWifiState();
	} else if (action.equals(WifiManager.WIFI_STATE_CHANGED_ACTION)) {
	mWifiState = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE,
	WifiManager.WIFI_STATE_UNKNOWN);
	notifyWifiState();
	}
	else {
	return;
	}
	}
	}

	public ConnectivityManagerTestActivity() {
	mState = State.UNKNOWN;
	}

	@Override
	protected void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	Log.v(LOG_TAG, "onCreate, inst=" + Integer.toHexString(hashCode()));

	// Create a simple layout
	LinearLayout contentView = new LinearLayout(this);
	contentView.setOrientation(LinearLayout.VERTICAL);
	setContentView(contentView);
	setTitle("ConnectivityManagerTestActivity");


	// register a connectivity receiver for CONNECTIVITY_ACTION;
	mConnectivityReceiver = new ConnectivityReceiver();
	registerReceiver(mConnectivityReceiver,
	new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION));

	mWifiReceiver = new WifiReceiver();
	IntentFilter mIntentFilter = new IntentFilter();
	mIntentFilter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);
	mIntentFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
	mIntentFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
	registerReceiver(mWifiReceiver, mIntentFilter);

	// Get an instance of ConnectivityManager
	mCM = (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
	// Get an instance of WifiManager
	mWifiManager =(WifiManager)getSystemService(Context.WIFI_SERVICE);
	initializeNetworkStates();

	if (mWifiManager.isWifiEnabled()) {
	Log.v(LOG_TAG, "Clear Wifi before we start the test.");
	clearWifi();
	}
	}

	// for each network type, initialize network states to UNKNOWN, and no verification flag is set
	public void initializeNetworkStates() {
	for (int networkType = NUM_NETWORK_TYPES - 1; networkType >=0; networkType--) {
	connectivityState[networkType] = new NetworkState();
	Log.v(LOG_TAG, "Initialize network state for " + networkType + ": " +
	connectivityState[networkType].toString());
	}
	}

	// deposit a network state
	public void recordNetworkState(int networkType, State networkState) {
	Log.v(LOG_TAG, "record network state for network " + networkType +
	", state is " + networkState);
	connectivityState[networkType].recordState(networkState);
	}

	// set the state transition criteria
	public void setStateTransitionCriteria(int networkType, State initState,
	int transitionDir, State targetState) {
	connectivityState[networkType].setStateTransitionCriteria(
	initState, transitionDir, targetState);
	}

	// Validate the states recorded
	public boolean validateNetworkStates(int networkType) {
	Log.v(LOG_TAG, "validate network state for " + networkType + ": ");
	return connectivityState[networkType].validateStateTransition();
	}

	// return result from network state validation
	public String getTransitionFailureReason(int networkType) {
	Log.v(LOG_TAG, "get network state transition failure reason for " + networkType + ": " +
	connectivityState[networkType].toString());
	return connectivityState[networkType].getReason();
	}

	private void notifyNetworkConnectivityChange() {
	synchronized(connectivityObject) {
	Log.v(LOG_TAG, "notify network connectivity changed");
	connectivityObject.notifyAll();
	}
	}
	private void notifyScanResult() {
	synchronized (this) {
	Log.v(LOG_TAG, "notify that scan results are available");
	this.notify();
	}
	}

	public void notifyWifiState() {
	synchronized (wifiObject) {
	Log.v(LOG_TAG, "notify wifi state changed");
	wifiObject.notify();
	}
	}

	// Return true if device is currently connected to mobile network
	public boolean isConnectedToMobile() {
	return (mNetworkInfo.getType() == ConnectivityManager.TYPE_MOBILE);
	}

	// Return true if device is currently connected to Wifi
	public boolean isConnectedToWifi() {
	return (mNetworkInfo.getType() == ConnectivityManager.TYPE_WIFI);
	}

	public boolean enableWifi() {
	return mWifiManager.setWifiEnabled(true);
	}

	/**
	* Associate the device to given SSID
	* If the device is already associated with a WiFi, disconnect and forget it,
	* We don't verify whether the connection is successful or not, leave this to the test
	*/
	public boolean connectToWifi(String knownSSID) {
	//If Wifi is not enabled, enable it
	if (!mWifiManager.isWifiEnabled()) {
	Log.v(LOG_TAG, "Wifi is not enabled, enable it");
	mWifiManager.setWifiEnabled(true);
	}

	List<ScanResult> netList = mWifiManager.getScanResults();
	if (netList == null) {
	// if no scan results are available, start active scan
	mWifiManager.startScanActive();
	mScanResultIsAvailable = false;
	long startTime = System.currentTimeMillis();
	while (!mScanResultIsAvailable) {
	if ((System.currentTimeMillis() - startTime) > WIFI_SCAN_TIMEOUT) {
	return false;
	}
	// wait for the scan results to be available
	synchronized (this) {
	// wait for the scan result to be available
	try {
	this.wait(WAIT_FOR_SCAN_RESULT);
	} catch (InterruptedException e) {
	e.printStackTrace();
	}
	if ((mWifiManager.getScanResults() == null) \|\|
	(mWifiManager.getScanResults().size() <= 0)) {
	continue;
	}
	mScanResultIsAvailable = true;
	}
	}
	}

	netList = mWifiManager.getScanResults();
	for (int i = 0; i < netList.size(); i++) {
	ScanResult sr= netList.get(i);
	if (sr.SSID.equals(knownSSID)) {
	Log.v(LOG_TAG, "found " + knownSSID + " in the scan result list");
	WifiConfiguration config = new WifiConfiguration();
	config.SSID = convertToQuotedString(sr.SSID);
	config.allowedKeyManagement.set(KeyMgmt.NONE);
	int networkId = mWifiManager.addNetwork(config);
	// Connect to network by disabling others.
	mWifiManager.enableNetwork(networkId, true);
	mWifiManager.saveConfiguration();
	mWifiManager.reconnect();
	break;
	}
	}

	List<WifiConfiguration> netConfList = mWifiManager.getConfiguredNetworks();
	if (netConfList.size() <= 0) {
	Log.v(LOG_TAG, knownSSID + " is not available");
	return false;
	}
	return true;
	}

	/*
	* Disconnect from the current AP
	*/
	public boolean disconnectAP() {
	if (mWifiManager.isWifiEnabled()) {
	//remove the current network Id
	WifiInfo curWifi = mWifiManager.getConnectionInfo();
	if (curWifi == null) {
	return false;
	}
	int curNetworkId = curWifi.getNetworkId();
	mWifiManager.removeNetwork(curNetworkId);
	mWifiManager.saveConfiguration();

	// remove other saved networks
	List<WifiConfiguration> netConfList = mWifiManager.getConfiguredNetworks();
	if (netConfList != null) {
	Log.v(LOG_TAG, "remove configured network ids");
	for (int i = 0; i < netConfList.size(); i++) {
	WifiConfiguration conf = new WifiConfiguration();
	conf = netConfList.get(i);
	mWifiManager.removeNetwork(conf.networkId);
	}
	}
	}
	mWifiManager.saveConfiguration();
	return true;
	}
	/**
	* Disable Wifi
	* @return true if Wifi is disabled successfully
	*/
	public boolean disableWifi() {
	return mWifiManager.setWifiEnabled(false);
	}

	/**
	* Disconnect from the current Wifi and clear the configuration list
	*/
	public boolean clearWifi() {
	if (!disconnectAP()) {
	return false;
	}
	// Disable Wifi
	if (!mWifiManager.setWifiEnabled(false)) {
	return false;
	}
	// Wait for the actions to be completed
	try {
	Thread.sleep(5*1000);
	} catch (InterruptedException e) {}
	return true;
	}

	/**
	* Set airplane mode
	*/
	public void setAirplaneMode(Context context, boolean enableAM) {
	//set the airplane mode
	Settings.System.putInt(context.getContentResolver(), Settings.System.AIRPLANE_MODE_ON,
	enableAM ? 1 : 0);
	// Post the intent
	Intent intent = new Intent(Intent.ACTION_AIRPLANE_MODE_CHANGED);
	intent.putExtra("state", enableAM);
	context.sendBroadcast(intent);
	}

	protected static String convertToQuotedString(String string) {
	return "\"" + string + "\"";
	}

	@Override
	protected void onDestroy() {
	super.onDestroy();

	//Unregister receiver
	if (mConnectivityReceiver != null) {
	unregisterReceiver(mConnectivityReceiver);
	}
	if (mWifiReceiver != null) {
	unregisterReceiver(mWifiReceiver);
	}
	Log.v(LOG_TAG, "onDestroy, inst=" + Integer.toHexString(hashCode()));
	}
	}