/*

/** Log tag. */

private static final String LOG = Uri.class.getSimpleName();

/**

@SuppressWarnings("RedundantStringConstructorCall")

private static final String NOT_CACHED = new String("NOT CACHED");

/**

public static final Uri EMPTY = new HierarchicalUri(null, Part.NULL,

PathPart.EMPTY, Part.NULL, Part.NULL);

/**

private Uri() {}

/**

public abstract boolean isHierarchical();

/**

public boolean isOpaque() {

return !isHierarchical();

}

/**

public abstract boolean isRelative();

/**

public boolean isAbsolute() {

return !isRelative();

}

/**

public abstract String getScheme();

/**

public abstract String getSchemeSpecificPart();

/**

public abstract String getEncodedSchemeSpecificPart();

/**

public abstract String getAuthority();

/**

public abstract String getEncodedAuthority();

/**

public abstract String getUserInfo();

/**

public abstract String getEncodedUserInfo();

/**

public abstract String getHost();

/**

public abstract int getPort();

/**

public abstract String getPath();

/**

public abstract String getEncodedPath();

/**

public abstract String getQuery();

/**

public abstract String getEncodedQuery();

/**

public abstract String getFragment();

/**

public abstract String getEncodedFragment();

/**

public abstract List<String> getPathSegments();

/**

public abstract String getLastPathSegment();

/**

public boolean equals(Object o) {

if (!(o instanceof Uri)) {

return false;

}

Uri other = (Uri) o;

return toString().equals(other.toString());

}

/**

public int hashCode() {

return toString().hashCode();

}

/**

public int compareTo(Uri other) {

return toString().compareTo(other.toString());

}

/**

public abstract String toString();

/**

public String toSafeString() {

String scheme = getScheme();

String ssp = getSchemeSpecificPart();

if (scheme != null) {

if (scheme.equalsIgnoreCase("tel") || scheme.equalsIgnoreCase("sip")

|| scheme.equalsIgnoreCase("sms") || scheme.equalsIgnoreCase("smsto")

|| scheme.equalsIgnoreCase("mailto")) {

StringBuilder builder = new StringBuilder(64);

builder.append(scheme);

builder.append(':');

if (ssp != null) {

for (int i=0; i<ssp.length(); i++) {

char c = ssp.charAt(i);

if (c == '-' || c == '@' || c == '.') {

builder.append(c);

} else {

builder.append('x');

}

}

}

return builder.toString();

}

}

// Not a sensitive scheme, but let's still be conservative about

// the data we include -- only the ssp, not the query params or

// fragment, because those can often have sensitive info.

StringBuilder builder = new StringBuilder(64);

if (scheme != null) {

builder.append(scheme);

builder.append(':');

}

if (ssp != null) {

builder.append(ssp);

}

return builder.toString();

}

/**

public abstract Builder buildUpon();

/** Index of a component which was not found. */

private final static int NOT_FOUND = -1;

/** Placeholder value for an index which hasn't been calculated yet. */

private final static int NOT_CALCULATED = -2;

/**

private static final String NOT_HIERARCHICAL

= "This isn't a hierarchical URI.";

/** Default encoding. */

private static final String DEFAULT_ENCODING = "UTF-8";

/**

public static Uri parse(String uriString) {

return new StringUri(uriString);

}

/**

public static Uri fromFile(File file) {

if (file == null) {

throw new NullPointerException("file");

}

PathPart path = PathPart.fromDecoded(file.getAbsolutePath());

return new HierarchicalUri(

"file", Part.EMPTY, path, Part.NULL, Part.NULL);

}

/**

private static class StringUri extends AbstractHierarchicalUri {

/** Used in parcelling. */

static final int TYPE_ID = 1;

/** URI string representation. */

private final String uriString;

private StringUri(String uriString) {

if (uriString == null) {

throw new NullPointerException("uriString");

}

this.uriString = uriString;

}

static Uri readFrom(Parcel parcel) {

return new StringUri(parcel.readString());

}

public int describeContents() {

return 0;

}

public void writeToParcel(Parcel parcel, int flags) {

parcel.writeInt(TYPE_ID);

parcel.writeString(uriString);

}

/** Cached scheme separator index. */

private volatile int cachedSsi = NOT_CALCULATED;

/** Finds the first ':'. Returns -1 if none found. */

private int findSchemeSeparator() {

return cachedSsi == NOT_CALCULATED

? cachedSsi = uriString.indexOf(':')

: cachedSsi;

}

/** Cached fragment separator index. */

private volatile int cachedFsi = NOT_CALCULATED;

/** Finds the first '#'. Returns -1 if none found. */

