core/java/android/webkit/Network.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2006 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 android.webkit;

 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.net.ConnectivityManager;
 import android.net.NetworkInfo;
 import android.net.http.*;
 import android.os.*;
 import android.util.Log;

 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
 import java.util.Map;

 import junit.framework.Assert;

 class Network {

     private static final String LOGTAG = "network";

     /**
      * Static instance of a Network object.
      */
     private static Network sNetwork;

     /**
      * Flag to store the state of platform notifications, for the case
      * when the Network object has not been constructed yet
      */
     private static boolean sPlatformNotifications;

     /**
      * Reference count for platform notifications as the network class is a
      * static and can exist over multiple activities, thus over multiple
      * onPause/onResume pairs.
      */
     private static int sPlatformNotificationEnableRefCount;

     /**
      * Proxy username if known (used for pre-emptive proxy authentication).
      */
     private String mProxyUsername;

     /**
      * Proxy password if known (used for pre-emptive proxy authentication).
      */
     private String mProxyPassword;

     /**
      * Network request queue (requests are added from the browser thread).
      */
     private RequestQueue mRequestQueue;

     /**
      * SSL error handler: takes care of synchronization of multiple async
      * loaders with SSL-related problems.
      */
     private SslErrorHandlerImpl mSslErrorHandler;

     /**
      * HTTP authentication handler: takes care of synchronization of HTTP
      * authentication requests.
      */
     private HttpAuthHandlerImpl mHttpAuthHandler;

     private Context mContext;

     /**
      * True if the currently used network connection is a roaming phone
      * connection.
      */
     private boolean mRoaming;

     /**
      * Tracks if we are roaming.
      */
     private RoamingMonitor mRoamingMonitor;

     /**
      * @return The singleton instance of the network.
      */
     public static synchronized Network getInstance(Context context) {
         if (sNetwork == null) {
             // Note Context of the Application is used here, rather than
             // the what is passed in (usually a Context derived from an
             // Activity) so the intent receivers belong to the application
             // rather than an activity - this fixes the issue where
             // Activities are created and destroyed during the lifetime of
             // an Application
             sNetwork = new Network(context.getApplicationContext());
             if (sPlatformNotifications) {
                 // Adjust the ref count before calling enable as it is already
                 // taken into account when the static function was called
                 // directly
                 --sPlatformNotificationEnableRefCount;
                 enablePlatformNotifications();
             }
         }
         return sNetwork;
     }


     /**
      * Enables data state and proxy tracking
      */
     public static void enablePlatformNotifications() {
         if (++sPlatformNotificationEnableRefCount == 1) {
             if (sNetwork != null) {
                 sNetwork.mRequestQueue.enablePlatformNotifications();
                 sNetwork.monitorRoaming();
             } else {
                 sPlatformNotifications = true;
             }
         }
     }

     /**
      * If platform notifications are enabled, this should be called
      * from onPause() or onStop()
      */
     public static void disablePlatformNotifications() {
         if (--sPlatformNotificationEnableRefCount == 0) {
             if (sNetwork != null) {
                 sNetwork.mRequestQueue.disablePlatformNotifications();
                 sNetwork.stopMonitoringRoaming();
             } else {
                 sPlatformNotifications = false;
             }
         }
     }

     /**
      * Creates a new Network object.
      * XXX: Must be created in the same thread as WebCore!!!!!
      */
     private Network(Context context) {
         if (DebugFlags.NETWORK) {
             Assert.assertTrue(Thread.currentThread().
                     getName().equals(WebViewCore.THREAD_NAME));
         }
         mContext = context;
         mSslErrorHandler = new SslErrorHandlerImpl();
         mHttpAuthHandler = new HttpAuthHandlerImpl(this);

         mRequestQueue = new RequestQueue(context);
     }

     private class RoamingMonitor extends BroadcastReceiver {
         @Override
         public void onReceive(Context context, Intent intent) {
             if (!ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction()))
                 return;

             NetworkInfo info = (NetworkInfo)intent.getParcelableExtra(ConnectivityManager.EXTRA_NETWORK_INFO);
             if (info != null)
                 mRoaming = info.isRoaming();
         };
     };

     private void monitorRoaming() {
         mRoamingMonitor = new RoamingMonitor();
         IntentFilter filter = new IntentFilter();
         filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
         mContext.registerReceiver(sNetwork.mRoamingMonitor, filter);
     }

     private void stopMonitoringRoaming() {
         if (mRoamingMonitor != null) {
             mContext.unregisterReceiver(mRoamingMonitor);
             mRoamingMonitor = null;
         }
     }

     /**
      * Request a url from either the network or the file system.
      * @param url The url to load.
      * @param method The http method.
      * @param headers The http headers.
      * @param postData The body of the request.
      * @param loader A LoadListener for receiving the results of the request.
      * @return True if the request was successfully queued.
      */
     public boolean requestURL(String method,
                               Map<String, String> headers,
                               byte [] postData,
                               LoadListener loader) {

         String url = loader.url();

         // Not a valid url, return false because we won't service the request!
         if (!URLUtil.isValidUrl(url)) {
             return false;
         }

         // asset, res, file system or data stream are handled in the other code
         // path. This only handles network request.
         if (URLUtil.isAssetUrl(url) || URLUtil.isResourceUrl(url)
                 || URLUtil.isFileUrl(url) || URLUtil.isDataUrl(url)) {
             return false;
         }

         // If this is a prefetch, abort it if we're roaming.
         if (mRoaming && headers.containsKey("X-Moz") && "prefetch".equals(headers.get("X-Moz"))) {
             return false;
         }

         /* FIXME: this is lame.  Pass an InputStream in, rather than
            making this lame one here */
         InputStream bodyProvider = null;
         int bodyLength = 0;
         if (postData != null) {
             bodyLength = postData.length;
             bodyProvider = new ByteArrayInputStream(postData);
         }

         RequestQueue q = mRequestQueue;
         RequestHandle handle = null;
         if (loader.isSynchronous()) {
             handle = q.queueSynchronousRequest(url, loader.getWebAddress(),
                     method, headers, loader, bodyProvider, bodyLength);
             loader.attachRequestHandle(handle);
             handle.processRequest();
             loader.loadSynchronousMessages();
         } else {
             handle = q.queueRequest(url, loader.getWebAddress(), method,
                     headers, loader, bodyProvider, bodyLength);
             // FIXME: Although this is probably a rare condition, normal network
             // requests are processed in a separate thread. This means that it
             // is possible to process part of the request before setting the
             // request handle on the loader. We should probably refactor this to
             // ensure the handle is attached before processing begins.
             loader.attachRequestHandle(handle);
         }

         return true;
     }

     /**
      * @return True iff there is a valid proxy set.
      */
     public boolean isValidProxySet() {
         // The proxy host and port can be set within a different thread during
         // an Intent broadcast.
         synchronized (mRequestQueue) {
             return mRequestQueue.getProxyHost() != null;
         }
     }

     /**
      * Get the proxy hostname.
      * @return The proxy hostname obtained from the network queue and proxy
      *         settings.
      */
     public String getProxyHostname() {
         return mRequestQueue.getProxyHost().getHostName();
     }

     /**
      * @return The proxy username or null if none.
      */
     public synchronized String getProxyUsername() {
         return mProxyUsername;
     }

     /**
      * Sets the proxy username.
      * @param proxyUsername Username to use when
      * connecting through the proxy.
      */
     public synchronized void setProxyUsername(String proxyUsername) {
         if (DebugFlags.NETWORK) {
             Assert.assertTrue(isValidProxySet());
         }

         mProxyUsername = proxyUsername;
     }

     /**
      * @return The proxy password or null if none.
      */
     public synchronized String getProxyPassword() {
         return mProxyPassword;
     }

     /**
      * Sets the proxy password.
      * @param proxyPassword Password to use when
      * connecting through the proxy.
      */
     public synchronized void setProxyPassword(String proxyPassword) {
         if (DebugFlags.NETWORK) {
             Assert.assertTrue(isValidProxySet());
         }

         mProxyPassword = proxyPassword;
     }

     /**
      * Saves the state of network handlers (user SSL and HTTP-authentication
      * preferences).
      * @param outState The out-state to save (write) to.
      * @return True iff succeeds.
      */
     public boolean saveState(Bundle outState) {
         if (DebugFlags.NETWORK) {
             Log.v(LOGTAG, "Network.saveState()");
         }

         return mSslErrorHandler.saveState(outState);
     }

     /**
      * Restores the state of network handlers (user SSL and HTTP-authentication
      * preferences).
      * @param inState The in-state to load (read) from.
      * @return True iff succeeds.
      */
     public boolean restoreState(Bundle inState) {
         if (DebugFlags.NETWORK) {
             Log.v(LOGTAG, "Network.restoreState()");
         }

         return mSslErrorHandler.restoreState(inState);
     }

     /**
      * Clears user SSL-error preference table.
      */
     public void clearUserSslPrefTable() {
         mSslErrorHandler.clear();
     }

     /**
      * Handles SSL error(s) on the way up to the user: the user must decide
      * whether errors should be ignored or not.
      * @param loader The loader that resulted in SSL errors.
      */
     public void handleSslErrorRequest(LoadListener loader) {
         if (DebugFlags.NETWORK) Assert.assertNotNull(loader);
         if (loader != null) {
             mSslErrorHandler.handleSslErrorRequest(loader);
         }
     }

     /* package */ boolean checkSslPrefTable(LoadListener loader,
             SslError error) {
         if (loader != null && error != null) {
             return mSslErrorHandler.checkSslPrefTable(loader, error);
         }
         return false;
     }

      /**
      * Handles authentication requests on their way up to the user (the user
      * must provide credentials).
      * @param loader The loader that resulted in an HTTP
      * authentication request.
      */
     public void handleAuthRequest(LoadListener loader) {
         if (DebugFlags.NETWORK) Assert.assertNotNull(loader);
         if (loader != null) {
             mHttpAuthHandler.handleAuthRequest(loader);
         }
     }

     // Performance probe
     public void startTiming() {
         mRequestQueue.startTiming();
     }

     public void stopTiming() {
         mRequestQueue.stopTiming();
     }
 }
	/*
	* Copyright (C) 2006 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 android.webkit;

	import android.content.BroadcastReceiver;
	import android.content.Context;
	import android.content.Intent;
	import android.content.IntentFilter;
	import android.net.ConnectivityManager;
	import android.net.NetworkInfo;
	import android.net.http.*;
	import android.os.*;
	import android.util.Log;

	import java.io.ByteArrayInputStream;
	import java.io.InputStream;
	import java.util.Map;

	import junit.framework.Assert;

	class Network {

	private static final String LOGTAG = "network";

	/**
	* Static instance of a Network object.
	*/
	private static Network sNetwork;

	/**
	* Flag to store the state of platform notifications, for the case
	* when the Network object has not been constructed yet
	*/
	private static boolean sPlatformNotifications;

	/**
	* Reference count for platform notifications as the network class is a
	* static and can exist over multiple activities, thus over multiple
	* onPause/onResume pairs.
	*/
	private static int sPlatformNotificationEnableRefCount;

	/**
	* Proxy username if known (used for pre-emptive proxy authentication).
	*/
	private String mProxyUsername;

	/**
	* Proxy password if known (used for pre-emptive proxy authentication).
	*/
	private String mProxyPassword;

	/**
	* Network request queue (requests are added from the browser thread).
	*/
	private RequestQueue mRequestQueue;

	/**
	* SSL error handler: takes care of synchronization of multiple async
	* loaders with SSL-related problems.
	*/
	private SslErrorHandlerImpl mSslErrorHandler;

	/**
	* HTTP authentication handler: takes care of synchronization of HTTP
	* authentication requests.
	*/
	private HttpAuthHandlerImpl mHttpAuthHandler;

	private Context mContext;

	/**
	* True if the currently used network connection is a roaming phone
	* connection.
	*/
	private boolean mRoaming;

	/**
	* Tracks if we are roaming.
	*/
	private RoamingMonitor mRoamingMonitor;

	/**
	* @return The singleton instance of the network.
	*/
	public static synchronized Network getInstance(Context context) {
	if (sNetwork == null) {
	// Note Context of the Application is used here, rather than
	// the what is passed in (usually a Context derived from an
	// Activity) so the intent receivers belong to the application
	// rather than an activity - this fixes the issue where
	// Activities are created and destroyed during the lifetime of
	// an Application
	sNetwork = new Network(context.getApplicationContext());
	if (sPlatformNotifications) {
	// Adjust the ref count before calling enable as it is already
	// taken into account when the static function was called
	// directly
	--sPlatformNotificationEnableRefCount;
	enablePlatformNotifications();
	}
	}
	return sNetwork;
	}


	/**
	* Enables data state and proxy tracking
	*/
	public static void enablePlatformNotifications() {
	if (++sPlatformNotificationEnableRefCount == 1) {
	if (sNetwork != null) {
	sNetwork.mRequestQueue.enablePlatformNotifications();
	sNetwork.monitorRoaming();
	} else {
	sPlatformNotifications = true;
	}
	}
	}

	/**
	* If platform notifications are enabled, this should be called
	* from onPause() or onStop()
	*/
	public static void disablePlatformNotifications() {
	if (--sPlatformNotificationEnableRefCount == 0) {
	if (sNetwork != null) {
	sNetwork.mRequestQueue.disablePlatformNotifications();
	sNetwork.stopMonitoringRoaming();
	} else {
	sPlatformNotifications = false;
	}
	}
	}

	/**
	* Creates a new Network object.
	* XXX: Must be created in the same thread as WebCore!!!!!
	*/
	private Network(Context context) {
	if (DebugFlags.NETWORK) {
	Assert.assertTrue(Thread.currentThread().
	getName().equals(WebViewCore.THREAD_NAME));
	}
	mContext = context;
	mSslErrorHandler = new SslErrorHandlerImpl();
	mHttpAuthHandler = new HttpAuthHandlerImpl(this);

	mRequestQueue = new RequestQueue(context);
	}

	private class RoamingMonitor extends BroadcastReceiver {
	@Override
	public void onReceive(Context context, Intent intent) {
	if (!ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction()))
	return;

	NetworkInfo info = (NetworkInfo)intent.getParcelableExtra(ConnectivityManager.EXTRA_NETWORK_INFO);
	if (info != null)
	mRoaming = info.isRoaming();
	};
	};

	private void monitorRoaming() {
	mRoamingMonitor = new RoamingMonitor();
	IntentFilter filter = new IntentFilter();
	filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
	mContext.registerReceiver(sNetwork.mRoamingMonitor, filter);
	}

	private void stopMonitoringRoaming() {
	if (mRoamingMonitor != null) {
	mContext.unregisterReceiver(mRoamingMonitor);
	mRoamingMonitor = null;
	}
	}

	/**
	* Request a url from either the network or the file system.
	* @param url The url to load.
	* @param method The http method.
	* @param headers The http headers.
	* @param postData The body of the request.
	* @param loader A LoadListener for receiving the results of the request.
	* @return True if the request was successfully queued.
	*/
	public boolean requestURL(String method,
	Map<String, String> headers,
	byte [] postData,
	LoadListener loader) {

	String url = loader.url();

	// Not a valid url, return false because we won't service the request!
	if (!URLUtil.isValidUrl(url)) {
	return false;
	}

	// asset, res, file system or data stream are handled in the other code
	// path. This only handles network request.
	if (URLUtil.isAssetUrl(url) \|\| URLUtil.isResourceUrl(url)
	\|\| URLUtil.isFileUrl(url) \|\| URLUtil.isDataUrl(url)) {
	return false;
	}

	// If this is a prefetch, abort it if we're roaming.
	if (mRoaming && headers.containsKey("X-Moz") && "prefetch".equals(headers.get("X-Moz"))) {
	return false;
	}

	/* FIXME: this is lame. Pass an InputStream in, rather than
	making this lame one here */
	InputStream bodyProvider = null;
	int bodyLength = 0;
	if (postData != null) {
	bodyLength = postData.length;
	bodyProvider = new ByteArrayInputStream(postData);
	}

	RequestQueue q = mRequestQueue;
	RequestHandle handle = null;
	if (loader.isSynchronous()) {
	handle = q.queueSynchronousRequest(url, loader.getWebAddress(),
	method, headers, loader, bodyProvider, bodyLength);
	loader.attachRequestHandle(handle);
	handle.processRequest();
	loader.loadSynchronousMessages();
	} else {
	handle = q.queueRequest(url, loader.getWebAddress(), method,
	headers, loader, bodyProvider, bodyLength);
	// FIXME: Although this is probably a rare condition, normal network
	// requests are processed in a separate thread. This means that it
	// is possible to process part of the request before setting the
	// request handle on the loader. We should probably refactor this to
	// ensure the handle is attached before processing begins.
	loader.attachRequestHandle(handle);
	}

	return true;
	}

	/**
	* @return True iff there is a valid proxy set.
	*/
	public boolean isValidProxySet() {
	// The proxy host and port can be set within a different thread during
	// an Intent broadcast.
	synchronized (mRequestQueue) {
	return mRequestQueue.getProxyHost() != null;
	}
	}

	/**
	* Get the proxy hostname.
	* @return The proxy hostname obtained from the network queue and proxy
	* settings.
	*/
	public String getProxyHostname() {
	return mRequestQueue.getProxyHost().getHostName();
	}

	/**
	* @return The proxy username or null if none.
	*/
	public synchronized String getProxyUsername() {
	return mProxyUsername;
	}

	/**
	* Sets the proxy username.
	* @param proxyUsername Username to use when
	* connecting through the proxy.
	*/
	public synchronized void setProxyUsername(String proxyUsername) {
	if (DebugFlags.NETWORK) {
	Assert.assertTrue(isValidProxySet());
	}

	mProxyUsername = proxyUsername;
	}

	/**
	* @return The proxy password or null if none.
	*/
	public synchronized String getProxyPassword() {
	return mProxyPassword;
	}

	/**
	* Sets the proxy password.
	* @param proxyPassword Password to use when
	* connecting through the proxy.
	*/
	public synchronized void setProxyPassword(String proxyPassword) {
	if (DebugFlags.NETWORK) {
	Assert.assertTrue(isValidProxySet());
	}

	mProxyPassword = proxyPassword;
	}

	/**
	* Saves the state of network handlers (user SSL and HTTP-authentication
	* preferences).
	* @param outState The out-state to save (write) to.
	* @return True iff succeeds.
	*/
	public boolean saveState(Bundle outState) {
	if (DebugFlags.NETWORK) {
	Log.v(LOGTAG, "Network.saveState()");
	}

	return mSslErrorHandler.saveState(outState);
	}

	/**
	* Restores the state of network handlers (user SSL and HTTP-authentication
	* preferences).
	* @param inState The in-state to load (read) from.
	* @return True iff succeeds.
	*/
	public boolean restoreState(Bundle inState) {
	if (DebugFlags.NETWORK) {
	Log.v(LOGTAG, "Network.restoreState()");
	}

	return mSslErrorHandler.restoreState(inState);
	}

	/**
	* Clears user SSL-error preference table.
	*/
	public void clearUserSslPrefTable() {
	mSslErrorHandler.clear();
	}

	/**
	* Handles SSL error(s) on the way up to the user: the user must decide
	* whether errors should be ignored or not.
	* @param loader The loader that resulted in SSL errors.
	*/
	public void handleSslErrorRequest(LoadListener loader) {
	if (DebugFlags.NETWORK) Assert.assertNotNull(loader);
	if (loader != null) {
	mSslErrorHandler.handleSslErrorRequest(loader);
	}
	}

	/* package */ boolean checkSslPrefTable(LoadListener loader,
	SslError error) {
	if (loader != null && error != null) {
	return mSslErrorHandler.checkSslPrefTable(loader, error);
	}
	return false;
	}

	/**
	* Handles authentication requests on their way up to the user (the user
	* must provide credentials).
	* @param loader The loader that resulted in an HTTP
	* authentication request.
	*/
	public void handleAuthRequest(LoadListener loader) {
	if (DebugFlags.NETWORK) Assert.assertNotNull(loader);
	if (loader != null) {
	mHttpAuthHandler.handleAuthRequest(loader);
	}
	}

	// Performance probe
	public void startTiming() {
	mRequestQueue.startTiming();
	}

	public void stopTiming() {
	mRequestQueue.stopTiming();
	}
	}