/**@class android.app.slice.SliceProvider
@extends android.content.ContentProvider

 A SliceProvider allows an app to provide content to be displayed in system spaces. This content
 is templated and can contain actions, and the behavior of how it is surfaced is specific to the
 system surface.
 <p>
 Slices are not currently live content. They are bound once and shown to the user. If the content
 changes due to a callback from user interaction, then
 {@link ContentResolver#notifyChange(Uri, ContentObserver)} should be used to notify the system.
 </p>
 <p>
 The provider needs to be declared in the manifest to provide the authority for the app. The
 authority for most slices is expected to match the package of the application.
 </p>

 <pre class="prettyprint">
 {@literal
 <provider
     android:name="com.example.mypkg.MySliceProvider"
     android:authorities="com.example.mypkg" />}
 </pre>
 <p>
 Slices can be identified by a Uri or by an Intent. To link an Intent with a slice, the provider
 must have an {@link IntentFilter} matching the slice intent. When a slice is being requested via
 an intent, {@link #onMapIntentToUri}(Intent) can be called and is expected to return an
 appropriate Uri representing the slice.

 <pre class="prettyprint">
 {@literal
 <provider
     android:name="com.example.mypkg.MySliceProvider"
     android:authorities="com.example.mypkg">
     <intent-filter>
         <action android:name="com.example.mypkg.intent.action.MY_SLICE_INTENT" />
         <category android:name="android.app.slice.category.SLICE" />
     </intent-filter>
 </provider>}
 </pre>

 @see Slice
*/
var SliceProvider = {

/** This is the Android platform's MIME type for a URI
 containing a slice implemented through {@link android.app.slice.SliceProvider}.
*/
SLICE_TYPE : "vnd.android.slice",
/** @hide
*/
EXTRA_BIND_URI : "slice_uri",
/** @hide
*/
EXTRA_SUPPORTED_SPECS : "supported_specs",
/** @hide
*/
METHOD_SLICE : "bind_slice",
/** @hide
*/
METHOD_MAP_INTENT : "map_slice",
/** @hide
*/
METHOD_MAP_ONLY_INTENT : "map_only",
/** @hide
*/
METHOD_PIN : "pin",
/** @hide
*/
METHOD_UNPIN : "unpin",
/** @hide
*/
METHOD_GET_DESCENDANTS : "get_descendants",
/** @hide
*/
METHOD_GET_PERMISSIONS : "get_permissions",
/** @hide
*/
EXTRA_INTENT : "slice_intent",
/** @hide
*/
EXTRA_SLICE : "slice",
/** @hide
*/
EXTRA_SLICE_DESCENDANTS : "slice_descendants",
/** @hide
*/
EXTRA_PKG : "pkg",
/** @hide
*/
EXTRA_PROVIDER_PKG : "provider_pkg",
/** @hide
*/
EXTRA_RESULT : "result",
/**
*/
attachInfo : function(  ) {},

/**Implemented to create a slice.
 <p>
 onBindSlice should return as quickly as possible so that the UI tied
 to this slice can be responsive. No network or other IO will be allowed
 during onBindSlice. Any loading that needs to be done should happen
 in the background with a call to {@link ContentResolver#notifyChange(Uri, ContentObserver)}
 when the app is ready to provide the complete data in onBindSlice.
 <p>
 The slice returned should have a spec that is compatible with one of
 the supported specs.
@param {Object {Uri}} sliceUri Uri to bind.
@param {Object {java.util.Set}} supportedSpecs List of supported specs.
@see Slice
@see Slice#HINT_PARTIAL
*/
onBindSlice : function(  ) {},

/**
@deprecated TO BE REMOVED
@removed 
*/
onBindSlice : function(  ) {},

/**Called to inform an app that a slice has been pinned.
 <p>
 Pinning is a way that slice hosts use to notify apps of which slices
 they care about updates for. When a slice is pinned the content is
 expected to be relatively fresh and kept up to date.
 <p>
 Being pinned does not provide any escalated privileges for the slice
 provider. So apps should do things such as turn on syncing or schedule
 a job in response to a onSlicePinned.
 <p>
 Pinned state is not persisted through a reboot, and apps can expect a
 new call to onSlicePinned for any slices that should remain pinned
 after a reboot occurs.
@param {Object {Uri}} sliceUri The uri of the slice being unpinned.
@see #onSliceUnpinned(Uri)
*/
onSlicePinned : function(  ) {},

/**Called to inform an app that a slices is no longer pinned.
 <p>
 This means that no other apps on the device care about updates to this
 slice anymore and therefore it is not important to be updated. Any syncs
 or jobs related to this slice should be cancelled.
@see #onSlicePinned(Uri)
*/
onSliceUnpinned : function(  ) {},

/**Obtains a list of slices that are descendants of the specified Uri.
 <p>
 Implementing this is optional for a SliceProvider, but does provide a good
 discovery mechanism for finding slice Uris.
@param {Object {Uri}} uri The uri to look for descendants under.
@return {Object {java.util.Collection}} All slices within the space.
@see SliceManager#getSliceDescendants(Uri)
*/
onGetSliceDescendants : function(  ) {},

/**This method must be overridden if an {@link IntentFilter} is specified on the SliceProvider.
 In that case, this method can be called and is expected to return a non-null Uri representing
 a slice. Otherwise this will throw {@link UnsupportedOperationException}.

 Any intent filter added to a slice provider should also contain
 {@link android.app.slice.SliceManager#CATEGORY_SLICE}, because otherwise it will not be detected by
 {@link android.app.slice.SliceManager#mapIntentToUri(Intent)}.
@return {Object {android.net.Uri}} Uri representing the slice associated with the provided intent.
@see Slice
@see SliceManager#mapIntentToUri(Intent)
*/
onMapIntentToUri : function(  ) {},

/**Called when an app requests a slice it does not have write permission
 to the uri for.
 <p>
 The return value will be the action on a slice that prompts the user that
 the calling app wants to show slices from this app. The default implementation
 launches a dialog that allows the user to grant access to this slice. Apps
 that do not want to allow this user grant, can override this and instead
 launch their own dialog with different behavior.
@param {Object {Uri}} sliceUri the Uri of the slice attempting to be bound.
@see #getCallingPackage()
*/
onCreatePermissionRequest : function(  ) {},

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

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

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

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

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

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

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

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

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

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

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


};