ContentProvider

ContentProvider

ContentProvider()

Construct a ContentProvider instance. Content providers must be declared in the manifest, accessed with ContentResolver, and created automatically by the system, so applications usually do not create ContentProvider instances directly.

At construction time, the object is uninitialized, and most fields and methods are unavailable. Subclasses should initialize themselves in onCreate, not the constructor.

Content providers are created on the application main thread at application launch time. The constructor must not perform lengthy operations, or application startup will be delayed.

applyBatch

open fun applyBatch(
    authority: String, 
    operations: ArrayList<ContentProviderOperation!>
): Array<ContentProviderResult!>

Override this to handle requests to perform a batch of operations, or the default implementation will iterate over the operations and call ContentProviderOperation.apply on each of them. If all calls to ContentProviderOperation.apply succeed then a ContentProviderResult array with as many elements as there were operations will be returned. If any of the calls fail, it is up to the implementation how many of the others take effect. This method can be called from multiple threads, as described in Processes and Threads.

applyBatch

open fun applyBatch(operations: ArrayList<ContentProviderOperation!>): Array<ContentProviderResult!>

attachInfo

open fun attachInfo(
    context: Context!, 
    info: ProviderInfo!
): Unit

After being instantiated, this is called to tell the content provider about itself.

bulkInsert

open fun bulkInsert(
    uri: Uri, 
    values: Array<ContentValues!>
): Int

Override this to handle requests to insert a set of new rows, or the default implementation will iterate over the values and call #insert on each of them. As a courtesy, call notifyChange() after inserting. This method can be called from multiple threads, as described in Processes and Threads.

call

open fun call(
    method: String, 
    arg: String?, 
    extras: Bundle?
): Bundle?

call

open fun call(
    authority: String, 
    method: String, 
    arg: String?, 
    extras: Bundle?
): Bundle?

Call a provider-defined method. This can be used to implement interfaces that are cheaper and/or unnatural for a table-like model.

WARNING: The framework does no permission checking on this entry into the content provider besides the basic ability for the application to get access to the provider at all. For example, it has no idea whether the call being executed may read or write data in the provider, so can't enforce those individual permissions. Any implementation of this method must do its own permission checks on incoming calls to make sure they are allowed.

canonicalize

open fun canonicalize(url: Uri): Uri?

Implement this to support canonicalization of URIs that refer to your content provider. A canonical URI is one that can be transported across devices, backup/restore, and other contexts, and still be able to refer to the same data item. Typically this is implemented by adding query params to the URI allowing the content provider to verify that an incoming canonical URI references the same data as it was originally intended for and, if it doesn't, to find that data (if it exists) in the current environment.

For example, if the content provider holds people and a normal URI in it is created with a row index into that people database, the cananical representation may have an additional query param at the end which specifies the name of the person it is intended for. Later calls into the provider with that URI will look up the row of that URI's base index and, if it doesn't match or its entry's name doesn't match the name in the query param, perform a query on its database to find the correct row to operate on.

If you implement support for canonical URIs, all incoming calls with URIs (including this one) must perform this verification and recovery of any canonical URIs they receive. In addition, you must also implement uncanonicalize to strip the canonicalization of any of these URIs.

The default implementation of this method returns null, indicating that canonical URIs are not supported.

clearCallingIdentity

fun clearCallingIdentity(): ContentProvider.CallingIdentity

Reset the identity of the incoming IPC on the current thread.

Internally this calls Binder.clearCallingIdentity() and also clears any value stored in getCallingPackage().

delete

open fun delete(
    uri: Uri, 
    extras: Bundle?
): Int

Implement this to handle requests to delete one or more rows. The implementation should apply the selection clause when performing deletion, allowing the operation to affect multiple rows in a directory. As a courtesy, call notifyChange() after deleting. This method can be called from multiple threads, as described in Processes and Threads.

The implementation is responsible for parsing out a row ID at the end of the URI, if a specific row is being deleted. That is, the client would pass in content://contacts/people/22 and the implementation is responsible for parsing the record number (22) when creating a SQL statement.

delete

abstract fun delete(
    uri: Uri, 
    selection: String?, 
    selectionArgs: Array<String!>?
): Int

Implement this to handle requests to delete one or more rows. The implementation should apply the selection clause when performing deletion, allowing the operation to affect multiple rows in a directory. As a courtesy, call notifyChange() after deleting. This method can be called from multiple threads, as described in Processes and Threads.

