/**@class android.content.IntentFilter
 implements android.os.Parcelable

@extends java.lang.Object

 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, android.content.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 android.content.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 android.content.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 android.content.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 android.content.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 android.content.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.
*/
var IntentFilter = {

/** 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
*/
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
*/
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.
*/
MATCH_CATEGORY_MASK : "268369920",
/** 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.
*/
MATCH_ADJUSTMENT_MASK : "65535",
/** Quality adjustment applied to the category of match that signifies
 the default, base value; higher numbers improve the quality while
 lower numbers reduce it.
*/
MATCH_ADJUSTMENT_NORMAL : "32768",
/** The filter matched an intent that had no data specified.
*/
MATCH_CATEGORY_EMPTY : "1048576",
/** The filter matched an intent with the same data URI scheme.
*/
MATCH_CATEGORY_SCHEME : "2097152",
/** The filter matched an intent with the same data URI scheme and
 authority host.
*/
MATCH_CATEGORY_HOST : "3145728",
/** The filter matched an intent with the same data URI scheme and
 authority host and port.
*/
MATCH_CATEGORY_PORT : "4194304",
/** The filter matched an intent with the same data URI scheme,
 authority, and path.
*/
MATCH_CATEGORY_PATH : "5242880",
/** The filter matched an intent with the same data URI scheme and
 scheme specific part.
*/
MATCH_CATEGORY_SCHEME_SPECIFIC_PART : "5767168",
/** The filter matched an intent with the same data MIME type.
*/
MATCH_CATEGORY_TYPE : "6291456",
/** The filter didn't match due to different MIME types.
*/
NO_MATCH_TYPE : "-1",
/** The filter didn't match due to different data URIs.
*/
NO_MATCH_DATA : "-2",
/** The filter didn't match due to different actions.
*/
NO_MATCH_ACTION : "-3",
/** The filter didn't match because it required one or more categories
 that were not in the Intent.
*/
NO_MATCH_CATEGORY : "-4",
/** HTTP scheme.

 @see #addDataScheme(String)
 @hide
*/
SCHEME_HTTP : "http",
/** HTTPS scheme.

 @see #addDataScheme(String)
 @hide
*/
SCHEME_HTTPS : "https",
/**@hide */
VISIBILITY_NONE : "0",
/**@hide */
VISIBILITY_EXPLICIT : "1",
/**@hide */
VISIBILITY_IMPLICIT : "2",
/***/
CREATOR : "null",
/**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 android.content.IntentFilter.MalformedMimeTypeException} exception that the constructor
 can call and turns it into a runtime exception.
@param {String} action The action to match, such as Intent.ACTION_VIEW.
@param {String} dataType The type to match, such as "vnd.android.cursor.dir/person".
@return {Object {android.content.IntentFilter}} A new IntentFilter for the given action and type.
@see #IntentFilter(String, String)
*/
create : function(  ) {},

/**Modify priority of this filter.  This only affects receiver filters.
 The priority of activity filters are set in XML and cannot be changed
 programmatically. 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 {Number} priority The new priority value.
@see #getPriority
@see #SYSTEM_LOW_PRIORITY
@see #SYSTEM_HIGH_PRIORITY
*/
setPriority : function(  ) {},

/**Return the priority of this filter.
@return {Number} The priority of the filter.
@see #setPriority
*/
getPriority : function(  ) {},

/**
@hide 
*/
setOrder : function(  ) {},

/**
@hide 
*/
getOrder : function(  ) {},

/**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 {Boolean} 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 
*/
setAutoVerify : function(  ) {},

/**Return if this filter will needs to be automatically verified again its data URIs or not.
@return {Boolean} True if the filter will needs to be automatically verified. False otherwise.
@see #setAutoVerify(boolean)
@hide 
*/
getAutoVerify : function(  ) {},

/**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 {Boolean} 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 
*/
handleAllWebDataURI : function(  ) {},

/**Return if this filter handles HTTP or HTTPS data URIs.
@param {Boolean} 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.
@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 
*/
handlesWebUris : function(  ) {},

/**Return if this filter needs to be automatically verified again its data URIs or not.
@return {Boolean} 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 
*/
needsVerification : function(  ) {},

/**Return if this filter has been verified
@return {Boolean} true if the filter has been verified or if autoVerify is false.
@hide 
*/
isVerified : function(  ) {},

/**Set if this filter has been verified
@param {Boolean} verified true if this filter has been verified. False otherwise.
@hide 
*/
setVerified : function(  ) {},

/**
@hide 
*/
setVisibilityToInstantApp : function(  ) {},

/**
@hide 
*/
getVisibilityToInstantApp : function(  ) {},

/**
@hide 
*/
isVisibleToInstantApp : function(  ) {},

/**
@hide 
*/
isExplicitlyVisibleToInstantApp : function(  ) {},

/**
@hide 
*/
isImplicitlyVisibleToInstantApp : function(  ) {},

/**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 {String} action Name of the action to match, such as Intent.ACTION_VIEW.
*/
addAction : function(  ) {},

/**Return the number of actions in the filter.
*/
countActions : function(  ) {},

/**Return an action in the filter.
*/
getAction : function(  ) {},

/**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 {String} action The action to look for.
@return {Boolean} True if the action is explicitly mentioned in the filter.
*/
hasAction : function(  ) {},

/**Match this filter against an Intent's action.  If the filter does not
 specify any actions, the match will always fail.
@param {String} action The desired action to look for.
@return {Boolean} True if the action is listed in the filter.
*/
matchAction : function(  ) {},

/**Return an iterator over the filter's actions.  If there are no actions,
 returns null.
*/
actionsIterator : function(  ) {},

/**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 android.content.IntentFilter.MalformedMimeTypeException} if the given MIME type is
 not syntactically correct.
@param {String} type Name of the data type to match, such as "vnd.android.cursor.dir/person".
@see #matchData
*/
addDataType : function(  ) {},

/**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 {String} type The data type to look for.
@return {Boolean} True if the type is explicitly mentioned in the filter.
*/
hasDataType : function(  ) {},

/**
@hide 
*/
hasExactDataType : function(  ) {},

/**Return the number of data types in the filter.
*/
countDataTypes : function(  ) {},

/**Return a data type in the filter.
*/
getDataType : function(  ) {},

/**Return an iterator over the filter's data types.
*/
typesIterator : function(  ) {},

/**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 {String} scheme Name of the scheme to match, such as "http".
@see #matchData
*/
addDataScheme : function(  ) {},

/**Return the number of data schemes in the filter.
*/
countDataSchemes : function(  ) {},

/**Return a data scheme in the filter.
*/
getDataScheme : function(  ) {},

/**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 {String} scheme The data scheme to look for.
@return {Boolean} True if the scheme is explicitly mentioned in the filter.
*/
hasDataScheme : function(  ) {},

/**Return an iterator over the filter's data schemes.
*/
schemesIterator : function(  ) {},

/**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 {String} ssp Either a raw string that must exactly match the scheme specific part
 path, or a simple pattern, depending on <var>type</var>.
@param {Number} 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
*/
addDataSchemeSpecificPart : function(  ) {},

/**
@hide 
*/
addDataSchemeSpecificPart : function(  ) {},

/**Return the number of data scheme specific parts in the filter.
*/
countDataSchemeSpecificParts : function(  ) {},

/**Return a data scheme specific part in the filter.
*/
getDataSchemeSpecificPart : function(  ) {},

/**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 {String} data The scheme specific part that is being looked for.
@return {Boolean} Returns true if the data string matches a scheme specific part listed in the
         filter.
*/
hasDataSchemeSpecificPart : function(  ) {},

/**
@hide 
*/
hasDataSchemeSpecificPart : function(  ) {},

/**Return an iterator over the filter's data scheme specific parts.
*/
schemeSpecificPartsIterator : function(  ) {},

/**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 {String} host The host part of the authority to match.  May start with a
             single '*' to wildcard the front of the host name.
@param {String} port Optional port part of the authority to match.  If null, any
             port is allowed.
@see #matchData
@see #addDataScheme
*/
addDataAuthority : function(  ) {},

/**
@hide 
*/
addDataAuthority : function(  ) {},

/**Return the number of data authorities in the filter.
*/
countDataAuthorities : function(  ) {},

/**Return a data authority in the filter.
*/
getDataAuthority : function(  ) {},

/**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 {Object {Uri}} data The data whose authority is being looked for.
@return {Boolean} Returns true if the data string matches an authority listed in the
         filter.
*/
hasDataAuthority : function(  ) {},

/**
@hide 
*/
hasDataAuthority : function(  ) {},

/**Return an iterator over the filter's data authorities.
*/
authoritiesIterator : function(  ) {},

/**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 {String} path Either a raw string that must exactly match the file
 path, or a simple pattern, depending on <var>type</var>.
@param {Number} 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
*/
addDataPath : function(  ) {},

/**
@hide 
*/
addDataPath : function(  ) {},

/**Return the number of data paths in the filter.
*/
countDataPaths : function(  ) {},

/**Return a data path in the filter.
*/
getDataPath : function(  ) {},

/**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 {String} data The data path to look for.  This is without the scheme
             prefix.
@return {Boolean} True if the data string matches a path listed in the
         filter.
*/
hasDataPath : function(  ) {},

/**
@hide 
*/
hasDataPath : function(  ) {},

/**Return an iterator over the filter's data paths.
*/
pathsIterator : function(  ) {},

/**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 {Object {Uri}} data The data whose authority is being looked for.
@return {Number} Returns either {@link #MATCH_CATEGORY_HOST},
 {@link #MATCH_CATEGORY_PORT}, {@link #NO_MATCH_DATA}.
*/
matchDataAuthority : function(  ) {},

/**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 {String} type The desired data type to look for, as returned by
             Intent.resolveType().
@param {String} scheme The desired data scheme to look for, as returned by
               Intent.getScheme().
@param {Object {Uri}} data The full data string to match against, as supplied in
             Intent.data.
@return {Number} 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
*/
matchData : function(  ) {},

/**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 {String} category Name of category to match, such as Intent.CATEGORY_EMBED.
*/
addCategory : function(  ) {},

/**Return the number of categories in the filter.
*/
countCategories : function(  ) {},

/**Return a category in the filter.
*/
getCategory : function(  ) {},

/**Is the given category included in the filter?
@param {String} category The category that the filter supports.
@return {Boolean} True if the category is explicitly mentioned in the filter.
*/
hasCategory : function(  ) {},

/**Return an iterator over the filter's categories.
@return {Object {java.util.Iterator}} Iterator if this filter has categories or {@code null} if none.
*/
categoriesIterator : function(  ) {},

/**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 {Object {java.util.Set}} categories The categories included in the intent, as returned by
                   Intent.getCategories().
@return {String} If all categories match (success), null; else the name of the
         first category that didn't match.
*/
matchCategories : function(  ) {},

/**Test whether this filter matches the given <var>intent</var>.
@param {Object {ContentResolver}} intent The Intent to compare against.
@param {Object {Intent}} 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 {Boolean} logTag Tag to use in debugging messages.
@return {Number} 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)
*/
match : function(  ) {},

/**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 android.content.IntentFilter}; in that case,
 the match result returned will be as per {@link #matchData}.
@param {String} action The intent action to match against (Intent.getAction).
@param {String} type The intent type to match against (Intent.resolveType()).
@param {String} scheme The data scheme to match against (Intent.getScheme()).
@param {Object {Uri}} data The data URI to match against (Intent.getData()).
@param {Object {java.util.Set}} categories The categories to match against
                   (Intent.getCategories()).
@param {String} logTag Tag to use in debugging messages.
@return {Number} 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
*/
match : function(  ) {},

/**Write the contents of the IntentFilter as an XML stream.
*/
writeToXml : function(  ) {},

/**
*/
readFromXml : function(  ) {},

/**
@hide 
*/
writeToProto : function(  ) {},

/**
*/
dump : function(  ) {},

/**
*/
describeContents : function(  ) {},

/**
*/
writeToParcel : function(  ) {},

/**For debugging -- perform a check on the filter, return true if it passed
 or false if it failed.

 {@hide}
*/
debugCheck : function(  ) {},

/**
@hide 
*/
getHostsList : function(  ) {},

/**
@hide 
*/
getHosts : function(  ) {},


};