private int findFragmentSeparator() {

return cachedFsi == NOT_CALCULATED

? cachedFsi = uriString.indexOf('#', findSchemeSeparator())

: cachedFsi;

}

public boolean isHierarchical() {

int ssi = findSchemeSeparator();

if (ssi == NOT_FOUND) {

// All relative URIs are hierarchical.

return true;

}

if (uriString.length() == ssi + 1) {

// No ssp.

return false;

}

// If the ssp starts with a '/', this is hierarchical.

return uriString.charAt(ssi + 1) == '/';

}

public boolean isRelative() {

// Note: We return true if the index is 0

return findSchemeSeparator() == NOT_FOUND;

}

private volatile String scheme = NOT_CACHED;

public String getScheme() {

@SuppressWarnings("StringEquality")

boolean cached = (scheme != NOT_CACHED);

return cached ? scheme : (scheme = parseScheme());

}

private String parseScheme() {

int ssi = findSchemeSeparator();

return ssi == NOT_FOUND ? null : uriString.substring(0, ssi);

}

private Part ssp;

private Part getSsp() {

return ssp == null ? ssp = Part.fromEncoded(parseSsp()) : ssp;

}

public String getEncodedSchemeSpecificPart() {

return getSsp().getEncoded();

}

public String getSchemeSpecificPart() {

return getSsp().getDecoded();

}

private String parseSsp() {

int ssi = findSchemeSeparator();

int fsi = findFragmentSeparator();

// Return everything between ssi and fsi.

return fsi == NOT_FOUND

? uriString.substring(ssi + 1)

: uriString.substring(ssi + 1, fsi);

}

private Part authority;

private Part getAuthorityPart() {

if (authority == null) {

String encodedAuthority

= parseAuthority(this.uriString, findSchemeSeparator());

return authority = Part.fromEncoded(encodedAuthority);

}

return authority;

}

public String getEncodedAuthority() {

return getAuthorityPart().getEncoded();

}

public String getAuthority() {

return getAuthorityPart().getDecoded();

}

private PathPart path;

private PathPart getPathPart() {

return path == null

? path = PathPart.fromEncoded(parsePath())

: path;

}

public String getPath() {

return getPathPart().getDecoded();

}

public String getEncodedPath() {

return getPathPart().getEncoded();

}

public List<String> getPathSegments() {

return getPathPart().getPathSegments();

}

private String parsePath() {

String uriString = this.uriString;

int ssi = findSchemeSeparator();

// If the URI is absolute.

if (ssi > -1) {

// Is there anything after the ':'?

boolean schemeOnly = ssi + 1 == uriString.length();

if (schemeOnly) {

// Opaque URI.

return null;

}

// A '/' after the ':' means this is hierarchical.

if (uriString.charAt(ssi + 1) != '/') {

// Opaque URI.

return null;

}

} else {

// All relative URIs are hierarchical.

}

return parsePath(uriString, ssi);

}

private Part query;

private Part getQueryPart() {

return query == null

? query = Part.fromEncoded(parseQuery()) : query;

}

public String getEncodedQuery() {

return getQueryPart().getEncoded();

}

private String parseQuery() {

// It doesn't make sense to cache this index. We only ever

// calculate it once.

int qsi = uriString.indexOf('?', findSchemeSeparator());

if (qsi == NOT_FOUND) {

return null;

}

int fsi = findFragmentSeparator();

if (fsi == NOT_FOUND) {

return uriString.substring(qsi + 1);

}

if (fsi < qsi) {

// Invalid.

return null;

}

return uriString.substring(qsi + 1, fsi);

}

public String getQuery() {

return getQueryPart().getDecoded();

}

private Part fragment;

private Part getFragmentPart() {

return fragment == null

? fragment = Part.fromEncoded(parseFragment()) : fragment;

}

public String getEncodedFragment() {

return getFragmentPart().getEncoded();

}

private String parseFragment() {

int fsi = findFragmentSeparator();

return fsi == NOT_FOUND ? null : uriString.substring(fsi + 1);

}

public String getFragment() {

return getFragmentPart().getDecoded();

}

public String toString() {

return uriString;

}