The implementation is responsible for parsing out a row ID at the end of the URI, if a specific row is being deleted. That is, the client would pass in content://contacts/people/22 and the implementation is responsible for parsing the record number (22) when creating a SQL statement.

dump

open fun dump(
    fd: FileDescriptor!, 
    writer: PrintWriter!, 
    args: Array<String!>!
): Unit

Print the Provider's state into the given stream. This gets invoked if you run "adb shell dumpsys activity provider <provider_component_name>".

getCallingAttributionSource

fun getCallingAttributionSource(): AttributionSource?

Gets the attribution source of the calling app. If you want to attribute the data access to the calling app you can create an attribution context via android.content.Context#createContext(ContextParams) and passing this identity to ContextParams.Builder.setNextAttributionSource(.

getCallingAttributionTag

fun getCallingAttributionTag(): String?

Return the attribution tag of the caller that initiated the request being processed on the current thread. Returns null if not currently processing a request of the request is for the default attribution.

This will always return null when processing getTypeAnonymous(android.net.Uri) requests For getType(android.net.Uri) requests, this will be only available for cases, where the caller can be identified. See getTypeAnonymous(android.net.Uri)

getCallingPackage

fun getCallingPackage(): String?

Return the package name of the caller that initiated the request being processed on the current thread. The returned package will have been verified to belong to the calling UID. Returns null if not currently processing a request.

This will always return null when processing getTypeAnonymous(android.net.Uri) requests For getType(android.net.Uri) requests, this will be only available for cases, where the caller can be identified. See getTypeAnonymous(android.net.Uri)

getCallingPackageUnchecked

fun getCallingPackageUnchecked(): String?

Return the package name of the caller that initiated the request being processed on the current thread. The returned package will have not been verified to belong to the calling UID. Returns null if not currently processing a request.

This will always return null when processing getTypeAnonymous(android.net.Uri) requests For getType(android.net.Uri) requests, this will be only available for cases, where the caller can be identified. See getTypeAnonymous(android.net.Uri)

getContext

fun getContext(): Context?

Retrieves the Context this provider is running in. Only available once onCreate has been called -- this will return null in the constructor.

getPathPermissions

fun getPathPermissions(): Array<PathPermission!>?

Return the path-based permissions required for read and/or write access to this content provider. This method can be called from multiple threads, as described in Processes and Threads.

getReadPermission

fun getReadPermission(): String?

Return the name of the permission required for read-only access to this content provider. This method can be called from multiple threads, as described in Processes and Threads.

getStreamTypes

open fun getStreamTypes(
    uri: Uri, 
    mimeTypeFilter: String
): Array<String!>?

Called by a client to determine the types of data streams that this content provider supports for the given URI. The default implementation returns null, meaning no types. If your content provider stores data of a particular type, return that MIME type if it matches the given mimeTypeFilter. If it can perform type conversions, return an array of all supported MIME types that match mimeTypeFilter.

getType

abstract fun getType(uri: Uri): String?

Implement this to handle requests for the MIME type of the data at the given URI. The returned MIME type should start with vnd.android.cursor.item for a single record, or vnd.android.cursor.dir/ for multiple items. This method can be called from multiple threads, as described in Processes and Threads.

Note that by default there are no permissions needed for an application to access this information; if your content provider requires read and/or write permissions, or is not exported, all applications can still call this method regardless of their access permissions.

If your mime type reveals details that should be protected, then you should protect this method by implementing getTypeAnonymous. Implementing getTypeAnonymous ensures your getType can be only accessed by caller's having associated readPermission for the URI.

getTypeAnonymous

open fun getTypeAnonymous(uri: Uri): String?

Implement this to handle requests for MIME type of URIs, that does not need to reveal any internal information which should be protected by any permission.

If your mime type reveals details that should be protected, then you should protect those by implementing those in getType, and in this function, only return types of URIs which can be obtained by anyone without any access. Implementing ths function will make sure getType is protected by readPermission. This function by default works as the getType

getWritePermission

fun getWritePermission(): String?

Return the name of the permission required for read/write access to this content provider. This method can be called from multiple threads, as described in Processes and Threads.

insert

abstract fun insert(
    uri: Uri, 
    values: ContentValues?
): Uri?

