luni/src/main/java/java/net/URL.java - platform/libcore2 - Git at Google

 /*
  *  Licensed to the Apache Software Foundation (ASF) under one or more
  *  contributor license agreements.  See the NOTICE file distributed with
  *  this work for additional information regarding copyright ownership.
  *  The ASF licenses this file to You 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 java.net;

 import java.io.IOException;
 import java.io.InputStream;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.io.Serializable;
 import java.util.Hashtable;
 import java.util.jar.JarFile;
 import libcore.net.http.HttpHandler;
 import libcore.net.http.HttpsHandler;
 import libcore.net.url.FileHandler;
 import libcore.net.url.FtpHandler;
 import libcore.net.url.JarHandler;
 import libcore.net.url.UrlUtils;

 /**
  * A Uniform Resource Locator that identifies the location of an Internet
  * resource as specified by <a href="http://www.ietf.org/rfc/rfc1738.txt">RFC
  * 1738</a>.
  *
  * <h3>Parts of a URL</h3>
  * A URL is composed of many parts. This class can both parse URL strings into
  * parts and compose URL strings from parts. For example, consider the parts of
  * this URL:
  * {@code http://username:password@host:8080/directory/file?query#ref}:
  * <table>
  * <tr><th>Component</th><th>Example value</th><th>Also known as</th></tr>
  * <tr><td>{@link #getProtocol() Protocol}</td><td>{@code http}</td><td>scheme</td></tr>
  * <tr><td>{@link #getAuthority() Authority}</td><td>{@code username:password@host:8080}</td><td></td></tr>
  * <tr><td>{@link #getUserInfo() User Info}</td><td>{@code username:password}</td><td></td></tr>
  * <tr><td>{@link #getHost() Host}</td><td>{@code host}</td><td></td></tr>
  * <tr><td>{@link #getPort() Port}</td><td>{@code 8080}</td><td></td></tr>
  * <tr><td>{@link #getFile() File}</td><td>{@code /directory/file?query}</td><td></td></tr>
  * <tr><td>{@link #getPath() Path}</td><td>{@code /directory/file}</td><td></td></tr>
  * <tr><td>{@link #getQuery() Query}</td><td>{@code query}</td><td></td></tr>
  * <tr><td>{@link #getRef() Ref}</td><td>{@code ref}</td><td>fragment</td></tr>
  * </table>
  *
  * <h3>Supported Protocols</h3>
  * This class may be used to construct URLs with the following protocols:
  * <ul>
  * <li><strong>file</strong>: read files from the local filesystem.
  * <li><strong>ftp</strong>: <a href="http://www.ietf.org/rfc/rfc959.txt">File
  *     Transfer Protocol</a>
  * <li><strong>http</strong>: <a href="http://www.ietf.org/rfc/rfc2616.txt">Hypertext
  *     Transfer Protocol</a>
  * <li><strong>https</strong>: <a href="http://www.ietf.org/rfc/rfc2818.txt">HTTP
  *     over TLS</a>
  * <li><strong>jar</strong>: read {@link JarFile Jar files} from the
  *     filesystem</li>
  * </ul>
  * In general, attempts to create URLs with any other protocol will fail with a
  * {@link MalformedURLException}. Applications may install handlers for other
  * schemes using {@link #setURLStreamHandlerFactory} or with the {@code
  * java.protocol.handler.pkgs} system property.
  *
  * <p>The {@link URI} class can be used to manipulate URLs of any protocol.
  */
 public final class URL implements Serializable {
     private static final long serialVersionUID = -7627629688361524110L;

     private static URLStreamHandlerFactory streamHandlerFactory;

     /** Cache of protocols to their handlers */
     private static final Hashtable<String, URLStreamHandler> streamHandlers
             = new Hashtable<String, URLStreamHandler>();

     private String protocol;
     private String authority;
     private String host;
     private int port = -1;
     private String file;
     private String ref;

     private transient String userInfo;
     private transient String path;
     private transient String query;

     transient URLStreamHandler streamHandler;

     /**
      * The cached hash code, or 0 if it hasn't been computed yet. Unlike the RI,
      * this implementation's hashCode is transient because the hash code is
      * unspecified and may vary between VMs or versions.
      */
     private transient int hashCode;

     /**
      * Sets the stream handler factory for this VM.
      *
      * @throws Error if a URLStreamHandlerFactory has already been installed
      *     for the current VM.
      */
     public static synchronized void setURLStreamHandlerFactory(URLStreamHandlerFactory factory) {
         if (streamHandlerFactory != null) {
             throw new Error("Factory already set");
         }
         streamHandlers.clear();
         streamHandlerFactory = factory;
     }

     /**
      * Creates a new URL instance by parsing {@code spec}.
      *
      * @throws MalformedURLException if {@code spec} could not be parsed as a
      *     URL.
      */
     public URL(String spec) throws MalformedURLException {
         this((URL) null, spec, null);
     }

     /**
      * Creates a new URL by resolving {@code spec} relative to {@code context}.
      *
      * @param context the URL to which {@code spec} is relative, or null for
      *     no context in which case {@code spec} must be an absolute URL.
      * @throws MalformedURLException if {@code spec} could not be parsed as a
      *     URL or has an unsupported protocol.
      */
     public URL(URL context, String spec) throws MalformedURLException {
         this(context, spec, null);
     }

     /**
      * Creates a new URL by resolving {@code spec} relative to {@code context}.
      *
      * @param context the URL to which {@code spec} is relative, or null for
      *     no context in which case {@code spec} must be an absolute URL.
      * @param handler the stream handler for this URL, or null for the
      *     protocol's default stream handler.
      * @throws MalformedURLException if the given string {@code spec} could not
      *     be parsed as a URL or an invalid protocol has been found.
      */
     public URL(URL context, String spec, URLStreamHandler handler) throws MalformedURLException {
         if (spec == null) {
             throw new MalformedURLException();
         }
         if (handler != null) {
             streamHandler = handler;
         }
         spec = spec.trim();

         protocol = UrlUtils.getSchemePrefix(spec);
         int schemeSpecificPartStart = protocol != null ? (protocol.length() + 1) : 0;

         // If the context URL has a different protocol, discard it because we can't use it.
         if (protocol != null && context != null && !protocol.equals(context.protocol)) {
             context = null;
         }

         // Inherit from the context URL if it exists.
         if (context != null) {
             set(context.protocol, context.getHost(), context.getPort(), context.getAuthority(),
                     context.getUserInfo(), context.getPath(), context.getQuery(),
                     context.getRef());
             if (streamHandler == null) {
                 streamHandler = context.streamHandler;
             }
         } else if (protocol == null) {
             throw new MalformedURLException("Protocol not found: " + spec);
         }

         if (streamHandler == null) {
             setupStreamHandler();
             if (streamHandler == null) {
                 throw new MalformedURLException("Unknown protocol: " + protocol);
             }
         }

         // Parse the URL. If the handler throws any exception, throw MalformedURLException instead.
         try {
             streamHandler.parseURL(this, spec, schemeSpecificPartStart, spec.length());
         } catch (Exception e) {
             throw new MalformedURLException(e.toString());
         }
     }

     /**
      * Creates a new URL of the given component parts. The URL uses the
      * protocol's default port.
      *
      * @throws MalformedURLException if the combination of all arguments do not
      *     represent a valid URL or if the protocol is invalid.
      */
     public URL(String protocol, String host, String file) throws MalformedURLException {
         this(protocol, host, -1, file, null);
     }

     /**
      * Creates a new URL of the given component parts. The URL uses the
      * protocol's default port.
      *
      * @param host the host name or IP address of the new URL.
      * @param port the port, or {@code -1} for the protocol's default port.
      * @param file the name of the resource.
      * @throws MalformedURLException if the combination of all arguments do not
      *     represent a valid URL or if the protocol is invalid.
      */
     public URL(String protocol, String host, int port, String file) throws MalformedURLException {
         this(protocol, host, port, file, null);
     }

     /**
      * Creates a new URL of the given component parts. The URL uses the
      * protocol's default port.
      *
      * @param host the host name or IP address of the new URL.
      * @param port the port, or {@code -1} for the protocol's default port.
      * @param file the name of the resource.
      * @param handler the stream handler for this URL, or null for the
      *     protocol's default stream handler.
      * @throws MalformedURLException if the combination of all arguments do not
      *     represent a valid URL or if the protocol is invalid.
      */
     public URL(String protocol, String host, int port, String file,
             URLStreamHandler handler) throws MalformedURLException {
         if (port < -1) {
             throw new MalformedURLException("port < -1: " + port);
         }
         if (protocol == null) {
             throw new NullPointerException("protocol == null");
         }

         // Wrap IPv6 addresses in square brackets if they aren't already.
         if (host != null && host.contains(":") && host.charAt(0) != '[') {
             host = "[" + host + "]";
         }

         this.protocol = protocol;
         this.host = host;
         this.port = port;

         file = UrlUtils.authoritySafePath(host, file);

         // Set the fields from the arguments. Handle the case where the
         // passed in "file" includes both a file and a reference part.
         int hash = file.indexOf("#");
         if (hash != -1) {
             this.file = file.substring(0, hash);
             this.ref = file.substring(hash + 1);
         } else {
             this.file = file;
         }
         fixURL(false);

         // Set the stream handler for the URL either to the handler
         // argument if it was specified, or to the default for the
         // receiver's protocol if the handler was null.
         if (handler == null) {
             setupStreamHandler();
             if (streamHandler == null) {
                 throw new MalformedURLException("Unknown protocol: " + protocol);
             }
         } else {
             streamHandler = handler;
         }
     }

     void fixURL(boolean fixHost) {
         int index;
         if (host != null && host.length() > 0) {
             authority = host;
             if (port != -1) {
                 authority = authority + ":" + port;
             }
         }
         if (fixHost) {
             if (host != null && (index = host.lastIndexOf('@')) > -1) {
                 userInfo = host.substring(0, index);
                 host = host.substring(index + 1);
             } else {
                 userInfo = null;
             }
         }
         if (file != null && (index = file.indexOf('?')) > -1) {
             query = file.substring(index + 1);
             path = file.substring(0, index);
         } else {
             query = null;
             path = file;
         }
     }

     /**
      * Sets the properties of this URL using the provided arguments. Only a
      * {@code URLStreamHandler} can use this method to set fields of the
      * existing URL instance. A URL is generally constant.
      */
     protected void set(String protocol, String host, int port, String file, String ref) {
         if (this.protocol == null) {
             this.protocol = protocol;
         }
         this.host = host;
         this.file = file;
         this.port = port;
         this.ref = ref;
         hashCode = 0;
         fixURL(true);
     }

     /**
      * Returns true if this URL equals {@code o}. URLs are equal if they have
      * the same protocol, host, port, file, and reference.
      *
      * <h3>Network I/O Warning</h3>
      * <p>Some implementations of URL.equals() resolve host names over the
      * network. This is problematic:
      * <ul>
      * <li><strong>The network may be slow.</strong> Many classes, including
      * core collections like {@link java.util.Map Map} and {@link java.util.Set
      * Set} expect that {@code equals} and {@code hashCode} will return quickly.
      * By violating this assumption, this method posed potential performance
      * problems.
      * <li><strong>Equal IP addresses do not imply equal content.</strong>
      * Virtual hosting permits unrelated sites to share an IP address. This
      * method could report two otherwise unrelated URLs to be equal because
      * they're hosted on the same server.</li>
      * <li><strong>The network many not be available.</strong> Two URLs could be
      * equal when a network is available and unequal otherwise.</li>
      * <li><strong>The network may change.</strong> The IP address for a given
      * host name varies by network and over time. This is problematic for mobile
      * devices. Two URLs could be equal on some networks and unequal on
      * others.</li>
      * </ul>
      * <p>This problem is fixed in Android 4.0 (Ice Cream Sandwich). In that
      * release, URLs are only equal if their host names are equal (ignoring
      * case).
      */
     @Override public boolean equals(Object o) {
         if (o == null) {
             return false;
         }
         if (this == o) {
             return true;
         }
         if (this.getClass() != o.getClass()) {
             return false;
         }
         return streamHandler.equals(this, (URL) o);
     }

     /**
      * Returns true if this URL refers to the same resource as {@code otherURL}.
      * All URL components except the reference field are compared.
      */
     public boolean sameFile(URL otherURL) {
         return streamHandler.sameFile(this, otherURL);
     }

     @Override public int hashCode() {
         if (hashCode == 0) {
             hashCode = streamHandler.hashCode(this);
         }
         return hashCode;
     }

     /**
      * Sets the receiver's stream handler to one which is appropriate for its
      * protocol.
      *
      * <p>Note that this will overwrite any existing stream handler with the new
      * one. Senders must check if the streamHandler is null before calling the
      * method if they do not want this behavior (a speed optimization).
      *
      * @throws MalformedURLException if no reasonable handler is available.
      */
     void setupStreamHandler() {
         // Check for a cached (previously looked up) handler for
         // the requested protocol.
         streamHandler = streamHandlers.get(protocol);
         if (streamHandler != null) {
             return;
         }

         // If there is a stream handler factory, then attempt to
         // use it to create the handler.
         if (streamHandlerFactory != null) {
             streamHandler = streamHandlerFactory.createURLStreamHandler(protocol);
             if (streamHandler != null) {
                 streamHandlers.put(protocol, streamHandler);
                 return;
             }
         }

         // Check if there is a list of packages which can provide handlers.
         // If so, then walk this list looking for an applicable one.
         String packageList = System.getProperty("java.protocol.handler.pkgs");
         ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
         if (packageList != null && contextClassLoader != null) {
             for (String packageName : packageList.split("\\|")) {
                 String className = packageName + "." + protocol + ".Handler";
                 try {
                     Class<?> c = contextClassLoader.loadClass(className);
                     streamHandler = (URLStreamHandler) c.newInstance();
                     if (streamHandler != null) {
                         streamHandlers.put(protocol, streamHandler);
                     }
                     return;
                 } catch (IllegalAccessException ignored) {
                 } catch (InstantiationException ignored) {
                 } catch (ClassNotFoundException ignored) {
                 }
             }
         }

         // Fall back to a built-in stream handler if the user didn't supply one
         if (protocol.equals("file")) {
             streamHandler = new FileHandler();
         } else if (protocol.equals("ftp")) {
             streamHandler = new FtpHandler();
         } else if (protocol.equals("http")) {
             streamHandler = new HttpHandler();
         } else if (protocol.equals("https")) {
             streamHandler = new HttpsHandler();
         } else if (protocol.equals("jar")) {
             streamHandler = new JarHandler();
         }
         if (streamHandler != null) {
             streamHandlers.put(protocol, streamHandler);
         }
     }

     /**
      * Returns the content of the resource which is referred by this URL. By
      * default this returns an {@code InputStream}, or null if the content type
      * of the response is unknown.
      */
     public final Object getContent() throws IOException {
         return openConnection().getContent();
     }

     /**
      * Equivalent to {@code openConnection().getContent(types)}.
      */
     @SuppressWarnings("unchecked") // Param not generic in spec
     public final Object getContent(Class[] types) throws IOException {
         return openConnection().getContent(types);
     }

     /**
      * Equivalent to {@code openConnection().getInputStream(types)}.
      */
     public final InputStream openStream() throws IOException {
         return openConnection().getInputStream();
     }

     /**
      * Returns a new connection to the resource referred to by this URL.
      *
      * @throws IOException if an error occurs while opening the connection.
      */
     public URLConnection openConnection() throws IOException {
         return streamHandler.openConnection(this);
     }

     /**
      * Returns a new connection to the resource referred to by this URL.
      *
      * @param proxy the proxy through which the connection will be established.
      * @throws IOException if an I/O error occurs while opening the connection.
      * @throws IllegalArgumentException if the argument proxy is null or of is
      *     an invalid type.
      * @throws UnsupportedOperationException if the protocol handler does not
      *     support opening connections through proxies.
      */
     public URLConnection openConnection(Proxy proxy) throws IOException {
         if (proxy == null) {
             throw new IllegalArgumentException("proxy == null");
         }
         return streamHandler.openConnection(this, proxy);
     }

     /**
      * Returns the URI equivalent to this URL.
      *
      * @throws URISyntaxException if this URL cannot be converted into a URI.
      */
     public URI toURI() throws URISyntaxException {
         return new URI(toExternalForm());
     }

     /**
      * Encodes this URL to the equivalent URI after escaping characters that are
      * not permitted by URI.
      *
      * @hide
      */
     public URI toURILenient() throws URISyntaxException {
         if (streamHandler == null) {
             throw new IllegalStateException(protocol);
         }
         return new URI(streamHandler.toExternalForm(this, true));
     }

     /**
      * Returns a string containing a concise, human-readable representation of
      * this URL. The returned string is the same as the result of the method
      * {@code toExternalForm()}.
      */
     @Override public String toString() {
         return toExternalForm();
     }

     /**
      * Returns a string containing a concise, human-readable representation of
      * this URL.
      */
     public String toExternalForm() {
         if (streamHandler == null) {
             return "unknown protocol(" + protocol + ")://" + host + file;
         }
         return streamHandler.toExternalForm(this);
     }

     private void readObject(ObjectInputStream stream) throws IOException {
         try {
             stream.defaultReadObject();
             if (host != null && authority == null) {
                 fixURL(true);
             } else if (authority != null) {
                 int index;
                 if ((index = authority.lastIndexOf('@')) > -1) {
                     userInfo = authority.substring(0, index);
                 }
                 if (file != null && (index = file.indexOf('?')) > -1) {
                     query = file.substring(index + 1);
                     path = file.substring(0, index);
                 } else {
                     path = file;
                 }
             }
             setupStreamHandler();
             if (streamHandler == null) {
                 throw new IOException("Unknown protocol: " + protocol);
             }
             hashCode = 0; // necessary until http://b/4471249 is fixed
         } catch (ClassNotFoundException e) {
             throw new IOException(e);
         }
     }

     private void writeObject(ObjectOutputStream s) throws IOException {
         s.defaultWriteObject();
     }

     /** @hide */
     public int getEffectivePort() {
         return URI.getEffectivePort(protocol, port);
     }

     /**
      * Returns the protocol of this URL like "http" or "file". This is also
      * known as the scheme. The returned string is lower case.
      */
     public String getProtocol() {
         return protocol;
     }

     /**
      * Returns the authority part of this URL, or null if this URL has no
      * authority.
      */
     public String getAuthority() {
         return authority;
     }

     /**
      * Returns the user info of this URL, or null if this URL has no user info.
      */
     public String getUserInfo() {
         return userInfo;
     }

     /**
      * Returns the host name or IP address of this URL.
      */
     public String getHost() {
         return host;
     }

     /**
      * Returns the port number of this URL or {@code -1} if this URL has no
      * explicit port.
      *
      * <p>If this URL has no explicit port, connections opened using this URL
      * will use its {@link #getDefaultPort() default port}.
      */
     public int getPort() {
         return port;
     }

     /**
      * Returns the default port number of the protocol used by this URL. If no
      * default port is defined by the protocol or the {@code URLStreamHandler},
      * {@code -1} will be returned.
      *
      * @see URLStreamHandler#getDefaultPort
      */
     public int getDefaultPort() {
         return streamHandler.getDefaultPort();
     }

     /**
      * Returns the file of this URL.
      */
     public String getFile() {
         return file;
     }

     /**
      * Returns the path part of this URL.
      */
     public String getPath() {
         return path;
     }

     /**
      * Returns the query part of this URL, or null if this URL has no query.
      */
     public String getQuery() {
         return query;
     }

     /**
      * Returns the value of the reference part of this URL, or null if this URL
      * has no reference part. This is also known as the fragment.
      */
     public String getRef() {
         return ref;
     }

     /**
      * Sets the properties of this URL using the provided arguments. Only a
      * {@code URLStreamHandler} can use this method to set fields of the
      * existing URL instance. A URL is generally constant.
      */
     protected void set(String protocol, String host, int port, String authority, String userInfo,
             String path, String query, String ref) {
         String file = path;
         if (query != null && !query.isEmpty()) {
             file += "?" + query;
         }
         set(protocol, host, port, file, ref);
         this.authority = authority;
         this.userInfo = userInfo;
         this.path = path;
         this.query = query;
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You 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 java.net;

	import java.io.IOException;
	import java.io.InputStream;
	import java.io.ObjectInputStream;
	import java.io.ObjectOutputStream;
	import java.io.Serializable;
	import java.util.Hashtable;
	import java.util.jar.JarFile;
	import libcore.net.http.HttpHandler;
	import libcore.net.http.HttpsHandler;
	import libcore.net.url.FileHandler;
	import libcore.net.url.FtpHandler;
	import libcore.net.url.JarHandler;
	import libcore.net.url.UrlUtils;

	/**
	* A Uniform Resource Locator that identifies the location of an Internet
	* resource as specified by <a href="http://www.ietf.org/rfc/rfc1738.txt">RFC
	* 1738</a>.
	*
	* <h3>Parts of a URL</h3>
	* A URL is composed of many parts. This class can both parse URL strings into
	* parts and compose URL strings from parts. For example, consider the parts of
	* this URL:
	* {@code http://username:password@host:8080/directory/file?query#ref}:
	* <table>
	* <tr><th>Component</th><th>Example value</th><th>Also known as</th></tr>
	* <tr><td>{@link #getProtocol() Protocol}</td><td>{@code http}</td><td>scheme</td></tr>
	* <tr><td>{@link #getAuthority() Authority}</td><td>{@code username:password@host:8080}</td><td></td></tr>
	* <tr><td>{@link #getUserInfo() User Info}</td><td>{@code username:password}</td><td></td></tr>
	* <tr><td>{@link #getHost() Host}</td><td>{@code host}</td><td></td></tr>
	* <tr><td>{@link #getPort() Port}</td><td>{@code 8080}</td><td></td></tr>
	* <tr><td>{@link #getFile() File}</td><td>{@code /directory/file?query}</td><td></td></tr>
	* <tr><td>{@link #getPath() Path}</td><td>{@code /directory/file}</td><td></td></tr>
	* <tr><td>{@link #getQuery() Query}</td><td>{@code query}</td><td></td></tr>
	* <tr><td>{@link #getRef() Ref}</td><td>{@code ref}</td><td>fragment</td></tr>
	* </table>
	*
	* <h3>Supported Protocols</h3>
	* This class may be used to construct URLs with the following protocols:
	* <ul>
	* <li><strong>file</strong>: read files from the local filesystem.
	* <li><strong>ftp</strong>: <a href="http://www.ietf.org/rfc/rfc959.txt">File
	* Transfer Protocol</a>
	* <li><strong>http</strong>: <a href="http://www.ietf.org/rfc/rfc2616.txt">Hypertext
	* Transfer Protocol</a>
	* <li><strong>https</strong>: <a href="http://www.ietf.org/rfc/rfc2818.txt">HTTP
	* over TLS</a>
	* <li><strong>jar</strong>: read {@link JarFile Jar files} from the
	* filesystem</li>
	* </ul>
	* In general, attempts to create URLs with any other protocol will fail with a
	* {@link MalformedURLException}. Applications may install handlers for other
	* schemes using {@link #setURLStreamHandlerFactory} or with the {@code
	* java.protocol.handler.pkgs} system property.
	*
	* <p>The {@link URI} class can be used to manipulate URLs of any protocol.
	*/
	public final class URL implements Serializable {
	private static final long serialVersionUID = -7627629688361524110L;

	private static URLStreamHandlerFactory streamHandlerFactory;

	/** Cache of protocols to their handlers */
	private static final Hashtable<String, URLStreamHandler> streamHandlers
	= new Hashtable<String, URLStreamHandler>();

	private String protocol;
	private String authority;
	private String host;
	private int port = -1;
	private String file;
	private String ref;

	private transient String userInfo;
	private transient String path;
	private transient String query;

	transient URLStreamHandler streamHandler;

	/**
	* The cached hash code, or 0 if it hasn't been computed yet. Unlike the RI,
	* this implementation's hashCode is transient because the hash code is
	* unspecified and may vary between VMs or versions.
	*/
	private transient int hashCode;

	/**
	* Sets the stream handler factory for this VM.
	*
	* @throws Error if a URLStreamHandlerFactory has already been installed
	* for the current VM.
	*/
	public static synchronized void setURLStreamHandlerFactory(URLStreamHandlerFactory factory) {
	if (streamHandlerFactory != null) {
	throw new Error("Factory already set");
	}
	streamHandlers.clear();
	streamHandlerFactory = factory;
	}

	/**
	* Creates a new URL instance by parsing {@code spec}.
	*
	* @throws MalformedURLException if {@code spec} could not be parsed as a
	* URL.
	*/
	public URL(String spec) throws MalformedURLException {
	this((URL) null, spec, null);
	}

	/**
	* Creates a new URL by resolving {@code spec} relative to {@code context}.
	*
	* @param context the URL to which {@code spec} is relative, or null for
	* no context in which case {@code spec} must be an absolute URL.
	* @throws MalformedURLException if {@code spec} could not be parsed as a
	* URL or has an unsupported protocol.
	*/
	public URL(URL context, String spec) throws MalformedURLException {
	this(context, spec, null);
	}

	/**
	* Creates a new URL by resolving {@code spec} relative to {@code context}.
	*
	* @param context the URL to which {@code spec} is relative, or null for
	* no context in which case {@code spec} must be an absolute URL.
	* @param handler the stream handler for this URL, or null for the
	* protocol's default stream handler.
	* @throws MalformedURLException if the given string {@code spec} could not
	* be parsed as a URL or an invalid protocol has been found.
	*/
	public URL(URL context, String spec, URLStreamHandler handler) throws MalformedURLException {
	if (spec == null) {
	throw new MalformedURLException();
	}
	if (handler != null) {
	streamHandler = handler;
	}
	spec = spec.trim();

	protocol = UrlUtils.getSchemePrefix(spec);
	int schemeSpecificPartStart = protocol != null ? (protocol.length() + 1) : 0;

	// If the context URL has a different protocol, discard it because we can't use it.
	if (protocol != null && context != null && !protocol.equals(context.protocol)) {
	context = null;
	}

	// Inherit from the context URL if it exists.
	if (context != null) {
	set(context.protocol, context.getHost(), context.getPort(), context.getAuthority(),
	context.getUserInfo(), context.getPath(), context.getQuery(),
	context.getRef());
	if (streamHandler == null) {
	streamHandler = context.streamHandler;
	}
	} else if (protocol == null) {
	throw new MalformedURLException("Protocol not found: " + spec);
	}

	if (streamHandler == null) {
	setupStreamHandler();
	if (streamHandler == null) {
	throw new MalformedURLException("Unknown protocol: " + protocol);
	}
	}

	// Parse the URL. If the handler throws any exception, throw MalformedURLException instead.
	try {
	streamHandler.parseURL(this, spec, schemeSpecificPartStart, spec.length());
	} catch (Exception e) {
	throw new MalformedURLException(e.toString());
	}
	}

	/**
	* Creates a new URL of the given component parts. The URL uses the
	* protocol's default port.
	*
	* @throws MalformedURLException if the combination of all arguments do not
	* represent a valid URL or if the protocol is invalid.
	*/
	public URL(String protocol, String host, String file) throws MalformedURLException {
	this(protocol, host, -1, file, null);
	}

	/**
	* Creates a new URL of the given component parts. The URL uses the
	* protocol's default port.
	*
	* @param host the host name or IP address of the new URL.
	* @param port the port, or {@code -1} for the protocol's default port.
	* @param file the name of the resource.
	* @throws MalformedURLException if the combination of all arguments do not
	* represent a valid URL or if the protocol is invalid.
	*/
	public URL(String protocol, String host, int port, String file) throws MalformedURLException {
	this(protocol, host, port, file, null);
	}

	/**
	* Creates a new URL of the given component parts. The URL uses the
	* protocol's default port.
	*
	* @param host the host name or IP address of the new URL.
	* @param port the port, or {@code -1} for the protocol's default port.
	* @param file the name of the resource.
	* @param handler the stream handler for this URL, or null for the
	* protocol's default stream handler.
	* @throws MalformedURLException if the combination of all arguments do not
	* represent a valid URL or if the protocol is invalid.
	*/
	public URL(String protocol, String host, int port, String file,
	URLStreamHandler handler) throws MalformedURLException {
	if (port < -1) {
	throw new MalformedURLException("port < -1: " + port);
	}
	if (protocol == null) {
	throw new NullPointerException("protocol == null");
	}

	// Wrap IPv6 addresses in square brackets if they aren't already.
	if (host != null && host.contains(":") && host.charAt(0) != '[') {
	host = "[" + host + "]";
	}

	this.protocol = protocol;
	this.host = host;
	this.port = port;

	file = UrlUtils.authoritySafePath(host, file);

	// Set the fields from the arguments. Handle the case where the
	// passed in "file" includes both a file and a reference part.
	int hash = file.indexOf("#");
	if (hash != -1) {
	this.file = file.substring(0, hash);
	this.ref = file.substring(hash + 1);
	} else {
	this.file = file;
	}
	fixURL(false);

	// Set the stream handler for the URL either to the handler
	// argument if it was specified, or to the default for the
	// receiver's protocol if the handler was null.
	if (handler == null) {
	setupStreamHandler();
	if (streamHandler == null) {
	throw new MalformedURLException("Unknown protocol: " + protocol);
	}
	} else {
	streamHandler = handler;
	}
	}

	void fixURL(boolean fixHost) {
	int index;
	if (host != null && host.length() > 0) {
	authority = host;
	if (port != -1) {
	authority = authority + ":" + port;
	}
	}
	if (fixHost) {
	if (host != null && (index = host.lastIndexOf('@')) > -1) {
	userInfo = host.substring(0, index);
	host = host.substring(index + 1);
	} else {
	userInfo = null;
	}
	}
	if (file != null && (index = file.indexOf('?')) > -1) {
	query = file.substring(index + 1);
	path = file.substring(0, index);
	} else {
	query = null;
	path = file;
	}
	}

	/**
	* Sets the properties of this URL using the provided arguments. Only a
	* {@code URLStreamHandler} can use this method to set fields of the
	* existing URL instance. A URL is generally constant.
	*/
	protected void set(String protocol, String host, int port, String file, String ref) {
	if (this.protocol == null) {
	this.protocol = protocol;
	}
	this.host = host;
	this.file = file;
	this.port = port;
	this.ref = ref;
	hashCode = 0;
	fixURL(true);
	}

	/**
	* Returns true if this URL equals {@code o}. URLs are equal if they have
	* the same protocol, host, port, file, and reference.
	*
	* <h3>Network I/O Warning</h3>
	* <p>Some implementations of URL.equals() resolve host names over the
	* network. This is problematic:
	* <ul>
	* <li><strong>The network may be slow.</strong> Many classes, including
	* core collections like {@link java.util.Map Map} and {@link java.util.Set
	* Set} expect that {@code equals} and {@code hashCode} will return quickly.
	* By violating this assumption, this method posed potential performance
	* problems.
	* <li><strong>Equal IP addresses do not imply equal content.</strong>
	* Virtual hosting permits unrelated sites to share an IP address. This
	* method could report two otherwise unrelated URLs to be equal because
	* they're hosted on the same server.</li>
	* <li><strong>The network many not be available.</strong> Two URLs could be
	* equal when a network is available and unequal otherwise.</li>
	* <li><strong>The network may change.</strong> The IP address for a given
	* host name varies by network and over time. This is problematic for mobile
	* devices. Two URLs could be equal on some networks and unequal on
	* others.</li>
	* </ul>
	* <p>This problem is fixed in Android 4.0 (Ice Cream Sandwich). In that
	* release, URLs are only equal if their host names are equal (ignoring
	* case).
	*/
	@Override public boolean equals(Object o) {
	if (o == null) {
	return false;
	}
	if (this == o) {
	return true;
	}
	if (this.getClass() != o.getClass()) {
	return false;
	}
	return streamHandler.equals(this, (URL) o);
	}

	/**
	* Returns true if this URL refers to the same resource as {@code otherURL}.
	* All URL components except the reference field are compared.
	*/
	public boolean sameFile(URL otherURL) {
	return streamHandler.sameFile(this, otherURL);
	}

	@Override public int hashCode() {
	if (hashCode == 0) {
	hashCode = streamHandler.hashCode(this);
	}
	return hashCode;
	}

	/**
	* Sets the receiver's stream handler to one which is appropriate for its
	* protocol.
	*
	* <p>Note that this will overwrite any existing stream handler with the new
	* one. Senders must check if the streamHandler is null before calling the
	* method if they do not want this behavior (a speed optimization).
	*
	* @throws MalformedURLException if no reasonable handler is available.
	*/
	void setupStreamHandler() {
	// Check for a cached (previously looked up) handler for
	// the requested protocol.
	streamHandler = streamHandlers.get(protocol);
	if (streamHandler != null) {
	return;
	}

	// If there is a stream handler factory, then attempt to
	// use it to create the handler.
	if (streamHandlerFactory != null) {
	streamHandler = streamHandlerFactory.createURLStreamHandler(protocol);
	if (streamHandler != null) {
	streamHandlers.put(protocol, streamHandler);
	return;
	}
	}

	// Check if there is a list of packages which can provide handlers.
	// If so, then walk this list looking for an applicable one.
	String packageList = System.getProperty("java.protocol.handler.pkgs");
	ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
	if (packageList != null && contextClassLoader != null) {
	for (String packageName : packageList.split("\\\|")) {
	String className = packageName + "." + protocol + ".Handler";
	try {
	Class<?> c = contextClassLoader.loadClass(className);
	streamHandler = (URLStreamHandler) c.newInstance();
	if (streamHandler != null) {
	streamHandlers.put(protocol, streamHandler);
	}
	return;
	} catch (IllegalAccessException ignored) {
	} catch (InstantiationException ignored) {
	} catch (ClassNotFoundException ignored) {
	}
	}
	}

	// Fall back to a built-in stream handler if the user didn't supply one
	if (protocol.equals("file")) {
	streamHandler = new FileHandler();
	} else if (protocol.equals("ftp")) {
	streamHandler = new FtpHandler();
	} else if (protocol.equals("http")) {
	streamHandler = new HttpHandler();
	} else if (protocol.equals("https")) {
	streamHandler = new HttpsHandler();
	} else if (protocol.equals("jar")) {
	streamHandler = new JarHandler();
	}
	if (streamHandler != null) {
	streamHandlers.put(protocol, streamHandler);
	}
	}

	/**
	* Returns the content of the resource which is referred by this URL. By
	* default this returns an {@code InputStream}, or null if the content type
	* of the response is unknown.
	*/
	public final Object getContent() throws IOException {
	return openConnection().getContent();
	}

	/**
	* Equivalent to {@code openConnection().getContent(types)}.
	*/
	@SuppressWarnings("unchecked") // Param not generic in spec
	public final Object getContent(Class[] types) throws IOException {
	return openConnection().getContent(types);
	}

	/**
	* Equivalent to {@code openConnection().getInputStream(types)}.
	*/
	public final InputStream openStream() throws IOException {
	return openConnection().getInputStream();
	}

	/**
	* Returns a new connection to the resource referred to by this URL.
	*
	* @throws IOException if an error occurs while opening the connection.
	*/
	public URLConnection openConnection() throws IOException {
	return streamHandler.openConnection(this);
	}

	/**
	* Returns a new connection to the resource referred to by this URL.
	*
	* @param proxy the proxy through which the connection will be established.
	* @throws IOException if an I/O error occurs while opening the connection.
	* @throws IllegalArgumentException if the argument proxy is null or of is
	* an invalid type.
	* @throws UnsupportedOperationException if the protocol handler does not
	* support opening connections through proxies.
	*/
	public URLConnection openConnection(Proxy proxy) throws IOException {
	if (proxy == null) {
	throw new IllegalArgumentException("proxy == null");
	}
	return streamHandler.openConnection(this, proxy);
	}

	/**
	* Returns the URI equivalent to this URL.
	*
	* @throws URISyntaxException if this URL cannot be converted into a URI.
	*/
	public URI toURI() throws URISyntaxException {
	return new URI(toExternalForm());
	}

	/**
	* Encodes this URL to the equivalent URI after escaping characters that are
	* not permitted by URI.
	*
	* @hide
	*/
	public URI toURILenient() throws URISyntaxException {
	if (streamHandler == null) {
	throw new IllegalStateException(protocol);
	}
	return new URI(streamHandler.toExternalForm(this, true));
	}

	/**
	* Returns a string containing a concise, human-readable representation of
	* this URL. The returned string is the same as the result of the method
	* {@code toExternalForm()}.
	*/
	@Override public String toString() {
	return toExternalForm();
	}

	/**
	* Returns a string containing a concise, human-readable representation of
	* this URL.
	*/
	public String toExternalForm() {
	if (streamHandler == null) {
	return "unknown protocol(" + protocol + ")://" + host + file;
	}
	return streamHandler.toExternalForm(this);
	}

	private void readObject(ObjectInputStream stream) throws IOException {
	try {
	stream.defaultReadObject();
	if (host != null && authority == null) {
	fixURL(true);
	} else if (authority != null) {
	int index;
	if ((index = authority.lastIndexOf('@')) > -1) {
	userInfo = authority.substring(0, index);
	}
	if (file != null && (index = file.indexOf('?')) > -1) {
	query = file.substring(index + 1);
	path = file.substring(0, index);
	} else {
	path = file;
	}
	}
	setupStreamHandler();
	if (streamHandler == null) {
	throw new IOException("Unknown protocol: " + protocol);
	}
	hashCode = 0; // necessary until http://b/4471249 is fixed
	} catch (ClassNotFoundException e) {
	throw new IOException(e);
	}
	}

	private void writeObject(ObjectOutputStream s) throws IOException {
	s.defaultWriteObject();
	}

	/** @hide */
	public int getEffectivePort() {
	return URI.getEffectivePort(protocol, port);
	}

	/**
	* Returns the protocol of this URL like "http" or "file". This is also
	* known as the scheme. The returned string is lower case.
	*/
	public String getProtocol() {
	return protocol;
	}

	/**
	* Returns the authority part of this URL, or null if this URL has no
	* authority.
	*/
	public String getAuthority() {
	return authority;
	}

	/**
	* Returns the user info of this URL, or null if this URL has no user info.
	*/
	public String getUserInfo() {
	return userInfo;
	}

	/**
	* Returns the host name or IP address of this URL.
	*/
	public String getHost() {
	return host;
	}

	/**
	* Returns the port number of this URL or {@code -1} if this URL has no
	* explicit port.
	*
	* <p>If this URL has no explicit port, connections opened using this URL
	* will use its {@link #getDefaultPort() default port}.
	*/
	public int getPort() {
	return port;
	}

	/**
	* Returns the default port number of the protocol used by this URL. If no
	* default port is defined by the protocol or the {@code URLStreamHandler},
	* {@code -1} will be returned.
	*
	* @see URLStreamHandler#getDefaultPort
	*/
	public int getDefaultPort() {
	return streamHandler.getDefaultPort();
	}

	/**
	* Returns the file of this URL.
	*/
	public String getFile() {
	return file;
	}

	/**
	* Returns the path part of this URL.
	*/
	public String getPath() {
	return path;
	}

	/**
	* Returns the query part of this URL, or null if this URL has no query.
	*/
	public String getQuery() {
	return query;
	}

	/**
	* Returns the value of the reference part of this URL, or null if this URL
	* has no reference part. This is also known as the fragment.
	*/
	public String getRef() {
	return ref;
	}

	/**
	* Sets the properties of this URL using the provided arguments. Only a
	* {@code URLStreamHandler} can use this method to set fields of the
	* existing URL instance. A URL is generally constant.
	*/
	protected void set(String protocol, String host, int port, String authority, String userInfo,
	String path, String query, String ref) {
	String file = path;
	if (query != null && !query.isEmpty()) {
	file += "?" + query;
	}
	set(protocol, host, port, file, ref);
	this.authority = authority;
	this.userInfo = userInfo;
	this.path = path;
	this.query = query;
	}
	}