| /* |
| * 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.content; |
| |
| import android.annotation.IntDef; |
| import android.annotation.SystemApi; |
| import android.annotation.UnsupportedAppUsage; |
| import android.net.Uri; |
| import android.os.Build; |
| import android.os.Parcel; |
| import android.os.Parcelable; |
| import android.os.PatternMatcher; |
| import android.text.TextUtils; |
| import android.util.AndroidException; |
| import android.util.Log; |
| import android.util.Printer; |
| import android.util.proto.ProtoOutputStream; |
| |
| import com.android.internal.util.XmlUtils; |
| |
| import org.xmlpull.v1.XmlPullParser; |
| import org.xmlpull.v1.XmlPullParserException; |
| import org.xmlpull.v1.XmlSerializer; |
| |
| import java.io.IOException; |
| import java.lang.annotation.Retention; |
| import java.lang.annotation.RetentionPolicy; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.Set; |
| |
| /** |
| * Structured description of Intent values to be matched. An IntentFilter can |
| * match against actions, categories, and data (either via its type, scheme, |
| * and/or path) in an Intent. It also includes a "priority" value which is |
| * used to order multiple matching filters. |
| * |
| * <p>IntentFilter objects are often created in XML as part of a package's |
| * {@link android.R.styleable#AndroidManifest AndroidManifest.xml} file, |
| * using {@link android.R.styleable#AndroidManifestIntentFilter intent-filter} |
| * tags. |
| * |
| * <p>There are three Intent characteristics you can filter on: the |
| * <em>action</em>, <em>data</em>, and <em>categories</em>. For each of these |
| * characteristics you can provide |
| * multiple possible matching values (via {@link #addAction}, |
| * {@link #addDataType}, {@link #addDataScheme}, {@link #addDataSchemeSpecificPart}, |
| * {@link #addDataAuthority}, {@link #addDataPath}, and {@link #addCategory}, respectively). |
| * For actions, the field |
| * will not be tested if no values have been given (treating it as a wildcard); |
| * if no data characteristics are specified, however, then the filter will |
| * only match intents that contain no data. |
| * |
| * <p>The data characteristic is |
| * itself divided into three attributes: type, scheme, authority, and path. |
| * Any that are |
| * specified must match the contents of the Intent. If you specify a scheme |
| * but no type, only Intent that does not have a type (such as mailto:) will |
| * match; a content: URI will never match because they always have a MIME type |
| * that is supplied by their content provider. Specifying a type with no scheme |
| * has somewhat special meaning: it will match either an Intent with no URI |
| * field, or an Intent with a content: or file: URI. If you specify neither, |
| * then only an Intent with no data or type will match. To specify an authority, |
| * you must also specify one or more schemes that it is associated with. |
| * To specify a path, you also must specify both one or more authorities and |
| * one or more schemes it is associated with. |
| * |
| * <div class="special reference"> |
| * <h3>Developer Guides</h3> |
| * <p>For information about how to create and resolve intents, read the |
| * <a href="{@docRoot}guide/topics/intents/intents-filters.html">Intents and Intent Filters</a> |
| * developer guide.</p> |
| * </div> |
| * |
| * <h3>Filter Rules</h3> |
| * <p>A match is based on the following rules. Note that |
| * for an IntentFilter to match an Intent, three conditions must hold: |
| * the <strong>action</strong> and <strong>category</strong> must match, and |
| * the data (both the <strong>data type</strong> and |
| * <strong>data scheme+authority+path</strong> if specified) must match |
| * (see {@link #match(ContentResolver, Intent, boolean, String)} for more details |
| * on how the data fields match). |
| * |
| * <p><strong>Action</strong> matches if any of the given values match the |
| * Intent action; if the filter specifies no actions, then it will only match |
| * Intents that do not contain an action. |
| * |
| * <p><strong>Data Type</strong> matches if any of the given values match the |
| * Intent type. The Intent |
| * type is determined by calling {@link Intent#resolveType}. A wildcard can be |
| * used for the MIME sub-type, in both the Intent and IntentFilter, so that the |
| * type "audio/*" will match "audio/mpeg", "audio/aiff", "audio/*", etc. |
| * <em>Note that MIME type matching here is <b>case sensitive</b>, unlike |
| * formal RFC MIME types!</em> You should thus always use lower case letters |
| * for your MIME types. |
| * |
| * <p><strong>Data Scheme</strong> matches if any of the given values match the |
| * Intent data's scheme. |
| * The Intent scheme is determined by calling {@link Intent#getData} |
| * and {@link android.net.Uri#getScheme} on that URI. |
| * <em>Note that scheme matching here is <b>case sensitive</b>, unlike |
| * formal RFC schemes!</em> You should thus always use lower case letters |
| * for your schemes. |
| * |
| * <p><strong>Data Scheme Specific Part</strong> matches if any of the given values match |
| * the Intent's data scheme specific part <em>and</em> one of the data schemes in the filter |
| * has matched the Intent, <em>or</em> no scheme specific parts were supplied in the filter. |
| * The Intent scheme specific part is determined by calling |
| * {@link Intent#getData} and {@link android.net.Uri#getSchemeSpecificPart} on that URI. |
| * <em>Note that scheme specific part matching is <b>case sensitive</b>.</em> |
| * |
| * <p><strong>Data Authority</strong> matches if any of the given values match |
| * the Intent's data authority <em>and</em> one of the data schemes in the filter |
| * has matched the Intent, <em>or</em> no authorities were supplied in the filter. |
| * The Intent authority is determined by calling |
| * {@link Intent#getData} and {@link android.net.Uri#getAuthority} on that URI. |
| * <em>Note that authority matching here is <b>case sensitive</b>, unlike |
| * formal RFC host names!</em> You should thus always use lower case letters |
| * for your authority. |
| * |
| * <p><strong>Data Path</strong> matches if any of the given values match the |
| * Intent's data path <em>and</em> both a scheme and authority in the filter |
| * has matched against the Intent, <em>or</em> no paths were supplied in the |
| * filter. The Intent authority is determined by calling |
| * {@link Intent#getData} and {@link android.net.Uri#getPath} on that URI. |
| * |
| * <p><strong>Categories</strong> match if <em>all</em> of the categories in |
| * the Intent match categories given in the filter. Extra categories in the |
| * filter that are not in the Intent will not cause the match to fail. Note |
| * that unlike the action, an IntentFilter with no categories |
| * will only match an Intent that does not have any categories. |
| */ |
| public class IntentFilter implements Parcelable { |
| private static final String AGLOB_STR = "aglob"; |
| private static final String SGLOB_STR = "sglob"; |
| private static final String PREFIX_STR = "prefix"; |
| private static final String LITERAL_STR = "literal"; |
| private static final String PATH_STR = "path"; |
| private static final String PORT_STR = "port"; |
| private static final String HOST_STR = "host"; |
| private static final String AUTH_STR = "auth"; |
| private static final String SSP_STR = "ssp"; |
| private static final String SCHEME_STR = "scheme"; |
| private static final String TYPE_STR = "type"; |
| private static final String CAT_STR = "cat"; |
| private static final String NAME_STR = "name"; |
| private static final String ACTION_STR = "action"; |
| private static final String AUTO_VERIFY_STR = "autoVerify"; |
| |
| /** |
| * The filter {@link #setPriority} value at which system high-priority |
| * receivers are placed; that is, receivers that should execute before |
| * application code. Applications should never use filters with this or |
| * higher priorities. |
| * |
| * @see #setPriority |
| */ |
| public static final int SYSTEM_HIGH_PRIORITY = 1000; |
| |
| /** |
| * The filter {@link #setPriority} value at which system low-priority |
| * receivers are placed; that is, receivers that should execute after |
| * application code. Applications should never use filters with this or |
| * lower priorities. |
| * |
| * @see #setPriority |
| */ |
| public static final int SYSTEM_LOW_PRIORITY = -1000; |
| |
| /** |
| * The part of a match constant that describes the category of match |
| * that occurred. May be either {@link #MATCH_CATEGORY_EMPTY}, |
| * {@link #MATCH_CATEGORY_SCHEME}, {@link #MATCH_CATEGORY_SCHEME_SPECIFIC_PART}, |
| * {@link #MATCH_CATEGORY_HOST}, {@link #MATCH_CATEGORY_PORT}, |
| * {@link #MATCH_CATEGORY_PATH}, or {@link #MATCH_CATEGORY_TYPE}. Higher |
| * values indicate a better match. |
| */ |
| public static final int MATCH_CATEGORY_MASK = 0xfff0000; |
| |
| /** |
| * The part of a match constant that applies a quality adjustment to the |
| * basic category of match. The value {@link #MATCH_ADJUSTMENT_NORMAL} |
| * is no adjustment; higher numbers than that improve the quality, while |
| * lower numbers reduce it. |
| */ |
| public static final int MATCH_ADJUSTMENT_MASK = 0x000ffff; |
| |
| /** |
| * Quality adjustment applied to the category of match that signifies |
| * the default, base value; higher numbers improve the quality while |
| * lower numbers reduce it. |
| */ |
| public static final int MATCH_ADJUSTMENT_NORMAL = 0x8000; |
| |
| /** |
| * The filter matched an intent that had no data specified. |
| */ |
| public static final int MATCH_CATEGORY_EMPTY = 0x0100000; |
| /** |
| * The filter matched an intent with the same data URI scheme. |
| */ |
| public static final int MATCH_CATEGORY_SCHEME = 0x0200000; |
| /** |
| * The filter matched an intent with the same data URI scheme and |
| * authority host. |
| */ |
| public static final int MATCH_CATEGORY_HOST = 0x0300000; |
| /** |
| * The filter matched an intent with the same data URI scheme and |
| * authority host and port. |
| */ |
| public static final int MATCH_CATEGORY_PORT = 0x0400000; |
| /** |
| * The filter matched an intent with the same data URI scheme, |
| * authority, and path. |
| */ |
| public static final int MATCH_CATEGORY_PATH = 0x0500000; |
| /** |
| * The filter matched an intent with the same data URI scheme and |
| * scheme specific part. |
| */ |
| public static final int MATCH_CATEGORY_SCHEME_SPECIFIC_PART = 0x0580000; |
| /** |
| * The filter matched an intent with the same data MIME type. |
| */ |
| public static final int MATCH_CATEGORY_TYPE = 0x0600000; |
| |
| /** |
| * The filter didn't match due to different MIME types. |
| */ |
| public static final int NO_MATCH_TYPE = -1; |
| /** |
| * The filter didn't match due to different data URIs. |
| */ |
| public static final int NO_MATCH_DATA = -2; |
| /** |
| * The filter didn't match due to different actions. |
| */ |
| public static final int NO_MATCH_ACTION = -3; |
| /** |
| * The filter didn't match because it required one or more categories |
| * that were not in the Intent. |
| */ |
| public static final int NO_MATCH_CATEGORY = -4; |
| |
| /** |
| * HTTP scheme. |
| * |
| * @see #addDataScheme(String) |
| * @hide |
| */ |
| public static final String SCHEME_HTTP = "http"; |
| /** |
| * HTTPS scheme. |
| * |
| * @see #addDataScheme(String) |
| * @hide |
| */ |
| public static final String SCHEME_HTTPS = "https"; |
| |
| private int mPriority; |
| @UnsupportedAppUsage |
| private int mOrder; |
| @UnsupportedAppUsage |
| private final ArrayList<String> mActions; |
| private ArrayList<String> mCategories = null; |
| private ArrayList<String> mDataSchemes = null; |
| private ArrayList<PatternMatcher> mDataSchemeSpecificParts = null; |
| private ArrayList<AuthorityEntry> mDataAuthorities = null; |
| private ArrayList<PatternMatcher> mDataPaths = null; |
| private ArrayList<String> mDataTypes = null; |
| private boolean mHasPartialTypes = false; |
| |
| private static final int STATE_VERIFY_AUTO = 0x00000001; |
| private static final int STATE_NEED_VERIFY = 0x00000010; |
| private static final int STATE_NEED_VERIFY_CHECKED = 0x00000100; |
| private static final int STATE_VERIFIED = 0x00001000; |
| |
| private int mVerifyState; |
| /** @hide */ |
| public static final int VISIBILITY_NONE = 0; |
| /** @hide */ |
| public static final int VISIBILITY_EXPLICIT = 1; |
| /** @hide */ |
| public static final int VISIBILITY_IMPLICIT = 2; |
| /** @hide */ |
| @IntDef(prefix = { "VISIBILITY_" }, value = { |
| VISIBILITY_NONE, |
| VISIBILITY_EXPLICIT, |
| VISIBILITY_IMPLICIT, |
| }) |
| @Retention(RetentionPolicy.SOURCE) |
| public @interface InstantAppVisibility {} |
| /** Whether or not the intent filter is visible to instant apps. */ |
| private @InstantAppVisibility int mInstantAppVisibility; |
| // These functions are the start of more optimized code for managing |
| // the string sets... not yet implemented. |
| |
| private static int findStringInSet(String[] set, String string, |
| int[] lengths, int lenPos) { |
| if (set == null) return -1; |
| final int N = lengths[lenPos]; |
| for (int i=0; i<N; i++) { |
| if (set[i].equals(string)) return i; |
| } |
| return -1; |
| } |
| |
| private static String[] addStringToSet(String[] set, String string, |
| int[] lengths, int lenPos) { |
| if (findStringInSet(set, string, lengths, lenPos) >= 0) return set; |
| if (set == null) { |
| set = new String[2]; |
| set[0] = string; |
| lengths[lenPos] = 1; |
| return set; |
| } |
| final int N = lengths[lenPos]; |
| if (N < set.length) { |
| set[N] = string; |
| lengths[lenPos] = N+1; |
| return set; |
| } |
| |
| String[] newSet = new String[(N*3)/2 + 2]; |
| System.arraycopy(set, 0, newSet, 0, N); |
| set = newSet; |
| set[N] = string; |
| lengths[lenPos] = N+1; |
| return set; |
| } |
| |
| private static String[] removeStringFromSet(String[] set, String string, |
| int[] lengths, int lenPos) { |
| int pos = findStringInSet(set, string, lengths, lenPos); |
| if (pos < 0) return set; |
| final int N = lengths[lenPos]; |
| if (N > (set.length/4)) { |
| int copyLen = N-(pos+1); |
| if (copyLen > 0) { |
| System.arraycopy(set, pos+1, set, pos, copyLen); |
| } |
| set[N-1] = null; |
| lengths[lenPos] = N-1; |
| return set; |
| } |
| |
| String[] newSet = new String[set.length/3]; |
| if (pos > 0) System.arraycopy(set, 0, newSet, 0, pos); |
| if ((pos+1) < N) System.arraycopy(set, pos+1, newSet, pos, N-(pos+1)); |
| return newSet; |
| } |
| |
| /** |
| * This exception is thrown when a given MIME type does not have a valid |
| * syntax. |
| */ |
| public static class MalformedMimeTypeException extends AndroidException { |
| public MalformedMimeTypeException() { |
| } |
| |
| public MalformedMimeTypeException(String name) { |
| super(name); |
| } |
| } |
| |
| /** |
| * Create a new IntentFilter instance with a specified action and MIME |
| * type, where you know the MIME type is correctly formatted. This catches |
| * the {@link MalformedMimeTypeException} exception that the constructor |
| * can call and turns it into a runtime exception. |
| * |
| * @param action The action to match, such as Intent.ACTION_VIEW. |
| * @param dataType The type to match, such as "vnd.android.cursor.dir/person". |
| * |
| * @return A new IntentFilter for the given action and type. |
| * |
| * @see #IntentFilter(String, String) |
| */ |
| public static IntentFilter create(String action, String dataType) { |
| try { |
| return new IntentFilter(action, dataType); |
| } catch (MalformedMimeTypeException e) { |
| throw new RuntimeException("Bad MIME type", e); |
| } |
| } |
| |
| /** |
| * New empty IntentFilter. |
| */ |
| public IntentFilter() { |
| mPriority = 0; |
| mActions = new ArrayList<String>(); |
| } |
| |
| /** |
| * New IntentFilter that matches a single action with no data. If |
| * no data characteristics are subsequently specified, then the |
| * filter will only match intents that contain no data. |
| * |
| * @param action The action to match, such as Intent.ACTION_MAIN. |
| */ |
| public IntentFilter(String action) { |
| mPriority = 0; |
| mActions = new ArrayList<String>(); |
| addAction(action); |
| } |
| |
| /** |
| * New IntentFilter that matches a single action and data type. |
| * |
| * <p><em>Note: MIME type matching in the Android framework is |
| * case-sensitive, unlike formal RFC MIME types. As a result, |
| * you should always write your MIME types with lower case letters, |
| * and any MIME types you receive from outside of Android should be |
| * converted to lower case before supplying them here.</em></p> |
| * |
| * <p>Throws {@link MalformedMimeTypeException} if the given MIME type is |
| * not syntactically correct. |
| * |
| * @param action The action to match, such as Intent.ACTION_VIEW. |
| * @param dataType The type to match, such as "vnd.android.cursor.dir/person". |
| * |
| */ |
| public IntentFilter(String action, String dataType) |
| throws MalformedMimeTypeException { |
| mPriority = 0; |
| mActions = new ArrayList<String>(); |
| addAction(action); |
| addDataType(dataType); |
| } |
| |
| /** |
| * New IntentFilter containing a copy of an existing filter. |
| * |
| * @param o The original filter to copy. |
| */ |
| public IntentFilter(IntentFilter o) { |
| mPriority = o.mPriority; |
| mOrder = o.mOrder; |
| mActions = new ArrayList<String>(o.mActions); |
| if (o.mCategories != null) { |
| mCategories = new ArrayList<String>(o.mCategories); |
| } |
| if (o.mDataTypes != null) { |
| mDataTypes = new ArrayList<String>(o.mDataTypes); |
| } |
| if (o.mDataSchemes != null) { |
| mDataSchemes = new ArrayList<String>(o.mDataSchemes); |
| } |
| if (o.mDataSchemeSpecificParts != null) { |
| mDataSchemeSpecificParts = new ArrayList<PatternMatcher>(o.mDataSchemeSpecificParts); |
| } |
| if (o.mDataAuthorities != null) { |
| mDataAuthorities = new ArrayList<AuthorityEntry>(o.mDataAuthorities); |
| } |
| if (o.mDataPaths != null) { |
| mDataPaths = new ArrayList<PatternMatcher>(o.mDataPaths); |
| } |
| mHasPartialTypes = o.mHasPartialTypes; |
| mVerifyState = o.mVerifyState; |
| mInstantAppVisibility = o.mInstantAppVisibility; |
| } |
| |
| /** |
| * Modify priority of this filter. This only affects receiver filters. |
| * The priority of activity filters are set in XML and cannot be changed |
| * programatically. The default priority is 0. Positive values will be |
| * before the default, lower values will be after it. Applications should |
| * use a value that is larger than {@link #SYSTEM_LOW_PRIORITY} and |
| * smaller than {@link #SYSTEM_HIGH_PRIORITY} . |
| * |
| * @param priority The new priority value. |
| * |
| * @see #getPriority |
| * @see #SYSTEM_LOW_PRIORITY |
| * @see #SYSTEM_HIGH_PRIORITY |
| */ |
| public final void setPriority(int priority) { |
| mPriority = priority; |
| } |
| |
| /** |
| * Return the priority of this filter. |
| * |
| * @return The priority of the filter. |
| * |
| * @see #setPriority |
| */ |
| public final int getPriority() { |
| return mPriority; |
| } |
| |
| /** @hide */ |
| @SystemApi |
| public final void setOrder(int order) { |
| mOrder = order; |
| } |
| |
| /** @hide */ |
| @SystemApi |
| public final int getOrder() { |
| return mOrder; |
| } |
| |
| /** |
| * Set whether this filter will needs to be automatically verified against its data URIs or not. |
| * The default is false. |
| * |
| * The verification would need to happen only and only if the Intent action is |
| * {@link android.content.Intent#ACTION_VIEW} and the Intent category is |
| * {@link android.content.Intent#CATEGORY_BROWSABLE} and the Intent data scheme |
| * is "http" or "https". |
| * |
| * True means that the filter will need to use its data URIs to be verified. |
| * |
| * @param autoVerify The new autoVerify value. |
| * |
| * @see #getAutoVerify() |
| * @see #addAction(String) |
| * @see #getAction(int) |
| * @see #addCategory(String) |
| * @see #getCategory(int) |
| * @see #addDataScheme(String) |
| * @see #getDataScheme(int) |
| * |
| * @hide |
| */ |
| @UnsupportedAppUsage |
| public final void setAutoVerify(boolean autoVerify) { |
| mVerifyState &= ~STATE_VERIFY_AUTO; |
| if (autoVerify) mVerifyState |= STATE_VERIFY_AUTO; |
| } |
| |
| /** |
| * Return if this filter will needs to be automatically verified again its data URIs or not. |
| * |
| * @return True if the filter will needs to be automatically verified. False otherwise. |
| * |
| * @see #setAutoVerify(boolean) |
| * |
| * @hide |
| */ |
| public final boolean getAutoVerify() { |
| return ((mVerifyState & STATE_VERIFY_AUTO) == STATE_VERIFY_AUTO); |
| } |
| |
| /** |
| * Return if this filter handle all HTTP or HTTPS data URI or not. This is the |
| * core check for whether a given activity qualifies as a "browser". |
| * |
| * @return True if the filter handle all HTTP or HTTPS data URI. False otherwise. |
| * |
| * This will check if: |
| * |
| * - either the Intent category is {@link android.content.Intent#CATEGORY_APP_BROWSER} |
| * - either the Intent action is {@link android.content.Intent#ACTION_VIEW} and |
| * the Intent category is {@link android.content.Intent#CATEGORY_BROWSABLE} and the Intent |
| * data scheme is "http" or "https" and that there is no specific host defined. |
| * |
| * @hide |
| */ |
| public final boolean handleAllWebDataURI() { |
| return hasCategory(Intent.CATEGORY_APP_BROWSER) || |
| (handlesWebUris(false) && countDataAuthorities() == 0); |
| } |
| |
| /** |
| * Return if this filter handles HTTP or HTTPS data URIs. |
| * |
| * @return True if the filter handles ACTION_VIEW/CATEGORY_BROWSABLE, |
| * has at least one HTTP or HTTPS data URI pattern defined, and optionally |
| * does not define any non-http/https data URI patterns. |
| * |
| * This will check if if the Intent action is {@link android.content.Intent#ACTION_VIEW} and |
| * the Intent category is {@link android.content.Intent#CATEGORY_BROWSABLE} and the Intent |
| * data scheme is "http" or "https". |
| * |
| * @param onlyWebSchemes When true, requires that the intent filter declare |
| * that it handles *only* http: or https: schemes. This is a requirement for |
| * the intent filter's domain linkage being verifiable. |
| * @hide |
| */ |
| public final boolean handlesWebUris(boolean onlyWebSchemes) { |
| // Require ACTION_VIEW, CATEGORY_BROWSEABLE, and at least one scheme |
| if (!hasAction(Intent.ACTION_VIEW) |
| || !hasCategory(Intent.CATEGORY_BROWSABLE) |
| || mDataSchemes == null |
| || mDataSchemes.size() == 0) { |
| return false; |
| } |
| |
| // Now allow only the schemes "http" and "https" |
| final int N = mDataSchemes.size(); |
| for (int i = 0; i < N; i++) { |
| final String scheme = mDataSchemes.get(i); |
| final boolean isWebScheme = |
| SCHEME_HTTP.equals(scheme) || SCHEME_HTTPS.equals(scheme); |
| if (onlyWebSchemes) { |
| // If we're specifically trying to ensure that there are no non-web schemes |
| // declared in this filter, then if we ever see a non-http/https scheme then |
| // we know it's a failure. |
| if (!isWebScheme) { |
| return false; |
| } |
| } else { |
| // If we see any http/https scheme declaration in this case then the |
| // filter matches what we're looking for. |
| if (isWebScheme) { |
| return true; |
| } |
| } |
| } |
| |
| // We get here if: |
| // 1) onlyWebSchemes and no non-web schemes were found, i.e success; or |
| // 2) !onlyWebSchemes and no http/https schemes were found, i.e. failure. |
| return onlyWebSchemes; |
| } |
| |
| /** |
| * Return if this filter needs to be automatically verified again its data URIs or not. |
| * |
| * @return True if the filter needs to be automatically verified. False otherwise. |
| * |
| * This will check if if the Intent action is {@link android.content.Intent#ACTION_VIEW} and |
| * the Intent category is {@link android.content.Intent#CATEGORY_BROWSABLE} and the Intent |
| * data scheme is "http" or "https". |
| * |
| * @see #setAutoVerify(boolean) |
| * |
| * @hide |
| */ |
| public final boolean needsVerification() { |
| return getAutoVerify() && handlesWebUris(true); |
| } |
| |
| /** |
| * Return if this filter has been verified |
| * |
| * @return true if the filter has been verified or if autoVerify is false. |
| * |
| * @hide |
| */ |
| @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023) |
| public final boolean isVerified() { |
| if ((mVerifyState & STATE_NEED_VERIFY_CHECKED) == STATE_NEED_VERIFY_CHECKED) { |
| return ((mVerifyState & STATE_NEED_VERIFY) == STATE_NEED_VERIFY); |
| } |
| return false; |
| } |
| |
| /** |
| * Set if this filter has been verified |
| * |
| * @param verified true if this filter has been verified. False otherwise. |
| * |
| * @hide |
| */ |
| public void setVerified(boolean verified) { |
| mVerifyState |= STATE_NEED_VERIFY_CHECKED; |
| mVerifyState &= ~STATE_VERIFIED; |
| if (verified) mVerifyState |= STATE_VERIFIED; |
| } |
| |
| /** @hide */ |
| public void setVisibilityToInstantApp(@InstantAppVisibility int visibility) { |
| mInstantAppVisibility = visibility; |
| } |
| /** @hide */ |
| public @InstantAppVisibility int getVisibilityToInstantApp() { |
| return mInstantAppVisibility; |
| } |
| /** @hide */ |
| public boolean isVisibleToInstantApp() { |
| return mInstantAppVisibility != VISIBILITY_NONE; |
| } |
| /** @hide */ |
| public boolean isExplicitlyVisibleToInstantApp() { |
| return mInstantAppVisibility == VISIBILITY_EXPLICIT; |
| } |
| /** @hide */ |
| public boolean isImplicitlyVisibleToInstantApp() { |
| return mInstantAppVisibility == VISIBILITY_IMPLICIT; |
| } |
| |
| /** |
| * Add a new Intent action to match against. If any actions are included |
| * in the filter, then an Intent's action must be one of those values for |
| * it to match. If no actions are included, the Intent action is ignored. |
| * |
| * @param action Name of the action to match, such as Intent.ACTION_VIEW. |
| */ |
| public final void addAction(String action) { |
| if (!mActions.contains(action)) { |
| mActions.add(action.intern()); |
| } |
| } |
| |
| /** |
| * Return the number of actions in the filter. |
| */ |
| public final int countActions() { |
| return mActions.size(); |
| } |
| |
| /** |
| * Return an action in the filter. |
| */ |
| public final String getAction(int index) { |
| return mActions.get(index); |
| } |
| |
| /** |
| * Is the given action included in the filter? Note that if the filter |
| * does not include any actions, false will <em>always</em> be returned. |
| * |
| * @param action The action to look for. |
| * |
| * @return True if the action is explicitly mentioned in the filter. |
| */ |
| public final boolean hasAction(String action) { |
| return action != null && mActions.contains(action); |
| } |
| |
| /** |
| * Match this filter against an Intent's action. If the filter does not |
| * specify any actions, the match will always fail. |
| * |
| * @param action The desired action to look for. |
| * |
| * @return True if the action is listed in the filter. |
| */ |
| public final boolean matchAction(String action) { |
| return hasAction(action); |
| } |
| |
| /** |
| * Return an iterator over the filter's actions. If there are no actions, |
| * returns null. |
| */ |
| public final Iterator<String> actionsIterator() { |
| return mActions != null ? mActions.iterator() : null; |
| } |
| |
| /** |
| * Add a new Intent data type to match against. If any types are |
| * included in the filter, then an Intent's data must be <em>either</em> |
| * one of these types <em>or</em> a matching scheme. If no data types |
| * are included, then an Intent will only match if it specifies no data. |
| * |
| * <p><em>Note: MIME type matching in the Android framework is |
| * case-sensitive, unlike formal RFC MIME types. As a result, |
| * you should always write your MIME types with lower case letters, |
| * and any MIME types you receive from outside of Android should be |
| * converted to lower case before supplying them here.</em></p> |
| * |
| * <p>Throws {@link MalformedMimeTypeException} if the given MIME type is |
| * not syntactically correct. |
| * |
| * @param type Name of the data type to match, such as "vnd.android.cursor.dir/person". |
| * |
| * @see #matchData |
| */ |
| public final void addDataType(String type) |
| throws MalformedMimeTypeException { |
| final int slashpos = type.indexOf('/'); |
| final int typelen = type.length(); |
| if (slashpos > 0 && typelen >= slashpos+2) { |
| if (mDataTypes == null) mDataTypes = new ArrayList<String>(); |
| if (typelen == slashpos+2 && type.charAt(slashpos+1) == '*') { |
| String str = type.substring(0, slashpos); |
| if (!mDataTypes.contains(str)) { |
| mDataTypes.add(str.intern()); |
| } |
| mHasPartialTypes = true; |
| } else { |
| if (!mDataTypes.contains(type)) { |
| mDataTypes.add(type.intern()); |
| } |
| } |
| return; |
| } |
| |
| throw new MalformedMimeTypeException(type); |
| } |
| |
| /** |
| * Is the given data type included in the filter? Note that if the filter |
| * does not include any type, false will <em>always</em> be returned. |
| * |
| * @param type The data type to look for. |
| * |
| * @return True if the type is explicitly mentioned in the filter. |
| */ |
| public final boolean hasDataType(String type) { |
| return mDataTypes != null && findMimeType(type); |
| } |
| |
| /** @hide */ |
| @UnsupportedAppUsage |
| public final boolean hasExactDataType(String type) { |
| return mDataTypes != null && mDataTypes.contains(type); |
| } |
| |
| /** |
| * Return the number of data types in the filter. |
| */ |
| public final int countDataTypes() { |
| return mDataTypes != null ? mDataTypes.size() : 0; |
| } |
| |
| /** |
| * Return a data type in the filter. |
| */ |
| public final String getDataType(int index) { |
| return mDataTypes.get(index); |
| } |
| |
| /** |
| * Return an iterator over the filter's data types. |
| */ |
| public final Iterator<String> typesIterator() { |
| return mDataTypes != null ? mDataTypes.iterator() : null; |
| } |
| |
| /** |
| * Add a new Intent data scheme to match against. If any schemes are |
| * included in the filter, then an Intent's data must be <em>either</em> |
| * one of these schemes <em>or</em> a matching data type. If no schemes |
| * are included, then an Intent will match only if it includes no data. |
| * |
| * <p><em>Note: scheme matching in the Android framework is |
| * case-sensitive, unlike formal RFC schemes. As a result, |
| * you should always write your schemes with lower case letters, |
| * and any schemes you receive from outside of Android should be |
| * converted to lower case before supplying them here.</em></p> |
| * |
| * @param scheme Name of the scheme to match, such as "http". |
| * |
| * @see #matchData |
| */ |
| public final void addDataScheme(String scheme) { |
| if (mDataSchemes == null) mDataSchemes = new ArrayList<String>(); |
| if (!mDataSchemes.contains(scheme)) { |
| mDataSchemes.add(scheme.intern()); |
| } |
| } |
| |
| /** |
| * Return the number of data schemes in the filter. |
| */ |
| public final int countDataSchemes() { |
| return mDataSchemes != null ? mDataSchemes.size() : 0; |
| } |
| |
| /** |
| * Return a data scheme in the filter. |
| */ |
| public final String getDataScheme(int index) { |
| return mDataSchemes.get(index); |
| } |
| |
| /** |
| * Is the given data scheme included in the filter? Note that if the |
| * filter does not include any scheme, false will <em>always</em> be |
| * returned. |
| * |
| * @param scheme The data scheme to look for. |
| * |
| * @return True if the scheme is explicitly mentioned in the filter. |
| */ |
| public final boolean hasDataScheme(String scheme) { |
| return mDataSchemes != null && mDataSchemes.contains(scheme); |
| } |
| |
| /** |
| * Return an iterator over the filter's data schemes. |
| */ |
| public final Iterator<String> schemesIterator() { |
| return mDataSchemes != null ? mDataSchemes.iterator() : null; |
| } |
| |
| /** |
| * This is an entry for a single authority in the Iterator returned by |
| * {@link #authoritiesIterator()}. |
| */ |
| public final static class AuthorityEntry { |
| private final String mOrigHost; |
| private final String mHost; |
| private final boolean mWild; |
| private final int mPort; |
| |
| public AuthorityEntry(String host, String port) { |
| mOrigHost = host; |
| mWild = host.length() > 0 && host.charAt(0) == '*'; |
| mHost = mWild ? host.substring(1).intern() : host; |
| mPort = port != null ? Integer.parseInt(port) : -1; |
| } |
| |
| AuthorityEntry(Parcel src) { |
| mOrigHost = src.readString(); |
| mHost = src.readString(); |
| mWild = src.readInt() != 0; |
| mPort = src.readInt(); |
| } |
| |
| void writeToParcel(Parcel dest) { |
| dest.writeString(mOrigHost); |
| dest.writeString(mHost); |
| dest.writeInt(mWild ? 1 : 0); |
| dest.writeInt(mPort); |
| } |
| |
| void writeToProto(ProtoOutputStream proto, long fieldId) { |
| long token = proto.start(fieldId); |
| // The original host information is already contained in host and wild, no output now. |
| proto.write(AuthorityEntryProto.HOST, mHost); |
| proto.write(AuthorityEntryProto.WILD, mWild); |
| proto.write(AuthorityEntryProto.PORT, mPort); |
| proto.end(token); |
| } |
| |
| public String getHost() { |
| return mOrigHost; |
| } |
| |
| public int getPort() { |
| return mPort; |
| } |
| |
| /** @hide */ |
| public boolean match(AuthorityEntry other) { |
| if (mWild != other.mWild) { |
| return false; |
| } |
| if (!mHost.equals(other.mHost)) { |
| return false; |
| } |
| if (mPort != other.mPort) { |
| return false; |
| } |
| return true; |
| } |
| |
| @Override |
| public boolean equals(Object obj) { |
| if (obj instanceof AuthorityEntry) { |
| final AuthorityEntry other = (AuthorityEntry)obj; |
| return match(other); |
| } |
| return false; |
| } |
| |
| /** |
| * Determine whether this AuthorityEntry matches the given data Uri. |
| * <em>Note that this comparison is case-sensitive, unlike formal |
| * RFC host names. You thus should always normalize to lower-case.</em> |
| * |
| * @param data The Uri to match. |
| * @return Returns either {@link IntentFilter#NO_MATCH_DATA}, |
| * {@link IntentFilter#MATCH_CATEGORY_PORT}, or |
| * {@link IntentFilter#MATCH_CATEGORY_HOST}. |
| */ |
| public int match(Uri data) { |
| String host = data.getHost(); |
| if (host == null) { |
| return NO_MATCH_DATA; |
| } |
| if (false) Log.v("IntentFilter", |
| "Match host " + host + ": " + mHost); |
| if (mWild) { |
| if (host.length() < mHost.length()) { |
| return NO_MATCH_DATA; |
| } |
| host = host.substring(host.length()-mHost.length()); |
| } |
| if (host.compareToIgnoreCase(mHost) != 0) { |
| return NO_MATCH_DATA; |
| } |
| if (mPort >= 0) { |
| if (mPort != data.getPort()) { |
| return NO_MATCH_DATA; |
| } |
| return MATCH_CATEGORY_PORT; |
| } |
| return MATCH_CATEGORY_HOST; |
| } |
| } |
| |
| /** |
| * Add a new Intent data "scheme specific part" to match against. The filter must |
| * include one or more schemes (via {@link #addDataScheme}) for the |
| * scheme specific part to be considered. If any scheme specific parts are |
| * included in the filter, then an Intent's data must match one of |
| * them. If no scheme specific parts are included, then only the scheme must match. |
| * |
| * <p>The "scheme specific part" that this matches against is the string returned |
| * by {@link android.net.Uri#getSchemeSpecificPart() Uri.getSchemeSpecificPart}. |
| * For Uris that contain a path, this kind of matching is not generally of interest, |
| * since {@link #addDataAuthority(String, String)} and |
| * {@link #addDataPath(String, int)} can provide a better mechanism for matching |
| * them. However, for Uris that do not contain a path, the authority and path |
| * are empty, so this is the only way to match against the non-scheme part.</p> |
| * |
| * @param ssp Either a raw string that must exactly match the scheme specific part |
| * path, or a simple pattern, depending on <var>type</var>. |
| * @param type Determines how <var>ssp</var> will be compared to |
| * determine a match: either {@link PatternMatcher#PATTERN_LITERAL}, |
| * {@link PatternMatcher#PATTERN_PREFIX}, or |
| * {@link PatternMatcher#PATTERN_SIMPLE_GLOB}. |
| * |
| * @see #matchData |
| * @see #addDataScheme |
| */ |
| public final void addDataSchemeSpecificPart(String ssp, int type) { |
| addDataSchemeSpecificPart(new PatternMatcher(ssp, type)); |
| } |
| |
| /** @hide */ |
| public final void addDataSchemeSpecificPart(PatternMatcher ssp) { |
| if (mDataSchemeSpecificParts == null) { |
| mDataSchemeSpecificParts = new ArrayList<PatternMatcher>(); |
| } |
| mDataSchemeSpecificParts.add(ssp); |
| } |
| |
| /** |
| * Return the number of data scheme specific parts in the filter. |
| */ |
| public final int countDataSchemeSpecificParts() { |
| return mDataSchemeSpecificParts != null ? mDataSchemeSpecificParts.size() : 0; |
| } |
| |
| /** |
| * Return a data scheme specific part in the filter. |
| */ |
| public final PatternMatcher getDataSchemeSpecificPart(int index) { |
| return mDataSchemeSpecificParts.get(index); |
| } |
| |
| /** |
| * Is the given data scheme specific part included in the filter? Note that if the |
| * filter does not include any scheme specific parts, false will <em>always</em> be |
| * returned. |
| * |
| * @param data The scheme specific part that is being looked for. |
| * |
| * @return Returns true if the data string matches a scheme specific part listed in the |
| * filter. |
| */ |
| public final boolean hasDataSchemeSpecificPart(String data) { |
| if (mDataSchemeSpecificParts == null) { |
| return false; |
| } |
| final int numDataSchemeSpecificParts = mDataSchemeSpecificParts.size(); |
| for (int i = 0; i < numDataSchemeSpecificParts; i++) { |
| final PatternMatcher pe = mDataSchemeSpecificParts.get(i); |
| if (pe.match(data)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** @hide */ |
| @UnsupportedAppUsage |
| public final boolean hasDataSchemeSpecificPart(PatternMatcher ssp) { |
| if (mDataSchemeSpecificParts == null) { |
| return false; |
| } |
| final int numDataSchemeSpecificParts = mDataSchemeSpecificParts.size(); |
| for (int i = 0; i < numDataSchemeSpecificParts; i++) { |
| final PatternMatcher pe = mDataSchemeSpecificParts.get(i); |
| if (pe.getType() == ssp.getType() && pe.getPath().equals(ssp.getPath())) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Return an iterator over the filter's data scheme specific parts. |
| */ |
| public final Iterator<PatternMatcher> schemeSpecificPartsIterator() { |
| return mDataSchemeSpecificParts != null ? mDataSchemeSpecificParts.iterator() : null; |
| } |
| |
| /** |
| * Add a new Intent data authority to match against. The filter must |
| * include one or more schemes (via {@link #addDataScheme}) for the |
| * authority to be considered. If any authorities are |
| * included in the filter, then an Intent's data must match one of |
| * them. If no authorities are included, then only the scheme must match. |
| * |
| * <p><em>Note: host name in the Android framework is |
| * case-sensitive, unlike formal RFC host names. As a result, |
| * you should always write your host names with lower case letters, |
| * and any host names you receive from outside of Android should be |
| * converted to lower case before supplying them here.</em></p> |
| * |
| * @param host The host part of the authority to match. May start with a |
| * single '*' to wildcard the front of the host name. |
| * @param port Optional port part of the authority to match. If null, any |
| * port is allowed. |
| * |
| * @see #matchData |
| * @see #addDataScheme |
| */ |
| public final void addDataAuthority(String host, String port) { |
| if (port != null) port = port.intern(); |
| addDataAuthority(new AuthorityEntry(host.intern(), port)); |
| } |
| |
| /** @hide */ |
| public final void addDataAuthority(AuthorityEntry ent) { |
| if (mDataAuthorities == null) mDataAuthorities = |
| new ArrayList<AuthorityEntry>(); |
| mDataAuthorities.add(ent); |
| } |
| |
| /** |
| * Return the number of data authorities in the filter. |
| */ |
| public final int countDataAuthorities() { |
| return mDataAuthorities != null ? mDataAuthorities.size() : 0; |
| } |
| |
| /** |
| * Return a data authority in the filter. |
| */ |
| public final AuthorityEntry getDataAuthority(int index) { |
| return mDataAuthorities.get(index); |
| } |
| |
| /** |
| * Is the given data authority included in the filter? Note that if the |
| * filter does not include any authorities, false will <em>always</em> be |
| * returned. |
| * |
| * @param data The data whose authority is being looked for. |
| * |
| * @return Returns true if the data string matches an authority listed in the |
| * filter. |
| */ |
| public final boolean hasDataAuthority(Uri data) { |
| return matchDataAuthority(data) >= 0; |
| } |
| |
| /** @hide */ |
| @UnsupportedAppUsage |
| public final boolean hasDataAuthority(AuthorityEntry auth) { |
| if (mDataAuthorities == null) { |
| return false; |
| } |
| final int numDataAuthorities = mDataAuthorities.size(); |
| for (int i = 0; i < numDataAuthorities; i++) { |
| if (mDataAuthorities.get(i).match(auth)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Return an iterator over the filter's data authorities. |
| */ |
| public final Iterator<AuthorityEntry> authoritiesIterator() { |
| return mDataAuthorities != null ? mDataAuthorities.iterator() : null; |
| } |
| |
| /** |
| * Add a new Intent data path to match against. The filter must |
| * include one or more schemes (via {@link #addDataScheme}) <em>and</em> |
| * one or more authorities (via {@link #addDataAuthority}) for the |
| * path to be considered. If any paths are |
| * included in the filter, then an Intent's data must match one of |
| * them. If no paths are included, then only the scheme/authority must |
| * match. |
| * |
| * <p>The path given here can either be a literal that must directly |
| * match or match against a prefix, or it can be a simple globbing pattern. |
| * If the latter, you can use '*' anywhere in the pattern to match zero |
| * or more instances of the previous character, '.' as a wildcard to match |
| * any character, and '\' to escape the next character. |
| * |
| * @param path Either a raw string that must exactly match the file |
| * path, or a simple pattern, depending on <var>type</var>. |
| * @param type Determines how <var>path</var> will be compared to |
| * determine a match: either {@link PatternMatcher#PATTERN_LITERAL}, |
| * {@link PatternMatcher#PATTERN_PREFIX}, or |
| * {@link PatternMatcher#PATTERN_SIMPLE_GLOB}. |
| * |
| * @see #matchData |
| * @see #addDataScheme |
| * @see #addDataAuthority |
| */ |
| public final void addDataPath(String path, int type) { |
| addDataPath(new PatternMatcher(path.intern(), type)); |
| } |
| |
| /** @hide */ |
| public final void addDataPath(PatternMatcher path) { |
| if (mDataPaths == null) mDataPaths = new ArrayList<PatternMatcher>(); |
| mDataPaths.add(path); |
| } |
| |
| /** |
| * Return the number of data paths in the filter. |
| */ |
| public final int countDataPaths() { |
| return mDataPaths != null ? mDataPaths.size() : 0; |
| } |
| |
| /** |
| * Return a data path in the filter. |
| */ |
| public final PatternMatcher getDataPath(int index) { |
| return mDataPaths.get(index); |
| } |
| |
| /** |
| * Is the given data path included in the filter? Note that if the |
| * filter does not include any paths, false will <em>always</em> be |
| * returned. |
| * |
| * @param data The data path to look for. This is without the scheme |
| * prefix. |
| * |
| * @return True if the data string matches a path listed in the |
| * filter. |
| */ |
| public final boolean hasDataPath(String data) { |
| if (mDataPaths == null) { |
| return false; |
| } |
| final int numDataPaths = mDataPaths.size(); |
| for (int i = 0; i < numDataPaths; i++) { |
| final PatternMatcher pe = mDataPaths.get(i); |
| if (pe.match(data)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** @hide */ |
| @UnsupportedAppUsage |
| public final boolean hasDataPath(PatternMatcher path) { |
| if (mDataPaths == null) { |
| return false; |
| } |
| final int numDataPaths = mDataPaths.size(); |
| for (int i = 0; i < numDataPaths; i++) { |
| final PatternMatcher pe = mDataPaths.get(i); |
| if (pe.getType() == path.getType() && pe.getPath().equals(path.getPath())) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Return an iterator over the filter's data paths. |
| */ |
| public final Iterator<PatternMatcher> pathsIterator() { |
| return mDataPaths != null ? mDataPaths.iterator() : null; |
| } |
| |
| /** |
| * Match this intent filter against the given Intent data. This ignores |
| * the data scheme -- unlike {@link #matchData}, the authority will match |
| * regardless of whether there is a matching scheme. |
| * |
| * @param data The data whose authority is being looked for. |
| * |
| * @return Returns either {@link #MATCH_CATEGORY_HOST}, |
| * {@link #MATCH_CATEGORY_PORT}, {@link #NO_MATCH_DATA}. |
| */ |
| public final int matchDataAuthority(Uri data) { |
| if (mDataAuthorities == null || data == null) { |
| return NO_MATCH_DATA; |
| } |
| final int numDataAuthorities = mDataAuthorities.size(); |
| for (int i = 0; i < numDataAuthorities; i++) { |
| final AuthorityEntry ae = mDataAuthorities.get(i); |
| int match = ae.match(data); |
| if (match >= 0) { |
| return match; |
| } |
| } |
| return NO_MATCH_DATA; |
| } |
| |
| /** |
| * Match this filter against an Intent's data (type, scheme and path). If |
| * the filter does not specify any types and does not specify any |
| * schemes/paths, the match will only succeed if the intent does not |
| * also specify a type or data. If the filter does not specify any schemes, |
| * it will implicitly match intents with no scheme, or the schemes "content:" |
| * or "file:" (basically performing a MIME-type only match). If the filter |
| * does not specify any MIME types, the Intent also must not specify a MIME |
| * type. |
| * |
| * <p>Be aware that to match against an authority, you must also specify a base |
| * scheme the authority is in. To match against a data path, both a scheme |
| * and authority must be specified. If the filter does not specify any |
| * types or schemes that it matches against, it is considered to be empty |
| * (any authority or data path given is ignored, as if it were empty as |
| * well). |
| * |
| * <p><em>Note: MIME type, Uri scheme, and host name matching in the |
| * Android framework is case-sensitive, unlike the formal RFC definitions. |
| * As a result, you should always write these elements with lower case letters, |
| * and normalize any MIME types or Uris you receive from |
| * outside of Android to ensure these elements are lower case before |
| * supplying them here.</em></p> |
| * |
| * @param type The desired data type to look for, as returned by |
| * Intent.resolveType(). |
| * @param scheme The desired data scheme to look for, as returned by |
| * Intent.getScheme(). |
| * @param data The full data string to match against, as supplied in |
| * Intent.data. |
| * |
| * @return Returns either a valid match constant (a combination of |
| * {@link #MATCH_CATEGORY_MASK} and {@link #MATCH_ADJUSTMENT_MASK}), |
| * or one of the error codes {@link #NO_MATCH_TYPE} if the type didn't match |
| * or {@link #NO_MATCH_DATA} if the scheme/path didn't match. |
| * |
| * @see #match |
| */ |
| public final int matchData(String type, String scheme, Uri data) { |
| final ArrayList<String> types = mDataTypes; |
| final ArrayList<String> schemes = mDataSchemes; |
| |
| int match = MATCH_CATEGORY_EMPTY; |
| |
| if (types == null && schemes == null) { |
| return ((type == null && data == null) |
| ? (MATCH_CATEGORY_EMPTY+MATCH_ADJUSTMENT_NORMAL) : NO_MATCH_DATA); |
| } |
| |
| if (schemes != null) { |
| if (schemes.contains(scheme != null ? scheme : "")) { |
| match = MATCH_CATEGORY_SCHEME; |
| } else { |
| return NO_MATCH_DATA; |
| } |
| |
| final ArrayList<PatternMatcher> schemeSpecificParts = mDataSchemeSpecificParts; |
| if (schemeSpecificParts != null && data != null) { |
| match = hasDataSchemeSpecificPart(data.getSchemeSpecificPart()) |
| ? MATCH_CATEGORY_SCHEME_SPECIFIC_PART : NO_MATCH_DATA; |
| } |
| if (match != MATCH_CATEGORY_SCHEME_SPECIFIC_PART) { |
| // If there isn't any matching ssp, we need to match an authority. |
| final ArrayList<AuthorityEntry> authorities = mDataAuthorities; |
| if (authorities != null) { |
| int authMatch = matchDataAuthority(data); |
| if (authMatch >= 0) { |
| final ArrayList<PatternMatcher> paths = mDataPaths; |
| if (paths == null) { |
| match = authMatch; |
| } else if (hasDataPath(data.getPath())) { |
| match = MATCH_CATEGORY_PATH; |
| } else { |
| return NO_MATCH_DATA; |
| } |
| } else { |
| return NO_MATCH_DATA; |
| } |
| } |
| } |
| // If neither an ssp nor an authority matched, we're done. |
| if (match == NO_MATCH_DATA) { |
| return NO_MATCH_DATA; |
| } |
| } else { |
| // Special case: match either an Intent with no data URI, |
| // or with a scheme: URI. This is to give a convenience for |
| // the common case where you want to deal with data in a |
| // content provider, which is done by type, and we don't want |
| // to force everyone to say they handle content: or file: URIs. |
| if (scheme != null && !"".equals(scheme) |
| && !"content".equals(scheme) |
| && !"file".equals(scheme)) { |
| return NO_MATCH_DATA; |
| } |
| } |
| |
| if (types != null) { |
| if (findMimeType(type)) { |
| match = MATCH_CATEGORY_TYPE; |
| } else { |
| return NO_MATCH_TYPE; |
| } |
| } else { |
| // If no MIME types are specified, then we will only match against |
| // an Intent that does not have a MIME type. |
| if (type != null) { |
| return NO_MATCH_TYPE; |
| } |
| } |
| |
| return match + MATCH_ADJUSTMENT_NORMAL; |
| } |
| |
| /** |
| * Add a new Intent category to match against. The semantics of |
| * categories is the opposite of actions -- an Intent includes the |
| * categories that it requires, all of which must be included in the |
| * filter in order to match. In other words, adding a category to the |
| * filter has no impact on matching unless that category is specified in |
| * the intent. |
| * |
| * @param category Name of category to match, such as Intent.CATEGORY_EMBED. |
| */ |
| public final void addCategory(String category) { |
| if (mCategories == null) mCategories = new ArrayList<String>(); |
| if (!mCategories.contains(category)) { |
| mCategories.add(category.intern()); |
| } |
| } |
| |
| /** |
| * Return the number of categories in the filter. |
| */ |
| public final int countCategories() { |
| return mCategories != null ? mCategories.size() : 0; |
| } |
| |
| /** |
| * Return a category in the filter. |
| */ |
| public final String getCategory(int index) { |
| return mCategories.get(index); |
| } |
| |
| /** |
| * Is the given category included in the filter? |
| * |
| * @param category The category that the filter supports. |
| * |
| * @return True if the category is explicitly mentioned in the filter. |
| */ |
| public final boolean hasCategory(String category) { |
| return mCategories != null && mCategories.contains(category); |
| } |
| |
| /** |
| * Return an iterator over the filter's categories. |
| * |
| * @return Iterator if this filter has categories or {@code null} if none. |
| */ |
| public final Iterator<String> categoriesIterator() { |
| return mCategories != null ? mCategories.iterator() : null; |
| } |
| |
| /** |
| * Match this filter against an Intent's categories. Each category in |
| * the Intent must be specified by the filter; if any are not in the |
| * filter, the match fails. |
| * |
| * @param categories The categories included in the intent, as returned by |
| * Intent.getCategories(). |
| * |
| * @return If all categories match (success), null; else the name of the |
| * first category that didn't match. |
| */ |
| public final String matchCategories(Set<String> categories) { |
| if (categories == null) { |
| return null; |
| } |
| |
| Iterator<String> it = categories.iterator(); |
| |
| if (mCategories == null) { |
| return it.hasNext() ? it.next() : null; |
| } |
| |
| while (it.hasNext()) { |
| final String category = it.next(); |
| if (!mCategories.contains(category)) { |
| return category; |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Test whether this filter matches the given <var>intent</var>. |
| * |
| * @param intent The Intent to compare against. |
| * @param resolve If true, the intent's type will be resolved by calling |
| * Intent.resolveType(); otherwise a simple match against |
| * Intent.type will be performed. |
| * @param logTag Tag to use in debugging messages. |
| * |
| * @return Returns either a valid match constant (a combination of |
| * {@link #MATCH_CATEGORY_MASK} and {@link #MATCH_ADJUSTMENT_MASK}), |
| * or one of the error codes {@link #NO_MATCH_TYPE} if the type didn't match, |
| * {@link #NO_MATCH_DATA} if the scheme/path didn't match, |
| * {@link #NO_MATCH_ACTION} if the action didn't match, or |
| * {@link #NO_MATCH_CATEGORY} if one or more categories didn't match. |
| * |
| * @see #match(String, String, String, android.net.Uri , Set, String) |
| */ |
| public final int match(ContentResolver resolver, Intent intent, |
| boolean resolve, String logTag) { |
| String type = resolve ? intent.resolveType(resolver) : intent.getType(); |
| return match(intent.getAction(), type, intent.getScheme(), |
| intent.getData(), intent.getCategories(), logTag); |
| } |
| |
| /** |
| * Test whether this filter matches the given intent data. A match is |
| * only successful if the actions and categories in the Intent match |
| * against the filter, as described in {@link IntentFilter}; in that case, |
| * the match result returned will be as per {@link #matchData}. |
| * |
| * @param action The intent action to match against (Intent.getAction). |
| * @param type The intent type to match against (Intent.resolveType()). |
| * @param scheme The data scheme to match against (Intent.getScheme()). |
| * @param data The data URI to match against (Intent.getData()). |
| * @param categories The categories to match against |
| * (Intent.getCategories()). |
| * @param logTag Tag to use in debugging messages. |
| * |
| * @return Returns either a valid match constant (a combination of |
| * {@link #MATCH_CATEGORY_MASK} and {@link #MATCH_ADJUSTMENT_MASK}), |
| * or one of the error codes {@link #NO_MATCH_TYPE} if the type didn't match, |
| * {@link #NO_MATCH_DATA} if the scheme/path didn't match, |
| * {@link #NO_MATCH_ACTION} if the action didn't match, or |
| * {@link #NO_MATCH_CATEGORY} if one or more categories didn't match. |
| * |
| * @see #matchData |
| * @see Intent#getAction |
| * @see Intent#resolveType |
| * @see Intent#getScheme |
| * @see Intent#getData |
| * @see Intent#getCategories |
| */ |
| public final int match(String action, String type, String scheme, |
| Uri data, Set<String> categories, String logTag) { |
| if (action != null && !matchAction(action)) { |
| if (false) Log.v( |
| logTag, "No matching action " + action + " for " + this); |
| return NO_MATCH_ACTION; |
| } |
| |
| int dataMatch = matchData(type, scheme, data); |
| if (dataMatch < 0) { |
| if (false) { |
| if (dataMatch == NO_MATCH_TYPE) { |
| Log.v(logTag, "No matching type " + type |
| + " for " + this); |
| } |
| if (dataMatch == NO_MATCH_DATA) { |
| Log.v(logTag, "No matching scheme/path " + data |
| + " for " + this); |
| } |
| } |
| return dataMatch; |
| } |
| |
| String categoryMismatch = matchCategories(categories); |
| if (categoryMismatch != null) { |
| if (false) { |
| Log.v(logTag, "No matching category " + categoryMismatch + " for " + this); |
| } |
| return NO_MATCH_CATEGORY; |
| } |
| |
| // It would be nice to treat container activities as more |
| // important than ones that can be embedded, but this is not the way... |
| if (false) { |
| if (categories != null) { |
| dataMatch -= mCategories.size() - categories.size(); |
| } |
| } |
| |
| return dataMatch; |
| } |
| |
| /** |
| * Write the contents of the IntentFilter as an XML stream. |
| */ |
| public void writeToXml(XmlSerializer serializer) throws IOException { |
| |
| if (getAutoVerify()) { |
| serializer.attribute(null, AUTO_VERIFY_STR, Boolean.toString(true)); |
| } |
| |
| int N = countActions(); |
| for (int i=0; i<N; i++) { |
| serializer.startTag(null, ACTION_STR); |
| serializer.attribute(null, NAME_STR, mActions.get(i)); |
| serializer.endTag(null, ACTION_STR); |
| } |
| N = countCategories(); |
| for (int i=0; i<N; i++) { |
| serializer.startTag(null, CAT_STR); |
| serializer.attribute(null, NAME_STR, mCategories.get(i)); |
| serializer.endTag(null, CAT_STR); |
| } |
| N = countDataTypes(); |
| for (int i=0; i<N; i++) { |
| serializer.startTag(null, TYPE_STR); |
| String type = mDataTypes.get(i); |
| if (type.indexOf('/') < 0) type = type + "/*"; |
| serializer.attribute(null, NAME_STR, type); |
| serializer.endTag(null, TYPE_STR); |
| } |
| N = countDataSchemes(); |
| for (int i=0; i<N; i++) { |
| serializer.startTag(null, SCHEME_STR); |
| serializer.attribute(null, NAME_STR, mDataSchemes.get(i)); |
| serializer.endTag(null, SCHEME_STR); |
| } |
| N = countDataSchemeSpecificParts(); |
| for (int i=0; i<N; i++) { |
| serializer.startTag(null, SSP_STR); |
| PatternMatcher pe = mDataSchemeSpecificParts.get(i); |
| switch (pe.getType()) { |
| case PatternMatcher.PATTERN_LITERAL: |
| serializer.attribute(null, LITERAL_STR, pe.getPath()); |
| break; |
| case PatternMatcher.PATTERN_PREFIX: |
| serializer.attribute(null, PREFIX_STR, pe.getPath()); |
| break; |
| case PatternMatcher.PATTERN_SIMPLE_GLOB: |
| serializer.attribute(null, SGLOB_STR, pe.getPath()); |
| break; |
| case PatternMatcher.PATTERN_ADVANCED_GLOB: |
| serializer.attribute(null, AGLOB_STR, pe.getPath()); |
| break; |
| } |
| serializer.endTag(null, SSP_STR); |
| } |
| N = countDataAuthorities(); |
| for (int i=0; i<N; i++) { |
| serializer.startTag(null, AUTH_STR); |
| AuthorityEntry ae = mDataAuthorities.get(i); |
| serializer.attribute(null, HOST_STR, ae.getHost()); |
| if (ae.getPort() >= 0) { |
| serializer.attribute(null, PORT_STR, Integer.toString(ae.getPort())); |
| } |
| serializer.endTag(null, AUTH_STR); |
| } |
| N = countDataPaths(); |
| for (int i=0; i<N; i++) { |
| serializer.startTag(null, PATH_STR); |
| PatternMatcher pe = mDataPaths.get(i); |
| switch (pe.getType()) { |
| case PatternMatcher.PATTERN_LITERAL: |
| serializer.attribute(null, LITERAL_STR, pe.getPath()); |
| break; |
| case PatternMatcher.PATTERN_PREFIX: |
| serializer.attribute(null, PREFIX_STR, pe.getPath()); |
| break; |
| case PatternMatcher.PATTERN_SIMPLE_GLOB: |
| serializer.attribute(null, SGLOB_STR, pe.getPath()); |
| break; |
| case PatternMatcher.PATTERN_ADVANCED_GLOB: |
| serializer.attribute(null, AGLOB_STR, pe.getPath()); |
| break; |
| } |
| serializer.endTag(null, PATH_STR); |
| } |
| } |
| |
| public void readFromXml(XmlPullParser parser) throws XmlPullParserException, |
| IOException { |
| String autoVerify = parser.getAttributeValue(null, AUTO_VERIFY_STR); |
| setAutoVerify(TextUtils.isEmpty(autoVerify) ? false : Boolean.getBoolean(autoVerify)); |
| |
| int outerDepth = parser.getDepth(); |
| int type; |
| while ((type=parser.next()) != XmlPullParser.END_DOCUMENT |
| && (type != XmlPullParser.END_TAG |
| || parser.getDepth() > outerDepth)) { |
| if (type == XmlPullParser.END_TAG |
| || type == XmlPullParser.TEXT) { |
| continue; |
| } |
| |
| String tagName = parser.getName(); |
| if (tagName.equals(ACTION_STR)) { |
| String name = parser.getAttributeValue(null, NAME_STR); |
| if (name != null) { |
| addAction(name); |
| } |
| } else if (tagName.equals(CAT_STR)) { |
| String name = parser.getAttributeValue(null, NAME_STR); |
| if (name != null) { |
| addCategory(name); |
| } |
| } else if (tagName.equals(TYPE_STR)) { |
| String name = parser.getAttributeValue(null, NAME_STR); |
| if (name != null) { |
| try { |
| addDataType(name); |
| } catch (MalformedMimeTypeException e) { |
| } |
| } |
| } else if (tagName.equals(SCHEME_STR)) { |
| String name = parser.getAttributeValue(null, NAME_STR); |
| if (name != null) { |
| addDataScheme(name); |
| } |
| } else if (tagName.equals(SSP_STR)) { |
| String ssp = parser.getAttributeValue(null, LITERAL_STR); |
| if (ssp != null) { |
| addDataSchemeSpecificPart(ssp, PatternMatcher.PATTERN_LITERAL); |
| } else if ((ssp=parser.getAttributeValue(null, PREFIX_STR)) != null) { |
| addDataSchemeSpecificPart(ssp, PatternMatcher.PATTERN_PREFIX); |
| } else if ((ssp=parser.getAttributeValue(null, SGLOB_STR)) != null) { |
| addDataSchemeSpecificPart(ssp, PatternMatcher.PATTERN_SIMPLE_GLOB); |
| } else if ((ssp=parser.getAttributeValue(null, AGLOB_STR)) != null) { |
| addDataSchemeSpecificPart(ssp, PatternMatcher.PATTERN_ADVANCED_GLOB); |
| } |
| } else if (tagName.equals(AUTH_STR)) { |
| String host = parser.getAttributeValue(null, HOST_STR); |
| String port = parser.getAttributeValue(null, PORT_STR); |
| if (host != null) { |
| addDataAuthority(host, port); |
| } |
| } else if (tagName.equals(PATH_STR)) { |
| String path = parser.getAttributeValue(null, LITERAL_STR); |
| if (path != null) { |
| addDataPath(path, PatternMatcher.PATTERN_LITERAL); |
| } else if ((path=parser.getAttributeValue(null, PREFIX_STR)) != null) { |
| addDataPath(path, PatternMatcher.PATTERN_PREFIX); |
| } else if ((path=parser.getAttributeValue(null, SGLOB_STR)) != null) { |
| addDataPath(path, PatternMatcher.PATTERN_SIMPLE_GLOB); |
| } else if ((path=parser.getAttributeValue(null, AGLOB_STR)) != null) { |
| addDataPath(path, PatternMatcher.PATTERN_ADVANCED_GLOB); |
| } |
| } else { |
| Log.w("IntentFilter", "Unknown tag parsing IntentFilter: " + tagName); |
| } |
| XmlUtils.skipCurrentTag(parser); |
| } |
| } |
| |
| /** @hide */ |
| public void writeToProto(ProtoOutputStream proto, long fieldId) { |
| long token = proto.start(fieldId); |
| if (mActions.size() > 0) { |
| Iterator<String> it = mActions.iterator(); |
| while (it.hasNext()) { |
| proto.write(IntentFilterProto.ACTIONS, it.next()); |
| } |
| } |
| if (mCategories != null) { |
| Iterator<String> it = mCategories.iterator(); |
| while (it.hasNext()) { |
| proto.write(IntentFilterProto.CATEGORIES, it.next()); |
| } |
| } |
| if (mDataSchemes != null) { |
| Iterator<String> it = mDataSchemes.iterator(); |
| while (it.hasNext()) { |
| proto.write(IntentFilterProto.DATA_SCHEMES, it.next()); |
| } |
| } |
| if (mDataSchemeSpecificParts != null) { |
| Iterator<PatternMatcher> it = mDataSchemeSpecificParts.iterator(); |
| while (it.hasNext()) { |
| it.next().writeToProto(proto, IntentFilterProto.DATA_SCHEME_SPECS); |
| } |
| } |
| if (mDataAuthorities != null) { |
| Iterator<AuthorityEntry> it = mDataAuthorities.iterator(); |
| while (it.hasNext()) { |
| it.next().writeToProto(proto, IntentFilterProto.DATA_AUTHORITIES); |
| } |
| } |
| if (mDataPaths != null) { |
| Iterator<PatternMatcher> it = mDataPaths.iterator(); |
| while (it.hasNext()) { |
| it.next().writeToProto(proto, IntentFilterProto.DATA_PATHS); |
| } |
| } |
| if (mDataTypes != null) { |
| Iterator<String> it = mDataTypes.iterator(); |
| while (it.hasNext()) { |
| proto.write(IntentFilterProto.DATA_TYPES, it.next()); |
| } |
| } |
| if (mPriority != 0 || mHasPartialTypes) { |
| proto.write(IntentFilterProto.PRIORITY, mPriority); |
| proto.write(IntentFilterProto.HAS_PARTIAL_TYPES, mHasPartialTypes); |
| } |
| proto.write(IntentFilterProto.GET_AUTO_VERIFY, getAutoVerify()); |
| proto.end(token); |
| } |
| |
| public void dump(Printer du, String prefix) { |
| StringBuilder sb = new StringBuilder(256); |
| if (mActions.size() > 0) { |
| Iterator<String> it = mActions.iterator(); |
| while (it.hasNext()) { |
| sb.setLength(0); |
| sb.append(prefix); sb.append("Action: \""); |
| sb.append(it.next()); sb.append("\""); |
| du.println(sb.toString()); |
| } |
| } |
| if (mCategories != null) { |
| Iterator<String> it = mCategories.iterator(); |
| while (it.hasNext()) { |
| sb.setLength(0); |
| sb.append(prefix); sb.append("Category: \""); |
| sb.append(it.next()); sb.append("\""); |
| du.println(sb.toString()); |
| } |
| } |
| if (mDataSchemes != null) { |
| Iterator<String> it = mDataSchemes.iterator(); |
| while (it.hasNext()) { |
| sb.setLength(0); |
| sb.append(prefix); sb.append("Scheme: \""); |
| sb.append(it.next()); sb.append("\""); |
| du.println(sb.toString()); |
| } |
| } |
| if (mDataSchemeSpecificParts != null) { |
| Iterator<PatternMatcher> it = mDataSchemeSpecificParts.iterator(); |
| while (it.hasNext()) { |
| PatternMatcher pe = it.next(); |
| sb.setLength(0); |
| sb.append(prefix); sb.append("Ssp: \""); |
| sb.append(pe); sb.append("\""); |
| du.println(sb.toString()); |
| } |
| } |
| if (mDataAuthorities != null) { |
| Iterator<AuthorityEntry> it = mDataAuthorities.iterator(); |
| while (it.hasNext()) { |
| AuthorityEntry ae = it.next(); |
| sb.setLength(0); |
| sb.append(prefix); sb.append("Authority: \""); |
| sb.append(ae.mHost); sb.append("\": "); |
| sb.append(ae.mPort); |
| if (ae.mWild) sb.append(" WILD"); |
| du.println(sb.toString()); |
| } |
| } |
| if (mDataPaths != null) { |
| Iterator<PatternMatcher> it = mDataPaths.iterator(); |
| while (it.hasNext()) { |
| PatternMatcher pe = it.next(); |
| sb.setLength(0); |
| sb.append(prefix); sb.append("Path: \""); |
| sb.append(pe); sb.append("\""); |
| du.println(sb.toString()); |
| } |
| } |
| if (mDataTypes != null) { |
| Iterator<String> it = mDataTypes.iterator(); |
| while (it.hasNext()) { |
| sb.setLength(0); |
| sb.append(prefix); sb.append("Type: \""); |
| sb.append(it.next()); sb.append("\""); |
| du.println(sb.toString()); |
| } |
| } |
| if (mPriority != 0 || mOrder != 0 || mHasPartialTypes) { |
| sb.setLength(0); |
| sb.append(prefix); sb.append("mPriority="); sb.append(mPriority); |
| sb.append(", mOrder="); sb.append(mOrder); |
| sb.append(", mHasPartialTypes="); sb.append(mHasPartialTypes); |
| du.println(sb.toString()); |
| } |
| if (getAutoVerify()) { |
| sb.setLength(0); |
| sb.append(prefix); sb.append("AutoVerify="); sb.append(getAutoVerify()); |
| du.println(sb.toString()); |
| } |
| } |
| |
| public static final Parcelable.Creator<IntentFilter> CREATOR |
| = new Parcelable.Creator<IntentFilter>() { |
| public IntentFilter createFromParcel(Parcel source) { |
| return new IntentFilter(source); |
| } |
| |
| public IntentFilter[] newArray(int size) { |
| return new IntentFilter[size]; |
| } |
| }; |
| |
| public final int describeContents() { |
| return 0; |
| } |
| |
| public final void writeToParcel(Parcel dest, int flags) { |
| dest.writeStringList(mActions); |
| if (mCategories != null) { |
| dest.writeInt(1); |
| dest.writeStringList(mCategories); |
| } else { |
| dest.writeInt(0); |
| } |
| if (mDataSchemes != null) { |
| dest.writeInt(1); |
| dest.writeStringList(mDataSchemes); |
| } else { |
| dest.writeInt(0); |
| } |
| if (mDataTypes != null) { |
| dest.writeInt(1); |
| dest.writeStringList(mDataTypes); |
| } else { |
| dest.writeInt(0); |
| } |
| if (mDataSchemeSpecificParts != null) { |
| final int N = mDataSchemeSpecificParts.size(); |
| dest.writeInt(N); |
| for (int i=0; i<N; i++) { |
| mDataSchemeSpecificParts.get(i).writeToParcel(dest, flags); |
| } |
| } else { |
| dest.writeInt(0); |
| } |
| if (mDataAuthorities != null) { |
| final int N = mDataAuthorities.size(); |
| dest.writeInt(N); |
| for (int i=0; i<N; i++) { |
| mDataAuthorities.get(i).writeToParcel(dest); |
| } |
| } else { |
| dest.writeInt(0); |
| } |
| if (mDataPaths != null) { |
| final int N = mDataPaths.size(); |
| dest.writeInt(N); |
| for (int i=0; i<N; i++) { |
| mDataPaths.get(i).writeToParcel(dest, flags); |
| } |
| } else { |
| dest.writeInt(0); |
| } |
| dest.writeInt(mPriority); |
| dest.writeInt(mHasPartialTypes ? 1 : 0); |
| dest.writeInt(getAutoVerify() ? 1 : 0); |
| dest.writeInt(mInstantAppVisibility); |
| dest.writeInt(mOrder); |
| } |
| |
| /** |
| * For debugging -- perform a check on the filter, return true if it passed |
| * or false if it failed. |
| * |
| * {@hide} |
| */ |
| public boolean debugCheck() { |
| return true; |
| |
| // This code looks for intent filters that do not specify data. |
| /* |
| if (mActions != null && mActions.size() == 1 |
| && mActions.contains(Intent.ACTION_MAIN)) { |
| return true; |
| } |
| |
| if (mDataTypes == null && mDataSchemes == null) { |
| Log.w("IntentFilter", "QUESTIONABLE INTENT FILTER:"); |
| dump(Log.WARN, "IntentFilter", " "); |
| return false; |
| } |
| |
| return true; |
| */ |
| } |
| |
| /** @hide */ |
| public IntentFilter(Parcel source) { |
| mActions = new ArrayList<String>(); |
| source.readStringList(mActions); |
| if (source.readInt() != 0) { |
| mCategories = new ArrayList<String>(); |
| source.readStringList(mCategories); |
| } |
| if (source.readInt() != 0) { |
| mDataSchemes = new ArrayList<String>(); |
| source.readStringList(mDataSchemes); |
| } |
| if (source.readInt() != 0) { |
| mDataTypes = new ArrayList<String>(); |
| source.readStringList(mDataTypes); |
| } |
| int N = source.readInt(); |
| if (N > 0) { |
| mDataSchemeSpecificParts = new ArrayList<PatternMatcher>(N); |
| for (int i=0; i<N; i++) { |
| mDataSchemeSpecificParts.add(new PatternMatcher(source)); |
| } |
| } |
| N = source.readInt(); |
| if (N > 0) { |
| mDataAuthorities = new ArrayList<AuthorityEntry>(N); |
| for (int i=0; i<N; i++) { |
| mDataAuthorities.add(new AuthorityEntry(source)); |
| } |
| } |
| N = source.readInt(); |
| if (N > 0) { |
| mDataPaths = new ArrayList<PatternMatcher>(N); |
| for (int i=0; i<N; i++) { |
| mDataPaths.add(new PatternMatcher(source)); |
| } |
| } |
| mPriority = source.readInt(); |
| mHasPartialTypes = source.readInt() > 0; |
| setAutoVerify(source.readInt() > 0); |
| setVisibilityToInstantApp(source.readInt()); |
| mOrder = source.readInt(); |
| } |
| |
| private final boolean findMimeType(String type) { |
| final ArrayList<String> t = mDataTypes; |
| |
| if (type == null) { |
| return false; |
| } |
| |
| if (t.contains(type)) { |
| return true; |
| } |
| |
| // Deal with an Intent wanting to match every type in the IntentFilter. |
| final int typeLength = type.length(); |
| if (typeLength == 3 && type.equals("*/*")) { |
| return !t.isEmpty(); |
| } |
| |
| // Deal with this IntentFilter wanting to match every Intent type. |
| if (mHasPartialTypes && t.contains("*")) { |
| return true; |
| } |
| |
| final int slashpos = type.indexOf('/'); |
| if (slashpos > 0) { |
| if (mHasPartialTypes && t.contains(type.substring(0, slashpos))) { |
| return true; |
| } |
| if (typeLength == slashpos+2 && type.charAt(slashpos+1) == '*') { |
| // Need to look through all types for one that matches |
| // our base... |
| final int numTypes = t.size(); |
| for (int i = 0; i < numTypes; i++) { |
| final String v = t.get(i); |
| if (type.regionMatches(0, v, 0, slashpos+1)) { |
| return true; |
| } |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * @hide |
| */ |
| public ArrayList<String> getHostsList() { |
| ArrayList<String> result = new ArrayList<>(); |
| Iterator<IntentFilter.AuthorityEntry> it = authoritiesIterator(); |
| if (it != null) { |
| while (it.hasNext()) { |
| IntentFilter.AuthorityEntry entry = it.next(); |
| result.add(entry.getHost()); |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * @hide |
| */ |
| public String[] getHosts() { |
| ArrayList<String> list = getHostsList(); |
| return list.toArray(new String[list.size()]); |
| } |
| } |