/**

static String parseAuthority(String uriString, int ssi) {

int length = uriString.length();

// If "//" follows the scheme separator, we have an authority.

if (length > ssi + 2

&& uriString.charAt(ssi + 1) == '/'

&& uriString.charAt(ssi + 2) == '/') {

// We have an authority.

// Look for the start of the path, query, or fragment, or the

// end of the string.

int end = ssi + 3;

LOOP: while (end < length) {

switch (uriString.charAt(end)) {

case '/': // Start of path

case '?': // Start of query

case '#': // Start of fragment

break LOOP;

}

end++;

}

return uriString.substring(ssi + 3, end);

} else {

return null;

}

}

/**

static String parsePath(String uriString, int ssi) {

int length = uriString.length();

// Find start of path.

int pathStart;

if (length > ssi + 2

&& uriString.charAt(ssi + 1) == '/'

&& uriString.charAt(ssi + 2) == '/') {

// Skip over authority to path.

pathStart = ssi + 3;

LOOP: while (pathStart < length) {

switch (uriString.charAt(pathStart)) {

case '?': // Start of query

case '#': // Start of fragment

return ""; // Empty path.

case '/': // Start of path!

break LOOP;

}

pathStart++;

}

} else {

// Path starts immediately after scheme separator.

pathStart = ssi + 1;

}

// Find end of path.

int pathEnd = pathStart;

LOOP: while (pathEnd < length) {

switch (uriString.charAt(pathEnd)) {

case '?': // Start of query

case '#': // Start of fragment

break LOOP;

}

pathEnd++;

}

return uriString.substring(pathStart, pathEnd);

}

public Builder buildUpon() {

if (isHierarchical()) {

return new Builder()

.scheme(getScheme())

.authority(getAuthorityPart())

.path(getPathPart())

.query(getQueryPart())

.fragment(getFragmentPart());

} else {

return new Builder()

.scheme(getScheme())

.opaquePart(getSsp())

.fragment(getFragmentPart());

}

}

}

/**

public static Uri fromParts(String scheme, String ssp,

String fragment) {

if (scheme == null) {

throw new NullPointerException("scheme");

}

if (ssp == null) {

throw new NullPointerException("ssp");

}

return new OpaqueUri(scheme, Part.fromDecoded(ssp),

Part.fromDecoded(fragment));

}

/**

private static class OpaqueUri extends Uri {

/** Used in parcelling. */

static final int TYPE_ID = 2;

private final String scheme;

private final Part ssp;

private final Part fragment;

private OpaqueUri(String scheme, Part ssp, Part fragment) {

this.scheme = scheme;

this.ssp = ssp;

this.fragment = fragment == null ? Part.NULL : fragment;

}

static Uri readFrom(Parcel parcel) {

return new OpaqueUri(

parcel.readString(),

Part.readFrom(parcel),

Part.readFrom(parcel)

);

}

public int describeContents() {

return 0;

}

public void writeToParcel(Parcel parcel, int flags) {

parcel.writeInt(TYPE_ID);

parcel.writeString(scheme);

ssp.writeTo(parcel);

fragment.writeTo(parcel);

}

public boolean isHierarchical() {

return false;

}

public boolean isRelative() {

return scheme == null;

}

public String getScheme() {

return this.scheme;

}

public String getEncodedSchemeSpecificPart() {

return ssp.getEncoded();

}

public String getSchemeSpecificPart() {

return ssp.getDecoded();

}

public String getAuthority() {

return null;

}

public String getEncodedAuthority() {

return null;

}

public String getPath() {

return null;

}

public String getEncodedPath() {

return null;

}

public String getQuery() {

return null;

}

public String getEncodedQuery() {

return null;

}

public String getFragment() {

return fragment.getDecoded();

}

public String getEncodedFragment() {

return fragment.getEncoded();

}

public List<String> getPathSegments() {

return Collections.emptyList();

}

public String getLastPathSegment() {

return null;

}

public String getUserInfo() {

return null;

}

public String getEncodedUserInfo() {

return null;

}

public String getHost() {

return null;

}

public int getPort() {

return -1;

}

private volatile String cachedString = NOT_CACHED;

public String toString() {

@SuppressWarnings("StringEquality")

boolean cached = cachedString != NOT_CACHED;

if (cached) {

return cachedString;

}

StringBuilder sb = new StringBuilder();

sb.append(scheme).append(':');

sb.append(getEncodedSchemeSpecificPart());

if (!fragment.isEmpty()) {

sb.append('#').append(fragment.getEncoded());

}

return cachedString = sb.toString();

}

public Builder buildUpon() {

return new Builder()

.scheme(this.scheme)

.opaquePart(this.ssp)

.fragment(this.fragment);

}

}

/**

static class PathSegments extends AbstractList<String>

implements RandomAccess {

static final PathSegments EMPTY = new PathSegments(null, 0);

final String[] segments;

final int size;

PathSegments(String[] segments, int size) {

this.segments = segments;

this.size = size;

}

public String get(int index) {

if (index >= size) {

throw new IndexOutOfBoundsException();

}

return segments[index];

}

public int size() {

return this.size;

}

}

/**

static class PathSegmentsBuilder {

String[] segments;

int size = 0;

void add(String segment) {

if (segments == null) {

segments = new String[4];

} else if (size + 1 == segments.length) {