Implement this to handle requests to insert a new row. As a courtesy, call notifyChange() after inserting. This method can be called from multiple threads, as described in Processes and Threads.

insert

open fun insert(
    uri: Uri, 
    values: ContentValues?, 
    extras: Bundle?
): Uri?

Implement this to handle requests to insert a new row. As a courtesy, call notifyChange() after inserting. This method can be called from multiple threads, as described in Processes and Threads.

onCallingPackageChanged

open fun onCallingPackageChanged(): Unit

Called whenever the value of getCallingPackage() changes, giving the provider an opportunity to invalidate any security related caching it may be performing.

This typically happens when a ContentProvider makes a nested call back into itself when already processing a call from a remote process.

onConfigurationChanged

open fun onConfigurationChanged(newConfig: Configuration): Unit

Called by the system when the device configuration changes while your component is running. Note that, unlike activities, other components are never restarted when a configuration changes: they must always deal with the results of the change, such as by re-retrieving resources.

At the time that this function has been called, your Resources object will have been updated to return resource values matching the new configuration.

For more information, read Handling Runtime Changes. This method is always called on the application main thread, and must not perform lengthy operations.

The default content provider implementation does nothing. Override this method to take appropriate action. (Content providers do not usually care about things like screen orientation, but may want to know about locale changes.)

onCreate

abstract fun onCreate(): Boolean

Implement this to initialize your content provider on startup. This method is called for all registered content providers on the application main thread at application launch time. It must not perform lengthy operations, or application startup will be delayed.

