IT. Expert System.

Android Reference

ContentProvider


android.content

Class ContentProvider

    • Constructor Detail

      • ContentProvider

        public 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.

      • ContentProvider

        public ContentProvider(Context context,
               String readPermission,
               String writePermission,
               PathPermission[] pathPermissions)
        Constructor just for mocking.
        Parameters:
        context - A Context object which should be some mock instance (like the instance of MockContext).
        readPermission - The read permision you want this instance should have in the test, which is available via getReadPermission().
        writePermission - The write permission you want this instance should have in the test, which is available via getWritePermission().
        pathPermissions - The PathPermissions you want this instance should have in the test, which is available via getPathPermissions().

    • Method Detail

      • coerceToLocalContentProvider

        public static ContentProvider coerceToLocalContentProvider(IContentProvider abstractInterface)
        Given an IContentProvider, try to coerce it back to the real ContentProvider object if it is running in the local process. This can be used if you know you are running in the same process as a provider, and want to get direct access to its implementation details. Most clients should not nor have a reason to use it.
        Parameters:
        abstractInterface - The ContentProvider interface that is to be coerced.
        Returns:
        If the IContentProvider is non-null and local, returns its actual ContentProvider instance. Otherwise returns null.

      • getContext

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

      • setReadPermission

        protected final void setReadPermission(String permission)
        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.
        Parameters:
        permission - Name of the permission required for read-only access.

      • getReadPermission

        public final String getReadPermission()
        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.

      • setWritePermission

        protected final void setWritePermission(String permission)
        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.
        Parameters:
        permission - Name of the permission required for read/write access.

      • getWritePermission

        public final String getWritePermission()
        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.

      • setPathPermissions

        protected final void setPathPermissions(PathPermission[] permissions)
        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.
        Parameters:
        permissions - Array of path permission descriptions.

      • getPathPermissions

        public final PathPermission[] getPathPermissions()
        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.

      • onConfigurationChanged

        public void onConfigurationChanged(Configuration newConfig)
        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. 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.)

        Specified by:
        onConfigurationChanged in interface ComponentCallbacks
        Parameters:
        newConfig - The new device configuration.

      • onLowMemory

        public void onLowMemory()
        This is called when the overall system is running low on memory, and would like actively running process to try to tighten their belt. While the exact point at which this will be called is not defined, generally it will happen around the time 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.

        Applications that want to be nice can implement this method to release any caches or other unnecessary resources they may be holding on to. The system will perform a gc for you after returning from this method. 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.

        Specified by:
        onLowMemory in interface ComponentCallbacks

      • query

        public abstract Cursor query(Uri uri,
           String[] projection,
           String selection,
           String[] selectionArgs,
           String sortOrder)
        Implement this to handle query requests from clients. 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.
        Example implementation:

        // SQLiteQueryBuilder is a helper class that creates the
        // proper SQL syntax for us.
        SQLiteQueryBuilder qBuilder = new SQLiteQueryBuilder();

        // 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;
        Parameters:
        uri - The URI to query. This will be the full URI sent by the client; if the client is requesting a specific record, the URI will end in a record number that the implementation should parse and add to a WHERE or HAVING clause, specifying that _id value.
        projection - The list of columns to put into the cursor. If null all columns are included.
        selection - A selection criteria to apply when filtering rows. If null then all rows are included.
        selectionArgs - You may include ?s in selection, which will be replaced by the values from selectionArgs, in order that they appear in the selection. The values will be bound as Strings.
        sortOrder - How the rows in the cursor should be sorted. If null then the provider is free to define the sort order.
        Returns:
        a Cursor or null.

      • query

        public Cursor query(Uri uri,
           String[] projection,
           String selection,
           String[] selectionArgs,
           String sortOrder,
           CancellationSignal cancellationSignal)
        Implement this to handle query requests from clients with support for cancellation. 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.
        Example implementation:

        // SQLiteQueryBuilder is a helper class that creates the
        // proper SQL syntax for us.
        SQLiteQueryBuilder qBuilder = new SQLiteQueryBuilder();

        // 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(Uri, String[], String, String[], 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.

        Parameters:
        uri - The URI to query. This will be the full URI sent by the client; if the client is requesting a specific record, the URI will end in a record number that the implementation should parse and add to a WHERE or HAVING clause, specifying that _id value.
        projection - The list of columns to put into the cursor. If null all columns are included.
        selection - A selection criteria to apply when filtering rows. If null then all rows are included.
        selectionArgs - You may include ?s in selection, which will be replaced by the values from selectionArgs, in order that they appear in the selection. The values will be bound as Strings.
        sortOrder - How the rows in the cursor should be sorted. If null then the provider is free to define the sort order.
        cancellationSignal - A signal to cancel the operation in progress, or null if none. If the operation is canceled, then OperationCanceledException will be thrown when the query is executed.
        Returns:
        a Cursor or null.

      • getType

        public abstract String getType(Uri uri)
        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 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. This allows them to retrieve the MIME type for a URI when dispatching intents.

        Parameters:
        uri - the URI to query.
        Returns:
        a MIME type string, or null if there is no type.

      • insert

        public abstract Uri insert(Uri uri,
         ContentValues values)
        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.
        Parameters:
        uri - The content:// URI of the insertion request.
        values - A set of column_name/value pairs to add to the database.
        Returns:
        The URI for the newly inserted item.

      • bulkInsert

        public int bulkInsert(Uri uri,
             ContentValues[] values)
        Override this to handle requests to insert a set of new rows, or the default implementation will iterate over the values and call insert(android.net.Uri, android.content.ContentValues) 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.
        Parameters:
        uri - The content:// URI of the insertion request.
        values - An array of sets of column_name/value pairs to add to the database.
        Returns:
        The number of values that were inserted.

      • delete

        public abstract int delete(Uri uri,
         String selection,
         String[] selectionArgs)
        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 notifyDelete() 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.

        Parameters:
        uri - The full URI to query, including a row ID (if a specific record is requested).
        selection - An optional restriction to apply to rows when deleting.
        Returns:
        The number of rows affected.
        Throws:
        SQLException

      • update

        public abstract int update(Uri uri,
         ContentValues values,
         String selection,
         String[] selectionArgs)
        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.
        Parameters:
        uri - The URI to query. This can potentially have a record ID if this is an update request for a specific record.
        values - A Bundle mapping from column names to new column values (NULL is a valid value).
        selection - An optional filter to match rows to update.
        Returns:
        the number of rows affected.

      • openFile

        public ParcelFileDescriptor openFile(Uri uri,
                            String mode)
                              throws FileNotFoundException
        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.

        Parameters:
        uri - The URI whose file is to be opened.
        mode - Access mode for the file. May be "r" for read-only access, "rw" for read and write access, or "rwt" for read and write access that truncates any existing file.
        Returns:
        Returns a new ParcelFileDescriptor which you can use to access the file.
        Throws:
        FileNotFoundException - Throws FileNotFoundException if there is no file associated with the given URI or the mode is invalid.
        SecurityException - Throws SecurityException if the caller does not have permission to access the file.
        See Also:
        openAssetFile(Uri, String), openFileHelper(Uri, String)

      • openFileHelper

        protected final ParcelFileDescriptor openFileHelper(Uri uri,
                                  String mode)
                                             throws FileNotFoundException
        Convenience for subclasses that wish to implement openFile(android.net.Uri, java.lang.String) by looking up a column named "_data" at the given URI.
        Parameters:
        uri - The URI to be opened.
        mode - The file mode. May be "r" for read-only access, "w" for write-only access (erasing whatever data is currently in the file), "wa" for write-only access to append to any existing data, "rw" for read and write access on any existing data, and "rwt" for read and write access that truncates any existing file.
        Returns:
        Returns a new ParcelFileDescriptor that can be used by the client to access the file.
        Throws:
        FileNotFoundException

      • getStreamTypes

        public String[] getStreamTypes(Uri uri,
                      String mimeTypeFilter)
        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.
        Parameters:
        uri - The data in the content provider being queried.
        mimeTypeFilter - The type of data the client desires. May be a pattern, such as *\/* to retrieve all possible data types.
        Returns:
        Returns null if there are no possible data streams for the given mimeTypeFilter. Otherwise returns an array of all available concrete MIME types.
        See Also:
        getType(Uri), openTypedAssetFile(Uri, String, Bundle), ClipDescription.compareMimeTypes(String, String)

      • openTypedAssetFile

        public AssetFileDescriptor openTypedAssetFile(Uri uri,
                                     String mimeTypeFilter,
                                     Bundle opts)
                                       throws FileNotFoundException
        Called by a client to open a read-only stream containing data of a particular MIME type. This is like openAssetFile(Uri, 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(Uri) and, if the match, simple calls openAssetFile(Uri, String).

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

        Parameters:
        uri - The data in the content provider being queried.
        mimeTypeFilter - The type of data the client desires. May be a pattern, such as *\/*, if the caller does not have specific type requirements; in this case the content provider will pick its best type matching the pattern.
        opts - Additional options from the client. The definitions of these are specific to the content provider being called.
        Returns:
        Returns a new AssetFileDescriptor from which the client can read data of the desired type.
        Throws:
        FileNotFoundException - Throws FileNotFoundException if there is no file associated with the given URI or the mode is invalid.
        SecurityException - Throws SecurityException if the caller does not have permission to access the data.
        IllegalArgumentException - Throws IllegalArgumentException if the content provider does not support the requested MIME type.
        See Also:
        getStreamTypes(Uri, String), openAssetFile(Uri, String), ClipDescription.compareMimeTypes(String, String)

      • openPipeHelper

        public <T> ParcelFileDescriptor openPipeHelper(Uri uri,
                                      String mimeType,
                                      Bundle opts,
                                      T args,
                                      ContentProvider.PipeDataWriter<T> func)
                                    throws FileNotFoundException
        A helper function for implementing openTypedAssetFile(android.net.Uri, java.lang.String, android.os.Bundle), 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).
        Parameters:
        uri - The URI whose data is to be written.
        mimeType - The desired type of data to be written.
        opts - Options supplied by caller.
        args - Your own custom arguments.
        func - Interface implementing the function that will actually stream the data.
        Returns:
        Returns a new ParcelFileDescriptor holding the read side of the pipe. This should be returned to the caller for reading; the caller is responsible for closing it when done.
        Throws:
        FileNotFoundException

      • isTemporary

        protected boolean isTemporary()
        Returns true if this instance is a temporary content provider.
        Returns:
        true if this instance is a temporary content provider

      • getIContentProvider

        public IContentProvider getIContentProvider()
        Returns the Binder object for this provider.
        Returns:
        the Binder object for this provider

      • attachInfo

        public void attachInfo(Context context,
              ProviderInfo info)
        After being instantiated, this is called to tell the content provider about itself.
        Parameters:
        context - The context this provider is running in
        info - Registered information about this content provider

      • call

        public Bundle call(String method,
          String arg,
          Bundle extras)
        Call a provider-defined method. This can be used to implement interfaces that are cheaper and/or unnatural for a table-like model.
        Parameters:
        method - method name to call. Opaque to framework, but should not be null.
        arg - provider-defined String argument. May be null.
        extras - provider-defined Bundle argument. May be null.
        Returns:
        provider-defined return value. May be null. Null is also the default for providers which don't implement any call methods.

      • shutdown

        public void shutdown()
        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.

      • dump

        public void dump(FileDescriptor fd,
        PrintWriter writer,
        String[] args)
        Print the Provider's state into the given stream. This gets invoked if you run "adb shell dumpsys activity provider <provider_component_name>".
        Parameters:
        prefix - Desired prefix to prepend at each line of output.
        fd - The raw file descriptor that the dump is being sent to.
        writer - The PrintWriter to which you should dump your state. This will be closed for you after you return.
        args - additional arguments to the dump request.


Content

Android Reference

Java basics

Java Enterprise Edition (EE)

Java Standard Edition (SE)

SQL

HTML

PHP

CSS

Java Script

MYSQL

JQUERY

VBS

REGEX

C

C++

C#

Design patterns

RFC (standard status)

RFC (proposed standard status)

RFC (draft standard status)

RFC (informational status)

RFC (experimental status)

RFC (best current practice status)

RFC (historic status)

RFC (unknown status)

IT dictionary

License.
All information of this service is derived from the free sources and is provided solely in the form of quotations. This service provides information and interfaces solely for the familiarization (not ownership) and under the "as is" condition.
Copyright 2016 © ELTASK.COM. All rights reserved.
Site is optimized for mobile devices.
Downloads: 166 / . Delta: 0.04284 с