/**@class android.net.Uri
 implements android.os.Parcelable

 implements java.lang.Comparable

@extends java.lang.Object

 Immutable URI reference. A URI reference includes a URI and a fragment, the
 component of the URI following a '#'. Builds and parses URI references
 which conform to
 <a href="http://www.faqs.org/rfcs/rfc2396.html">RFC 2396</a>.

 <p>In the interest of performance, this class performs little to no
 validation. Behavior is undefined for invalid input. This class is very
 forgiving--in the face of invalid input, it will return garbage
 rather than throw an exception unless otherwise specified.
*/
var Uri = {

/** The empty URI, equivalent to "".
*/
EMPTY : "null",
/** Reads Uris from Parcels.
*/
CREATOR : "null",
/**Returns true if this URI is hierarchical like "http://google.com".
 Absolute URIs are hierarchical if the scheme-specific part starts with
 a '/'. Relative URIs are always hierarchical.
*/
isHierarchical : function(  ) {},

/**Returns true if this URI is opaque like "mailto:nobody@google.com". The
 scheme-specific part of an opaque URI cannot start with a '/'.
*/
isOpaque : function(  ) {},

/**Returns true if this URI is relative, i.e.&nbsp;if it doesn't contain an
 explicit scheme.
@return {Boolean} true if this URI is relative, false if it's absolute
*/
isRelative : function(  ) {},

/**Returns true if this URI is absolute, i.e.&nbsp;if it contains an
 explicit scheme.
@return {Boolean} true if this URI is absolute, false if it's relative
*/
isAbsolute : function(  ) {},

/**Gets the scheme of this URI. Example: "http"
@return {String} the scheme or null if this is a relative URI
*/
getScheme : function(  ) {},

/**Gets the scheme-specific part of this URI, i.e.&nbsp;everything between
 the scheme separator ':' and the fragment separator '#'. If this is a
 relative URI, this method returns the entire URI. Decodes escaped octets.

 <p>Example: "//www.google.com/search?q=android"
@return {String} the decoded scheme-specific-part
*/
getSchemeSpecificPart : function(  ) {},

/**Gets the scheme-specific part of this URI, i.e.&nbsp;everything between
 the scheme separator ':' and the fragment separator '#'. If this is a
 relative URI, this method returns the entire URI. Leaves escaped octets
 intact.

 <p>Example: "//www.google.com/search?q=android"
@return {String} the decoded scheme-specific-part
*/
getEncodedSchemeSpecificPart : function(  ) {},

/**Gets the decoded authority part of this URI. For
 server addresses, the authority is structured as follows:
 {@code [ userinfo '@' ] host [ ':' port ]}

 <p>Examples: "google.com", "bob@google.com:80"
@return {String} the authority for this URI or null if not present
*/
getAuthority : function(  ) {},

/**Gets the encoded authority part of this URI. For
 server addresses, the authority is structured as follows:
 {@code [ userinfo '@' ] host [ ':' port ]}

 <p>Examples: "google.com", "bob@google.com:80"
@return {String} the authority for this URI or null if not present
*/
getEncodedAuthority : function(  ) {},

/**Gets the decoded user information from the authority.
 For example, if the authority is "nobody@google.com", this method will
 return "nobody".
@return {String} the user info for this URI or null if not present
*/
getUserInfo : function(  ) {},

/**Gets the encoded user information from the authority.
 For example, if the authority is "nobody@google.com", this method will
 return "nobody".
@return {String} the user info for this URI or null if not present
*/
getEncodedUserInfo : function(  ) {},

/**Gets the encoded host from the authority for this URI. For example,
 if the authority is "bob@google.com", this method will return
 "google.com".
@return {String} the host for this URI or null if not present
*/
getHost : function(  ) {},

/**Gets the port from the authority for this URI. For example,
 if the authority is "google.com:80", this method will return 80.
@return {Number} the port for this URI or -1 if invalid or not present
*/
getPort : function(  ) {},

/**Gets the decoded path.
@return {String} the decoded path, or null if this is not a hierarchical URI
 (like "mailto:nobody@google.com") or the URI is invalid
*/
getPath : function(  ) {},

/**Gets the encoded path.
@return {String} the encoded path, or null if this is not a hierarchical URI
 (like "mailto:nobody@google.com") or the URI is invalid
*/
getEncodedPath : function(  ) {},

/**Gets the decoded query component from this URI. The query comes after
 the query separator ('?') and before the fragment separator ('#'). This
 method would return "q=android" for
 "http://www.google.com/search?q=android".
@return {String} the decoded query or null if there isn't one
*/
getQuery : function(  ) {},

/**Gets the encoded query component from this URI. The query comes after
 the query separator ('?') and before the fragment separator ('#'). This
 method would return "q=android" for
 "http://www.google.com/search?q=android".
@return {String} the encoded query or null if there isn't one
*/
getEncodedQuery : function(  ) {},

/**Gets the decoded fragment part of this URI, everything after the '#'.
@return {String} the decoded fragment or null if there isn't one
*/
getFragment : function(  ) {},

/**Gets the encoded fragment part of this URI, everything after the '#'.
@return {String} the encoded fragment or null if there isn't one
*/
getEncodedFragment : function(  ) {},

/**Gets the decoded path segments.
@return {Object {java.util.List}} decoded path segments, each without a leading or trailing '/'
*/
getPathSegments : function(  ) {},

/**Gets the decoded last segment in the path.
@return {String} the decoded last segment or null if the path is empty
*/
getLastPathSegment : function(  ) {},

/**Compares this Uri to another object for equality. Returns true if the
 encoded string representations of this Uri and the given Uri are
 equal. Case counts. Paths are not normalized. If one Uri specifies a
 default port explicitly and the other leaves it implicit, they will not
 be considered equal.
*/
equals : function(  ) {},

/**Hashes the encoded string represention of this Uri consistently with
 {@link #equals}(Object).
*/
hashCode : function(  ) {},

/**Compares the string representation of this Uri with that of
 another.
*/
compareTo : function(  ) {},

/**Returns the encoded string representation of this URI.
 Example: "http://google.com/"
*/
toString : function(  ) {},

/**Return a string representation of the URI that is safe to print
 to logs and other places where PII should be avoided.
@hide 
*/
toSafeString : function(  ) {},

/**Constructs a new builder, copying the attributes from this Uri.
*/
buildUpon : function(  ) {},

/**Creates a Uri which parses the given encoded URI string.
@param {String} uriString an RFC 2396-compliant, encoded URI
@throws NullPointerException if uriString is null
@return {Object {android.net.Uri}} Uri for this given uri string
*/
parse : function(  ) {},

/**Creates a Uri from a file. The URI has the form
 "file://<absolute path>". Encodes path characters with the exception of
 '/'.

 <p>Example: "file:///tmp/android.txt"
@throws NullPointerException if file is null
@return {Object {android.net.Uri}} a Uri for the given file
*/
fromFile : function(  ) {},

/**Creates an opaque Uri from the given components. Encodes the ssp
 which means this method cannot be used to create hierarchical URIs.
@param {String} scheme of the URI
@param {String} ssp scheme-specific-part, everything between the
  scheme separator (':') and the fragment separator ('#'), which will
  get encoded
@param {String} fragment fragment, everything after the '#', null if undefined,
  will get encoded
@throws NullPointerException if scheme or ssp is null
@return {Object {android.net.Uri}} Uri composed of the given scheme, ssp, and fragment
@see Builder if you don't want the ssp and fragment to be encoded
*/
fromParts : function(  ) {},

/**Returns a set of the unique names of all query parameters. Iterating
 over the set will return the names in order of their first occurrence.
@throws UnsupportedOperationException if this isn't a hierarchical URI
@return {Object {java.util.Set}} a set of decoded names
*/
getQueryParameterNames : function(  ) {},

/**Searches the query string for parameter values with the given key.
@param {String} key which will be encoded
@throws UnsupportedOperationException if this isn't a hierarchical URI
@throws NullPointerException if key is null
@return {Object {java.util.List}} a list of decoded values
*/
getQueryParameters : function(  ) {},

/**Searches the query string for the first value with the given key.

 <p><strong>Warning:</strong> Prior to Jelly Bean, this decoded
 the '+' character as '+' rather than ' '.
@param {String} key which will be encoded
@throws UnsupportedOperationException if this isn't a hierarchical URI
@throws NullPointerException if key is null
@return {String} the decoded value or null if no parameter is found
*/
getQueryParameter : function(  ) {},

/**Searches the query string for the first value with the given key and interprets it
 as a boolean value. "false" and "0" are interpreted as <code>false</code>, everything
 else is interpreted as <code>true</code>.
@param {String} key which will be decoded
@param {Boolean} defaultValue the default value to return if there is no query parameter for key
@return {Boolean} the boolean interpretation of the query parameter key
*/
getBooleanQueryParameter : function(  ) {},

/**Return an equivalent URI with a lowercase scheme component.
 This aligns the Uri with Android best practices for
 intent filtering.

 <p>For example, "HTTP://www.android.com" becomes
 "http://www.android.com"

 <p>All URIs received from outside Android (such as user input,
 or external sources like Bluetooth, NFC, or the Internet) should
 be normalized before they are used to create an Intent.

 <p class="note">This method does <em>not</em> validate bad URI's,
 or 'fix' poorly formatted URI's - so do not use it for input validation.
 A Uri will always be returned, even if the Uri is badly formatted to
 begin with and a scheme component cannot be found.
@return {Object {android.net.Uri}} normalized Uri (never null)
@see {@link android.content.Intent#setData}
@see {@link android.content.Intent#setDataAndNormalize}
*/
normalizeScheme : function(  ) {},

/**Writes a Uri to a Parcel.
@param {Object {Parcel}} out parcel to write to
@param {Object {Uri}} uri to write, can be null
*/
writeToParcel : function(  ) {},

/**Encodes characters in the given string as '%'-escaped octets
 using the UTF-8 scheme. Leaves letters ("A-Z", "a-z"), numbers
 ("0-9"), and unreserved characters ("_-!.~'()*") intact. Encodes
 all other characters.
@param {String} s string to encode
@return {String} an encoded version of s suitable for use as a URI component,
  or null if s is null
*/
encode : function(  ) {},

/**Encodes characters in the given string as '%'-escaped octets
 using the UTF-8 scheme. Leaves letters ("A-Z", "a-z"), numbers
 ("0-9"), and unreserved characters ("_-!.~'()*") intact. Encodes
 all other characters with the exception of those specified in the
 allow argument.
@param {String} s string to encode
@param {String} allow set of additional characters to allow in the encoded form,
  null if no characters should be skipped
@return {String} an encoded version of s suitable for use as a URI component,
  or null if s is null
*/
encode : function(  ) {},

/**Decodes '%'-escaped octets in the given string using the UTF-8 scheme.
 Replaces invalid octets with the unicode replacement character
 ("\\uFFFD").
@param {String} s encoded string to decode
@return {String} the given string with escaped octets decoded, or null if
  s is null
*/
decode : function(  ) {},

/**Creates a new Uri by appending an already-encoded path segment to a
 base Uri.
@param {Object {Uri}} baseUri Uri to append path segment to
@param {String} pathSegment encoded path segment to append
@return {Object {android.net.Uri}} a new Uri based on baseUri with the given segment appended to
  the path
@throws NullPointerException if baseUri is null
*/
withAppendedPath : function(  ) {},

/**If this {@link android.net.Uri} is {@code file://}, then resolve and return its
 canonical path. Also fixes legacy emulated storage paths so they are
 usable across user boundaries. Should always be called from the app
 process before sending elsewhere.
@hide 
*/
getCanonicalUri : function(  ) {},

/**If this is a {@code file://} Uri, it will be reported to
 {@link StrictMode}.
@hide 
*/
checkFileUriExposed : function(  ) {},

/**Test if this is a path prefix match against the given Uri. Verifies that
 scheme, authority, and atomic path segments match.
@hide 
*/
isPathPrefixMatch : function(  ) {},


};