You should defer nontrivial initialization (such as opening, upgrading, and scanning databases) until the content provider is used (via #query, #insert, etc). Deferred initialization keeps application startup fast, avoids unnecessary work if the provider turns out not to be needed, and stops database errors (such as a full disk) from halting application launch.

If you use SQLite, android.database.sqlite.SQLiteOpenHelper is a helpful utility class that makes it easy to manage databases, and will automatically defer opening until first use. If you do use SQLiteOpenHelper, make sure to avoid calling android.database.sqlite.SQLiteOpenHelper#getReadableDatabase or android.database.sqlite.SQLiteOpenHelper#getWritableDatabase from this method. (Instead, override android.database.sqlite.SQLiteOpenHelper#onOpen to initialize the database when it is first opened.)

onLowMemory

open fun onLowMemory(): Unit

This is called when the overall system is running low on memory, and actively running processes should trim their memory usage. While the exact point at which this will be called is not defined, generally it will happen when all background process have been killed. That is, before reaching the point of killing processes hosting service and foreground UI that we would like to avoid killing. This method is always called on the application main thread, and must not perform lengthy operations.

The default content provider implementation does nothing. Subclasses may override this method to take appropriate action.

onTrimMemory

open fun onTrimMemory(level: Int): Unit

openAssetFile

open fun openAssetFile(
    uri: Uri, 
    mode: String
): AssetFileDescriptor?

This is like #openFile, but can be implemented by providers that need to be able to return sub-sections of files, often assets inside of their .apk. This method can be called from multiple threads, as described in Processes and Threads.

If you implement this, your clients must be able to deal with such file slices, either directly with android.content.ContentResolver#openAssetFileDescriptor, or by using the higher-level ContentResolver.openInputStream or android.content.ContentResolver#openOutputStream methods.

The returned AssetFileDescriptor can be a pipe or socket pair to enable streaming of data.

If you are implementing this to return a full file, you should create the AssetFileDescriptor with AssetFileDescriptor.UNKNOWN_LENGTH to be compatible with applications that cannot handle sub-sections of files.

For use in Intents, you will want to implement getType to return the appropriate MIME type for the data returned here with the same URI. This will allow intent resolution to automatically determine the data MIME type and select the appropriate matching targets as part of its operation.

For better interoperability with other applications, it is recommended that for any URIs that can be opened, you also support queries on them containing at least the columns specified by android.provider.OpenableColumns.

openAssetFile

open fun openAssetFile(
    uri: Uri, 
    mode: String, 
    signal: CancellationSignal?
): AssetFileDescriptor?

This is like #openFile, but can be implemented by providers that need to be able to return sub-sections of files, often assets inside of their .apk. This method can be called from multiple threads, as described in Processes and Threads.

If you implement this, your clients must be able to deal with such file slices, either directly with android.content.ContentResolver#openAssetFileDescriptor, or by using the higher-level ContentResolver.openInputStream or android.content.ContentResolver#openOutputStream methods.

The returned AssetFileDescriptor can be a pipe or socket pair to enable streaming of data.

If you are implementing this to return a full file, you should create the AssetFileDescriptor with AssetFileDescriptor.UNKNOWN_LENGTH to be compatible with applications that cannot handle sub-sections of files.

For use in Intents, you will want to implement getType to return the appropriate MIME type for the data returned here with the same URI. This will allow intent resolution to automatically determine the data MIME type and select the appropriate matching targets as part of its operation.

For better interoperability with other applications, it is recommended that for any URIs that can be opened, you also support queries on them containing at least the columns specified by android.provider.OpenableColumns.

openFile

open fun openFile(
    uri: Uri, 
    mode: String
): ParcelFileDescriptor?

Override this to handle requests to open a file blob. The default implementation always throws FileNotFoundException. This method can be called from multiple threads, as described in Processes and Threads.

This method returns a ParcelFileDescriptor, which is returned directly to the caller. This way large data (such as images and documents) can be returned without copying the content.

The returned ParcelFileDescriptor is owned by the caller, so it is their responsibility to close it when done. That is, the implementation of this method should create a new ParcelFileDescriptor for each call.

If opened with the exclusive "r" or "w" modes, the returned ParcelFileDescriptor can be a pipe or socket pair to enable streaming of data. Opening with the "rw" or "rwt" modes implies a file on disk that supports seeking.

If you need to detect when the returned ParcelFileDescriptor has been closed, or if the remote process has crashed or encountered some other error, you can use ParcelFileDescriptor.open(File, int,, ParcelFileDescriptor.createReliablePipe(), or ParcelFileDescriptor.createReliableSocketPair().

If you need to return a large file that isn't backed by a real file on disk, such as a file on a network share or cloud storage service, consider using StorageManager.openProxyFileDescriptor(int, android.os.ProxyFileDescriptorCallback, android.os.Handler) which will let you to stream the content on-demand.

For use in Intents, you will want to implement getType to return the appropriate MIME type for the data returned here with the same URI. This will allow intent resolution to automatically determine the data MIME type and select the appropriate matching targets as part of its operation.

For better interoperability with other applications, it is recommended that for any URIs that can be opened, you also support queries on them containing at least the columns specified by android.provider.OpenableColumns. You may also want to support other common columns if you have additional meta-data to supply, such as android.provider.MediaStore.MediaColumns#DATE_ADDED in android.provider.MediaStore.MediaColumns.

openFile

open fun openFile(
    uri: Uri, 
    mode: String, 
    signal: CancellationSignal?
): ParcelFileDescriptor?

Override this to handle requests to open a file blob. The default implementation always throws FileNotFoundException. This method can be called from multiple threads, as described in Processes and Threads.

This method returns a ParcelFileDescriptor, which is returned directly to the caller. This way large data (such as images and documents) can be returned without copying the content.

The returned ParcelFileDescriptor is owned by the caller, so it is their responsibility to close it when done. That is, the implementation of this method should create a new ParcelFileDescriptor for each call.

If opened with the exclusive "r" or "w" modes, the returned ParcelFileDescriptor can be a pipe or socket pair to enable streaming of data. Opening with the "rw" or "rwt" modes implies a file on disk that supports seeking.

If you need to detect when the returned ParcelFileDescriptor has been closed, or if the remote process has crashed or encountered some other error, you can use ParcelFileDescriptor.open(File, int,, ParcelFileDescriptor.createReliablePipe(), or ParcelFileDescriptor.createReliableSocketPair().

For use in Intents, you will want to implement getType to return the appropriate MIME type for the data returned here with the same URI. This will allow intent resolution to automatically determine the data MIME type and select the appropriate matching targets as part of its operation.

For better interoperability with other applications, it is recommended that for any URIs that can be opened, you also support queries on them containing at least the columns specified by android.provider.OpenableColumns. You may also want to support other common columns if you have additional meta-data to supply, such as android.provider.MediaStore.MediaColumns#DATE_ADDED in android.provider.MediaStore.MediaColumns.

openPipeHelper

open fun <T : Any!> openPipeHelper(
    uri: Uri, 
    mimeType: String, 
    opts: Bundle?, 
    args: T?, 
    func: ContentProvider.PipeDataWriter<T>
): ParcelFileDescriptor

A helper function for implementing #openTypedAssetFile, for creating a data pipe and background thread allowing you to stream generated data back to the client. This function returns a new ParcelFileDescriptor that should be returned to the caller (the caller is responsible for closing it).

openTypedAssetFile

open fun openTypedAssetFile(
    uri: Uri, 
    mimeTypeFilter: String, 
    opts: Bundle?
): AssetFileDescriptor?

Called by a client to open a read-only stream containing data of a particular MIME type. This is like openAssetFile(android.net.Uri,java.lang.String), except the file can only be read-only and the content provider may perform data conversions to generate data of the desired type.

The default implementation compares the given mimeType against the result of getType(android.net.Uri) and, if they match, simply calls openAssetFile(android.net.Uri,java.lang.String).

See ClipData for examples of the use and implementation of this method.

The returned AssetFileDescriptor can be a pipe or socket pair to enable streaming of data.

For better interoperability with other applications, it is recommended that for any URIs that can be opened, you also support queries on them containing at least the columns specified by android.provider.OpenableColumns. You may also want to support other common columns if you have additional meta-data to supply, such as android.provider.MediaStore.MediaColumns#DATE_ADDED in android.provider.MediaStore.MediaColumns.

openTypedAssetFile

open fun openTypedAssetFile(
    uri: Uri, 
    mimeTypeFilter: String, 
    opts: Bundle?, 
    signal: CancellationSignal?
): AssetFileDescriptor?

Called by a client to open a read-only stream containing data of a particular MIME type. This is like openAssetFile(android.net.Uri,java.lang.String), except the file can only be read-only and the content provider may perform data conversions to generate data of the desired type.

The default implementation compares the given mimeType against the result of getType(android.net.Uri) and, if they match, simply calls openAssetFile(android.net.Uri,java.lang.String).

See ClipData for examples of the use and implementation of this method.

The returned AssetFileDescriptor can be a pipe or socket pair to enable streaming of data.

For better interoperability with other applications, it is recommended that for any URIs that can be opened, you also support queries on them containing at least the columns specified by android.provider.OpenableColumns. You may also want to support other common columns if you have additional meta-data to supply, such as android.provider.MediaStore.MediaColumns#DATE_ADDED in android.provider.MediaStore.MediaColumns.

query

open fun query(
    uri: Uri, 
    projection: Array<String!>?, 
    queryArgs: Bundle?, 
    cancellationSignal: CancellationSignal?
): Cursor?

Implement this to handle query requests where the arguments are packed into a Bundle. Arguments may include traditional SQL style query arguments. When present these should be handled according to the contract established in query(android.net.Uri,java.lang.String[],java.lang.String,java.lang.String[],java.lang.String,android.os.CancellationSignal).

Traditional SQL arguments can be found in the bundle using the following keys:

// Request 20 records starting at row index 30.
 Bundle queryArgs = new Bundle();
 queryArgs.putInt(ContentResolver.QUERY_ARG_OFFSET, 30);
 queryArgs.putInt(ContentResolver.QUERY_ARG_LIMIT, 20);
 
 Cursor cursor = getContentResolver().query(
         contentUri,    // Content Uri is specific to individual content providers.
         projection,    // String[] describing which columns to return.
         queryArgs,     // Query arguments.
         null);         // Cancellation signal.

int recordsetSize = 0x1000;  // Actual value is implementation specific.
 queryArgs = queryArgs != null ? queryArgs : Bundle.EMPTY;  // ensure queryArgs is non-null
 
 int offset = queryArgs.getInt(ContentResolver.QUERY_ARG_OFFSET, 0);
 int limit = queryArgs.getInt(ContentResolver.QUERY_ARG_LIMIT, Integer.MIN_VALUE);
 
 MatrixCursor c = new MatrixCursor(PROJECTION, limit);
 
 // Calculate the number of items to include in the cursor.
 int numItems = MathUtils.constrain(recordsetSize - offset, 0, limit);
 
 // Build the paged result set....
 for (int i = offset; i < offset + numItems; i++) {
     // populate row from your data.
 }
 
 Bundle extras = new Bundle();
 c.setExtras(extras);
 
 // Any QUERY_ARG_* key may be included if honored.
 // In an actual implementation, include only keys that are both present in queryArgs
 // and reflected in the Cursor output. For example, if QUERY_ARG_OFFSET were included
 // in queryArgs, but was ignored because it contained an invalid value (like –273),
 // then QUERY_ARG_OFFSET should be omitted.
 extras.putStringArray(ContentResolver.EXTRA_HONORED_ARGS, new String[] {
     ContentResolver.QUERY_ARG_OFFSET,
     ContentResolver.QUERY_ARG_LIMIT
 });
 
 extras.putInt(ContentResolver.EXTRA_TOTAL_COUNT, recordsetSize);
 
 cursor.setNotificationUri(getContext().getContentResolver(), uri);
 
 return cursor;

query

abstract fun query(
    uri: Uri, 
    projection: Array<String!>?, 
    selection: String?, 
    selectionArgs: Array<String!>?, 
    sortOrder: String?
): Cursor?

Implement this to handle query requests from clients.

Apps targeting android.os.Build.VERSION_CODES#O or higher should override query(android.net.Uri,java.lang.String[],android.os.Bundle,android.os.CancellationSignal) and provide a stub implementation of this method.

This method can be called from multiple threads, as described in Processes and Threads.

Example client call:

// Request a specific record.
  Cursor managedCursor = managedQuery(
         ContentUris.withAppendedId(Contacts.People.CONTENT_URI, 2),
         projection,    // Which columns to return.
         null,          // WHERE clause.
         null,          // WHERE clause value substitution
         People.NAME + " ASC");   // Sort order.

// SQLiteQueryBuilder is a helper class that creates the
 // proper SQL syntax for us.
 SQLiteQueryBuilder qBuilder = new SQLiteQueryBuilder();
 
 // Guard against SQL injection attacks
 qBuilder.setStrict(true);
 qBuilder.setProjectionMap(MAP_OF_QUERYABLE_COLUMNS);
 qBuilder.setStrictColumns(true);
 qBuilder.setStrictGrammar(true);
 
 // Set the table we're querying.
 qBuilder.setTables(DATABASE_TABLE_NAME);
 
 // If the query ends in a specific record number, we're
 // being asked for a specific record, so set the
 // WHERE clause in our query.
 if((URI_MATCHER.match(uri)) == SPECIFIC_MESSAGE){
     qBuilder.appendWhere("_id=" + uri.getPathLeafId());
 }
 
 // Make the query.
 Cursor c = qBuilder.query(mDb,
         projection,
         selection,
         selectionArgs,
         groupBy,
         having,
         sortOrder);
 c.setNotificationUri(getContext().getContentResolver(), uri);
 return c;

query

open fun query(
    uri: Uri, 
    projection: Array<String!>?, 
    selection: String?, 
    selectionArgs: Array<String!>?, 
    sortOrder: String?, 
    cancellationSignal: CancellationSignal?
): Cursor?

Implement this to handle query requests from clients with support for cancellation.

Apps targeting android.os.Build.VERSION_CODES#O or higher should override query(android.net.Uri,java.lang.String[],android.os.Bundle,android.os.CancellationSignal) instead of this method.

This method can be called from multiple threads, as described in Processes and Threads.

Example client call:

// Request a specific record.
  Cursor managedCursor = managedQuery(
         ContentUris.withAppendedId(Contacts.People.CONTENT_URI, 2),
         projection,    // Which columns to return.
         null,          // WHERE clause.
         null,          // WHERE clause value substitution
         People.NAME + " ASC");   // Sort order.

// SQLiteQueryBuilder is a helper class that creates the
 // proper SQL syntax for us.
 SQLiteQueryBuilder qBuilder = new SQLiteQueryBuilder();
 
 // Guard against SQL injection attacks
 qBuilder.setStrict(true);
 qBuilder.setProjectionMap(MAP_OF_QUERYABLE_COLUMNS);
 qBuilder.setStrictColumns(true);
 qBuilder.setStrictGrammar(true);
 
 // Set the table we're querying.
 qBuilder.setTables(DATABASE_TABLE_NAME);
 
 // If the query ends in a specific record number, we're
 // being asked for a specific record, so set the
 // WHERE clause in our query.
 if((URI_MATCHER.match(uri)) == SPECIFIC_MESSAGE){
     qBuilder.appendWhere("_id=" + uri.getPathLeafId());
 }
 
 // Make the query.
 Cursor c = qBuilder.query(mDb,
         projection,
         selection,
         selectionArgs,
         groupBy,
         having,
         sortOrder);
 c.setNotificationUri(getContext().getContentResolver(), uri);
 return c;

If you implement this method then you must also implement the version of query(android.net.Uri,java.lang.String[],java.lang.String,java.lang.String[],java.lang.String) that does not take a cancellation signal to ensure correct operation on older versions of the Android Framework in which the cancellation signal overload was not available.

refresh

open fun refresh(
    uri: Uri!, 
    extras: Bundle?, 
    cancellationSignal: CancellationSignal?
): Boolean

Implement this to support refresh of content identified by uri. By default, this method returns false; providers who wish to implement this should return true to signal the client that the provider has tried refreshing with its own implementation.

This allows clients to request an explicit refresh of content identified by uri.

Client code should only invoke this method when there is a strong indication (such as a user initiated pull to refresh gesture) that the content is stale.

Remember to send ContentResolver.notifyChange(Uri, android.database.ContentObserver) notifications when content changes.

requireContext

fun requireContext(): Context

Retrieves a Non-Nullable Context this provider is running in, this is intended to be called after onCreate. When called before context was created, an IllegalStateException will be thrown.

Note A provider must be declared in the manifest and created automatically by the system, and context is only available after onCreate is called.

restoreCallingIdentity

fun restoreCallingIdentity(identity: ContentProvider.CallingIdentity): Unit

Restore the identity of the incoming IPC on the current thread back to a previously identity that was returned by clearCallingIdentity.

Internally this calls Binder.restoreCallingIdentity(long) and also restores any value stored in getCallingPackage().

shutdown

open fun shutdown(): Unit

Implement this to shut down the ContentProvider instance. You can then invoke this method in unit tests.

Android normally handles ContentProvider startup and shutdown automatically. You do not need to start up or shut down a ContentProvider. When you invoke a test method on a ContentProvider, however, a ContentProvider instance is started and keeps running after the test finishes, even if a succeeding test instantiates another ContentProvider. A conflict develops because the two instances are usually running against the same underlying data source (for example, an sqlite database).

Implementing shutDown() avoids this conflict by providing a way to terminate the ContentProvider. This method can also prevent memory leaks from multiple instantiations of the ContentProvider, and it can ensure unit test isolation by allowing you to completely clean up the test fixture before moving on to the next test.

uncanonicalize

open fun uncanonicalize(url: Uri): Uri?

Remove canonicalization from canonical URIs previously returned by canonicalize. For example, if your implementation is to add a query param to canonicalize a URI, this method can simply trip any query params on the URI. The default implementation always returns the same url that was passed in.

update

open fun update(
    uri: Uri, 
    values: ContentValues?, 
    extras: Bundle?
): Int

Implement this to handle requests to update one or more rows. The implementation should update all rows matching the selection to set the columns according to the provided values map. As a courtesy, call notifyChange() after updating. This method can be called from multiple threads, as described in Processes and Threads.

update

abstract fun update(
    uri: Uri, 
    values: ContentValues?, 
    selection: String?, 
    selectionArgs: Array<String!>?
): Int

Implement this to handle requests to update one or more rows. The implementation should update all rows matching the selection to set the columns according to the provided values map. As a courtesy, call notifyChange() after updating. This method can be called from multiple threads, as described in Processes and Threads.

isTemporary

protected open fun isTemporary(): Boolean

Returns true if this instance is a temporary content provider.

openFileHelper

protected fun openFileHelper(
    uri: Uri, 
    mode: String
): ParcelFileDescriptor

Convenience for subclasses that wish to implement #openFile by looking up a column named "_data" at the given URI.

setPathPermissions

protected fun setPathPermissions(permissions: Array<PathPermission!>?): Unit

Change the path-based permission required to read and/or write data in the content provider. This is normally set for you from its manifest information when the provider is first created.

setReadPermission

protected fun setReadPermission(permission: String?): Unit

Change the permission required to read data from the content provider. This is normally set for you from its manifest information when the provider is first created.

setWritePermission

protected fun setWritePermission(permission: String?): Unit

Change the permission required to read and write data in the content provider. This is normally set for you from its manifest information when the provider is first created.