/* * Copyright (C) 2006 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package android.content; import android.accounts.Account; import android.app.ActivityManagerNative; import android.app.ActivityThread; import android.app.AppGlobals; import android.content.pm.PackageManager.NameNotFoundException; import android.content.res.AssetFileDescriptor; import android.content.res.Resources; import android.database.ContentObserver; import android.database.Cursor; import android.database.CursorWrapper; import android.database.IContentObserver; import android.net.Uri; import android.os.Bundle; import android.os.IBinder; import android.os.ParcelFileDescriptor; import android.os.RemoteException; import android.os.ServiceManager; import android.os.SystemClock; import android.text.TextUtils; import android.util.Config; import android.util.EventLog; import android.util.Log; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.util.List; import java.util.Random; import java.util.ArrayList; /** * This class provides applications access to the content model. */ public abstract class ContentResolver { /** * @deprecated instead use * {@link #requestSync(android.accounts.Account, String, android.os.Bundle)} */ @Deprecated public static final String SYNC_EXTRAS_ACCOUNT = "account"; public static final String SYNC_EXTRAS_EXPEDITED = "expedited"; /** * @deprecated instead use * {@link #SYNC_EXTRAS_MANUAL} */ @Deprecated public static final String SYNC_EXTRAS_FORCE = "force"; /** * If this extra is set to true then the sync settings (like getSyncAutomatically()) * are ignored by the sync scheduler. */ public static final String SYNC_EXTRAS_IGNORE_SETTINGS = "ignore_settings"; /** * If this extra is set to true then any backoffs for the initial attempt (e.g. due to retries) * are ignored by the sync scheduler. If this request fails and gets rescheduled then the * retries will still honor the backoff. */ public static final String SYNC_EXTRAS_IGNORE_BACKOFF = "ignore_backoff"; /** * If this extra is set to true then the request will not be retried if it fails. */ public static final String SYNC_EXTRAS_DO_NOT_RETRY = "do_not_retry"; /** * Setting this extra is the equivalent of setting both {@link #SYNC_EXTRAS_IGNORE_SETTINGS} * and {@link #SYNC_EXTRAS_IGNORE_BACKOFF} */ public static final String SYNC_EXTRAS_MANUAL = "force"; public static final String SYNC_EXTRAS_UPLOAD = "upload"; public static final String SYNC_EXTRAS_OVERRIDE_TOO_MANY_DELETIONS = "deletions_override"; public static final String SYNC_EXTRAS_DISCARD_LOCAL_DELETIONS = "discard_deletions"; /** * Set by the SyncManager to request that the SyncAdapter initialize itself for * the given account/authority pair. One required initialization step is to * ensure that {@link #setIsSyncable(android.accounts.Account, String, int)} has been * called with a >= 0 value. When this flag is set the SyncAdapter does not need to * do a full sync, though it is allowed to do so. */ public static final String SYNC_EXTRAS_INITIALIZE = "initialize"; public static final String SCHEME_CONTENT = "content"; public static final String SCHEME_ANDROID_RESOURCE = "android.resource"; public static final String SCHEME_FILE = "file"; /** * This is the Android platform's base MIME type for a content: URI * containing a Cursor of a single item. Applications should use this * as the base type along with their own sub-type of their content: URIs * that represent a particular item. For example, hypothetical IMAP email * client may have a URI * content://com.company.provider.imap/inbox/1 for a particular * message in the inbox, whose MIME type would be reported as * CURSOR_ITEM_BASE_TYPE + "/vnd.company.imap-msg" * *

Compare with {@link #CURSOR_DIR_BASE_TYPE}. */ public static final String CURSOR_ITEM_BASE_TYPE = "vnd.android.cursor.item"; /** * This is the Android platform's base MIME type for a content: URI * containing a Cursor of zero or more items. Applications should use this * as the base type along with their own sub-type of their content: URIs * that represent a directory of items. For example, hypothetical IMAP email * client may have a URI * content://com.company.provider.imap/inbox for all of the * messages in its inbox, whose MIME type would be reported as * CURSOR_DIR_BASE_TYPE + "/vnd.company.imap-msg" * *

Note how the base MIME type varies between this and * {@link #CURSOR_ITEM_BASE_TYPE} depending on whether there is * one single item or multiple items in the data set, while the sub-type * remains the same because in either case the data structure contained * in the cursor is the same. */ public static final String CURSOR_DIR_BASE_TYPE = "vnd.android.cursor.dir"; /** @hide */ public static final int SYNC_ERROR_SYNC_ALREADY_IN_PROGRESS = 1; /** @hide */ public static final int SYNC_ERROR_AUTHENTICATION = 2; /** @hide */ public static final int SYNC_ERROR_IO = 3; /** @hide */ public static final int SYNC_ERROR_PARSE = 4; /** @hide */ public static final int SYNC_ERROR_CONFLICT = 5; /** @hide */ public static final int SYNC_ERROR_TOO_MANY_DELETIONS = 6; /** @hide */ public static final int SYNC_ERROR_TOO_MANY_RETRIES = 7; /** @hide */ public static final int SYNC_ERROR_INTERNAL = 8; public static final int SYNC_OBSERVER_TYPE_SETTINGS = 1<<0; public static final int SYNC_OBSERVER_TYPE_PENDING = 1<<1; public static final int SYNC_OBSERVER_TYPE_ACTIVE = 1<<2; /** @hide */ public static final int SYNC_OBSERVER_TYPE_STATUS = 1<<3; /** @hide */ public static final int SYNC_OBSERVER_TYPE_ALL = 0x7fffffff; // Always log queries which take 500ms+; shorter queries are // sampled accordingly. private static final int SLOW_THRESHOLD_MILLIS = 500; private final Random mRandom = new Random(); // guarded by itself public ContentResolver(Context context) { mContext = context; } /** @hide */ protected abstract IContentProvider acquireProvider(Context c, String name); /** Providing a default implementation of this, to avoid having to change * a lot of other things, but implementations of ContentResolver should * implement it. @hide */ protected IContentProvider acquireExistingProvider(Context c, String name) { return acquireProvider(c, name); } /** @hide */ public abstract boolean releaseProvider(IContentProvider icp); /** * Return the MIME type of the given content URL. * * @param url A Uri identifying content (either a list or specific type), * using the content:// scheme. * @return A MIME type for the content, or null if the URL is invalid or the type is unknown */ public final String getType(Uri url) { IContentProvider provider = acquireExistingProvider(url); if (provider != null) { try { return provider.getType(url); } catch (RemoteException e) { return null; } catch (java.lang.Exception e) { return null; } finally { releaseProvider(provider); } } if (!SCHEME_CONTENT.equals(url.getScheme())) { return null; } try { String type = ActivityManagerNative.getDefault().getProviderMimeType(url); return type; } catch (RemoteException e) { return null; } } /** *

* Query the given URI, returning a {@link Cursor} over the result set. *

*

* For best performance, the caller should follow these guidelines: *

*

* * @param uri The URI, using the content:// scheme, for the content to * retrieve. * @param projection A list of which columns to return. Passing null will * return all columns, which is inefficient. * @param selection A filter declaring which rows to return, formatted as an * SQL WHERE clause (excluding the WHERE itself). Passing null will * return all rows for the given URI. * @param selectionArgs You may include ?s in selection, which will be * replaced by the values from selectionArgs, in the order that they * appear in the selection. The values will be bound as Strings. * @param sortOrder How to order the rows, formatted as an SQL ORDER BY * clause (excluding the ORDER BY itself). Passing null will use the * default sort order, which may be unordered. * @return A Cursor object, which is positioned before the first entry, or null * @see Cursor */ public final Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) { IContentProvider provider = acquireProvider(uri); if (provider == null) { return null; } try { long startTime = SystemClock.uptimeMillis(); Cursor qCursor = provider.query(uri, projection, selection, selectionArgs, sortOrder); if (qCursor == null) { releaseProvider(provider); return null; } // force query execution qCursor.getCount(); long durationMillis = SystemClock.uptimeMillis() - startTime; maybeLogQueryToEventLog(durationMillis, uri, projection, selection, sortOrder); // Wrap the cursor object into CursorWrapperInner object return new CursorWrapperInner(qCursor, provider); } catch (RemoteException e) { releaseProvider(provider); return null; } catch(RuntimeException e) { releaseProvider(provider); throw e; } } /** * Open a stream on to the content associated with a content URI. If there * is no data associated with the URI, FileNotFoundException is thrown. * *
Accepts the following URI schemes:
* * *

See {@link #openAssetFileDescriptor(Uri, String)} for more information * on these schemes. * * @param uri The desired URI. * @return InputStream * @throws FileNotFoundException if the provided URI could not be opened. * @see #openAssetFileDescriptor(Uri, String) */ public final InputStream openInputStream(Uri uri) throws FileNotFoundException { String scheme = uri.getScheme(); if (SCHEME_ANDROID_RESOURCE.equals(scheme)) { // Note: left here to avoid breaking compatibility. May be removed // with sufficient testing. OpenResourceIdResult r = getResourceId(uri); try { InputStream stream = r.r.openRawResource(r.id); return stream; } catch (Resources.NotFoundException ex) { throw new FileNotFoundException("Resource does not exist: " + uri); } } else if (SCHEME_FILE.equals(scheme)) { // Note: left here to avoid breaking compatibility. May be removed // with sufficient testing. return new FileInputStream(uri.getPath()); } else { AssetFileDescriptor fd = openAssetFileDescriptor(uri, "r"); try { return fd != null ? fd.createInputStream() : null; } catch (IOException e) { throw new FileNotFoundException("Unable to create stream"); } } } /** * Synonym for {@link #openOutputStream(Uri, String) * openOutputStream(uri, "w")}. * @throws FileNotFoundException if the provided URI could not be opened. */ public final OutputStream openOutputStream(Uri uri) throws FileNotFoundException { return openOutputStream(uri, "w"); } /** * Open a stream on to the content associated with a content URI. If there * is no data associated with the URI, FileNotFoundException is thrown. * *

Accepts the following URI schemes:
* * *

See {@link #openAssetFileDescriptor(Uri, String)} for more information * on these schemes. * * @param uri The desired URI. * @param mode May be "w", "wa", "rw", or "rwt". * @return OutputStream * @throws FileNotFoundException if the provided URI could not be opened. * @see #openAssetFileDescriptor(Uri, String) */ public final OutputStream openOutputStream(Uri uri, String mode) throws FileNotFoundException { AssetFileDescriptor fd = openAssetFileDescriptor(uri, mode); try { return fd != null ? fd.createOutputStream() : null; } catch (IOException e) { throw new FileNotFoundException("Unable to create stream"); } } /** * Open a raw file descriptor to access data under a "content:" URI. This * is like {@link #openAssetFileDescriptor(Uri, String)}, but uses the * underlying {@link ContentProvider#openFile} * ContentProvider.openFile()} method, so will not work with * providers that return sub-sections of files. If at all possible, * you should use {@link #openAssetFileDescriptor(Uri, String)}. You * will receive a FileNotFoundException exception if the provider returns a * sub-section of a file. * *

Accepts the following URI schemes:
* * *

See {@link #openAssetFileDescriptor(Uri, String)} for more information * on these schemes. * * @param uri The desired URI to open. * @param mode The file mode to use, as per {@link ContentProvider#openFile * ContentProvider.openFile}. * @return Returns a new ParcelFileDescriptor pointing to the file. You * own this descriptor and are responsible for closing it when done. * @throws FileNotFoundException Throws FileNotFoundException of no * file exists under the URI or the mode is invalid. * @see #openAssetFileDescriptor(Uri, String) */ public final ParcelFileDescriptor openFileDescriptor(Uri uri, String mode) throws FileNotFoundException { AssetFileDescriptor afd = openAssetFileDescriptor(uri, mode); if (afd == null) { return null; } if (afd.getDeclaredLength() < 0) { // This is a full file! return afd.getParcelFileDescriptor(); } // Client can't handle a sub-section of a file, so close what // we got and bail with an exception. try { afd.close(); } catch (IOException e) { } throw new FileNotFoundException("Not a whole file"); } /** * Open a raw file descriptor to access data under a "content:" URI. This * interacts with the underlying {@link ContentProvider#openAssetFile} * ContentProvider.openAssetFile()} method of the provider associated with the * given URI, to retrieve any file stored there. * *

Accepts the following URI schemes:
* *
The android.resource ({@link #SCHEME_ANDROID_RESOURCE}) Scheme
*

* A Uri object can be used to reference a resource in an APK file. The * Uri should be one of the following formats: *

* * @param uri The desired URI to open. * @param mode The file mode to use, as per {@link ContentProvider#openAssetFile * ContentProvider.openAssetFile}. * @return Returns a new ParcelFileDescriptor pointing to the file. You * own this descriptor and are responsible for closing it when done. * @throws FileNotFoundException Throws FileNotFoundException of no * file exists under the URI or the mode is invalid. */ public final AssetFileDescriptor openAssetFileDescriptor(Uri uri, String mode) throws FileNotFoundException { String scheme = uri.getScheme(); if (SCHEME_ANDROID_RESOURCE.equals(scheme)) { if (!"r".equals(mode)) { throw new FileNotFoundException("Can't write resources: " + uri); } OpenResourceIdResult r = getResourceId(uri); try { return r.r.openRawResourceFd(r.id); } catch (Resources.NotFoundException ex) { throw new FileNotFoundException("Resource does not exist: " + uri); } } else if (SCHEME_FILE.equals(scheme)) { ParcelFileDescriptor pfd = ParcelFileDescriptor.open( new File(uri.getPath()), modeToMode(uri, mode)); return new AssetFileDescriptor(pfd, 0, -1); } else { IContentProvider provider = acquireProvider(uri); if (provider == null) { throw new FileNotFoundException("No content provider: " + uri); } try { AssetFileDescriptor fd = provider.openAssetFile(uri, mode); if(fd == null) { releaseProvider(provider); return null; } ParcelFileDescriptor pfd = new ParcelFileDescriptorInner( fd.getParcelFileDescriptor(), provider); return new AssetFileDescriptor(pfd, fd.getStartOffset(), fd.getDeclaredLength()); } catch (RemoteException e) { releaseProvider(provider); throw new FileNotFoundException("Dead content provider: " + uri); } catch (FileNotFoundException e) { releaseProvider(provider); throw e; } catch (RuntimeException e) { releaseProvider(provider); throw e; } } } /** * A resource identified by the {@link Resources} that contains it, and a resource id. * * @hide */ public class OpenResourceIdResult { public Resources r; public int id; } /** * Resolves an android.resource URI to a {@link Resources} and a resource id. * * @hide */ public OpenResourceIdResult getResourceId(Uri uri) throws FileNotFoundException { String authority = uri.getAuthority(); Resources r; if (TextUtils.isEmpty(authority)) { throw new FileNotFoundException("No authority: " + uri); } else { try { r = mContext.getPackageManager().getResourcesForApplication(authority); } catch (NameNotFoundException ex) { throw new FileNotFoundException("No package found for authority: " + uri); } } List path = uri.getPathSegments(); if (path == null) { throw new FileNotFoundException("No path: " + uri); } int len = path.size(); int id; if (len == 1) { try { id = Integer.parseInt(path.get(0)); } catch (NumberFormatException e) { throw new FileNotFoundException("Single path segment is not a resource ID: " + uri); } } else if (len == 2) { id = r.getIdentifier(path.get(1), path.get(0), authority); } else { throw new FileNotFoundException("More than two path segments: " + uri); } if (id == 0) { throw new FileNotFoundException("No resource found for: " + uri); } OpenResourceIdResult res = new OpenResourceIdResult(); res.r = r; res.id = id; return res; } /** @hide */ static public int modeToMode(Uri uri, String mode) throws FileNotFoundException { int modeBits; if ("r".equals(mode)) { modeBits = ParcelFileDescriptor.MODE_READ_ONLY; } else if ("w".equals(mode) || "wt".equals(mode)) { modeBits = ParcelFileDescriptor.MODE_WRITE_ONLY | ParcelFileDescriptor.MODE_CREATE | ParcelFileDescriptor.MODE_TRUNCATE; } else if ("wa".equals(mode)) { modeBits = ParcelFileDescriptor.MODE_WRITE_ONLY | ParcelFileDescriptor.MODE_CREATE | ParcelFileDescriptor.MODE_APPEND; } else if ("rw".equals(mode)) { modeBits = ParcelFileDescriptor.MODE_READ_WRITE | ParcelFileDescriptor.MODE_CREATE; } else if ("rwt".equals(mode)) { modeBits = ParcelFileDescriptor.MODE_READ_WRITE | ParcelFileDescriptor.MODE_CREATE | ParcelFileDescriptor.MODE_TRUNCATE; } else { throw new FileNotFoundException("Bad mode for " + uri + ": " + mode); } return modeBits; } /** * Inserts a row into a table at the given URL. * * If the content provider supports transactions the insertion will be atomic. * * @param url The URL of the table to insert into. * @param values The initial values for the newly inserted row. The key is the column name for * the field. Passing an empty ContentValues will create an empty row. * @return the URL of the newly created row. */ public final Uri insert(Uri url, ContentValues values) { IContentProvider provider = acquireProvider(url); if (provider == null) { throw new IllegalArgumentException("Unknown URL " + url); } try { long startTime = SystemClock.uptimeMillis(); Uri createdRow = provider.insert(url, values); long durationMillis = SystemClock.uptimeMillis() - startTime; maybeLogUpdateToEventLog(durationMillis, url, "insert", null /* where */); return createdRow; } catch (RemoteException e) { return null; } finally { releaseProvider(provider); } } /** * Applies each of the {@link ContentProviderOperation} objects and returns an array * of their results. Passes through OperationApplicationException, which may be thrown * by the call to {@link ContentProviderOperation#apply}. * If all the applications succeed then a {@link ContentProviderResult} array with the * same number of elements as the operations will be returned. It is implementation-specific * how many, if any, operations will have been successfully applied if a call to * apply results in a {@link OperationApplicationException}. * @param authority the authority of the ContentProvider to which this batch should be applied * @param operations the operations to apply * @return the results of the applications * @throws OperationApplicationException thrown if an application fails. * See {@link ContentProviderOperation#apply} for more information. * @throws RemoteException thrown if a RemoteException is encountered while attempting * to communicate with a remote provider. */ public ContentProviderResult[] applyBatch(String authority, ArrayList operations) throws RemoteException, OperationApplicationException { ContentProviderClient provider = acquireContentProviderClient(authority); if (provider == null) { throw new IllegalArgumentException("Unknown authority " + authority); } try { return provider.applyBatch(operations); } finally { provider.release(); } } /** * Inserts multiple rows into a table at the given URL. * * This function make no guarantees about the atomicity of the insertions. * * @param url The URL of the table to insert into. * @param values The initial values for the newly inserted rows. The key is the column name for * the field. Passing null will create an empty row. * @return the number of newly created rows. */ public final int bulkInsert(Uri url, ContentValues[] values) { IContentProvider provider = acquireProvider(url); if (provider == null) { throw new IllegalArgumentException("Unknown URL " + url); } try { long startTime = SystemClock.uptimeMillis(); int rowsCreated = provider.bulkInsert(url, values); long durationMillis = SystemClock.uptimeMillis() - startTime; maybeLogUpdateToEventLog(durationMillis, url, "bulkinsert", null /* where */); return rowsCreated; } catch (RemoteException e) { return 0; } finally { releaseProvider(provider); } } /** * Deletes row(s) specified by a content URI. * * If the content provider supports transactions, the deletion will be atomic. * * @param url The URL of the row to delete. * @param where A filter to apply to rows before deleting, formatted as an SQL WHERE clause (excluding the WHERE itself). * @return The number of rows deleted. */ public final int delete(Uri url, String where, String[] selectionArgs) { IContentProvider provider = acquireProvider(url); if (provider == null) { throw new IllegalArgumentException("Unknown URL " + url); } try { long startTime = SystemClock.uptimeMillis(); int rowsDeleted = provider.delete(url, where, selectionArgs); long durationMillis = SystemClock.uptimeMillis() - startTime; maybeLogUpdateToEventLog(durationMillis, url, "delete", where); return rowsDeleted; } catch (RemoteException e) { return -1; } finally { releaseProvider(provider); } } /** * Update row(s) in a content URI. * * If the content provider supports transactions the update will be atomic. * * @param uri The URI to modify. * @param values The new field values. The key is the column name for the field. A null value will remove an existing field value. * @param where A filter to apply to rows before updating, formatted as an SQL WHERE clause (excluding the WHERE itself). * @return The number of rows updated. * @throws NullPointerException if uri or values are null */ public final int update(Uri uri, ContentValues values, String where, String[] selectionArgs) { IContentProvider provider = acquireProvider(uri); if (provider == null) { throw new IllegalArgumentException("Unknown URI " + uri); } try { long startTime = SystemClock.uptimeMillis(); int rowsUpdated = provider.update(uri, values, where, selectionArgs); long durationMillis = SystemClock.uptimeMillis() - startTime; maybeLogUpdateToEventLog(durationMillis, uri, "update", where); return rowsUpdated; } catch (RemoteException e) { return -1; } finally { releaseProvider(provider); } } /** * Returns the content provider for the given content URI. * * @param uri The URI to a content provider * @return The ContentProvider for the given URI, or null if no content provider is found. * @hide */ public final IContentProvider acquireProvider(Uri uri) { if (!SCHEME_CONTENT.equals(uri.getScheme())) { return null; } String auth = uri.getAuthority(); if (auth != null) { return acquireProvider(mContext, uri.getAuthority()); } return null; } /** * Returns the content provider for the given content URI if the process * already has a reference on it. * * @param uri The URI to a content provider * @return The ContentProvider for the given URI, or null if no content provider is found. * @hide */ public final IContentProvider acquireExistingProvider(Uri uri) { if (!SCHEME_CONTENT.equals(uri.getScheme())) { return null; } String auth = uri.getAuthority(); if (auth != null) { return acquireExistingProvider(mContext, uri.getAuthority()); } return null; } /** * @hide */ public final IContentProvider acquireProvider(String name) { if (name == null) { return null; } return acquireProvider(mContext, name); } /** * Returns a {@link ContentProviderClient} that is associated with the {@link ContentProvider} * that services the content at uri, starting the provider if necessary. Returns * null if there is no provider associated wih the uri. The caller must indicate that they are * done with the provider by calling {@link ContentProviderClient#release} which will allow * the system to release the provider it it determines that there is no other reason for * keeping it active. * @param uri specifies which provider should be acquired * @return a {@link ContentProviderClient} that is associated with the {@link ContentProvider} * that services the content at uri or null if there isn't one. */ public final ContentProviderClient acquireContentProviderClient(Uri uri) { IContentProvider provider = acquireProvider(uri); if (provider != null) { return new ContentProviderClient(this, provider); } return null; } /** * Returns a {@link ContentProviderClient} that is associated with the {@link ContentProvider} * with the authority of name, starting the provider if necessary. Returns * null if there is no provider associated wih the uri. The caller must indicate that they are * done with the provider by calling {@link ContentProviderClient#release} which will allow * the system to release the provider it it determines that there is no other reason for * keeping it active. * @param name specifies which provider should be acquired * @return a {@link ContentProviderClient} that is associated with the {@link ContentProvider} * with the authority of name or null if there isn't one. */ public final ContentProviderClient acquireContentProviderClient(String name) { IContentProvider provider = acquireProvider(name); if (provider != null) { return new ContentProviderClient(this, provider); } return null; } /** * Register an observer class that gets callbacks when data identified by a * given content URI changes. * * @param uri The URI to watch for changes. This can be a specific row URI, or a base URI * for a whole class of content. * @param notifyForDescendents If true changes to URIs beginning with uri * will also cause notifications to be sent. If false only changes to the exact URI * specified by uri will cause notifications to be sent. If true, than any URI values * at or below the specified URI will also trigger a match. * @param observer The object that receives callbacks when changes occur. * @see #unregisterContentObserver */ public final void registerContentObserver(Uri uri, boolean notifyForDescendents, ContentObserver observer) { try { getContentService().registerContentObserver(uri, notifyForDescendents, observer.getContentObserver()); } catch (RemoteException e) { } } /** * Unregisters a change observer. * * @param observer The previously registered observer that is no longer needed. * @see #registerContentObserver */ public final void unregisterContentObserver(ContentObserver observer) { try { IContentObserver contentObserver = observer.releaseContentObserver(); if (contentObserver != null) { getContentService().unregisterContentObserver( contentObserver); } } catch (RemoteException e) { } } /** * Notify registered observers that a row was updated. * To register, call {@link #registerContentObserver(android.net.Uri , boolean, android.database.ContentObserver) registerContentObserver()}. * By default, CursorAdapter objects will get this notification. * * @param uri * @param observer The observer that originated the change, may be null */ public void notifyChange(Uri uri, ContentObserver observer) { notifyChange(uri, observer, true /* sync to network */); } /** * Notify registered observers that a row was updated. * To register, call {@link #registerContentObserver(android.net.Uri , boolean, android.database.ContentObserver) registerContentObserver()}. * By default, CursorAdapter objects will get this notification. * * @param uri * @param observer The observer that originated the change, may be null * @param syncToNetwork If true, attempt to sync the change to the network. */ public void notifyChange(Uri uri, ContentObserver observer, boolean syncToNetwork) { try { getContentService().notifyChange( uri, observer == null ? null : observer.getContentObserver(), observer != null && observer.deliverSelfNotifications(), syncToNetwork); } catch (RemoteException e) { } } /** * Start an asynchronous sync operation. If you want to monitor the progress * of the sync you may register a SyncObserver. Only values of the following * types may be used in the extras bundle: *
    *
  • Integer
  • *
  • Long
  • *
  • Boolean
  • *
  • Float
  • *
  • Double
  • *
  • String
  • *
* * @param uri the uri of the provider to sync or null to sync all providers. * @param extras any extras to pass to the SyncAdapter. * @deprecated instead use * {@link #requestSync(android.accounts.Account, String, android.os.Bundle)} */ @Deprecated public void startSync(Uri uri, Bundle extras) { Account account = null; if (extras != null) { String accountName = extras.getString(SYNC_EXTRAS_ACCOUNT); if (!TextUtils.isEmpty(accountName)) { account = new Account(accountName, "com.google"); } extras.remove(SYNC_EXTRAS_ACCOUNT); } requestSync(account, uri != null ? uri.getAuthority() : null, extras); } /** * Start an asynchronous sync operation. If you want to monitor the progress * of the sync you may register a SyncObserver. Only values of the following * types may be used in the extras bundle: *
    *
  • Integer
  • *
  • Long
  • *
  • Boolean
  • *
  • Float
  • *
  • Double
  • *
  • String
  • *
* * @param account which account should be synced * @param authority which authority should be synced * @param extras any extras to pass to the SyncAdapter. */ public static void requestSync(Account account, String authority, Bundle extras) { validateSyncExtrasBundle(extras); try { getContentService().requestSync(account, authority, extras); } catch (RemoteException e) { } } /** * Check that only values of the following types are in the Bundle: *
    *
  • Integer
  • *
  • Long
  • *
  • Boolean
  • *
  • Float
  • *
  • Double
  • *
  • String
  • *
  • Account
  • *
  • null
  • *
* @param extras the Bundle to check */ public static void validateSyncExtrasBundle(Bundle extras) { try { for (String key : extras.keySet()) { Object value = extras.get(key); if (value == null) continue; if (value instanceof Long) continue; if (value instanceof Integer) continue; if (value instanceof Boolean) continue; if (value instanceof Float) continue; if (value instanceof Double) continue; if (value instanceof String) continue; if (value instanceof Account) continue; throw new IllegalArgumentException("unexpected value type: " + value.getClass().getName()); } } catch (IllegalArgumentException e) { throw e; } catch (RuntimeException exc) { throw new IllegalArgumentException("error unparceling Bundle", exc); } } /** * Cancel any active or pending syncs that match the Uri. If the uri is null then * all syncs will be canceled. * * @param uri the uri of the provider to sync or null to sync all providers. * @deprecated instead use {@link #cancelSync(android.accounts.Account, String)} */ @Deprecated public void cancelSync(Uri uri) { cancelSync(null /* all accounts */, uri != null ? uri.getAuthority() : null); } /** * Cancel any active or pending syncs that match account and authority. The account and * authority can each independently be set to null, which means that syncs with any account * or authority, respectively, will match. * * @param account filters the syncs that match by this account * @param authority filters the syncs that match by this authority */ public static void cancelSync(Account account, String authority) { try { getContentService().cancelSync(account, authority); } catch (RemoteException e) { } } /** * Get information about the SyncAdapters that are known to the system. * @return an array of SyncAdapters that have registered with the system */ public static SyncAdapterType[] getSyncAdapterTypes() { try { return getContentService().getSyncAdapterTypes(); } catch (RemoteException e) { throw new RuntimeException("the ContentService should always be reachable", e); } } /** * Check if the provider should be synced when a network tickle is received * * @param account the account whose setting we are querying * @param authority the provider whose setting we are querying * @return true if the provider should be synced when a network tickle is received */ public static boolean getSyncAutomatically(Account account, String authority) { try { return getContentService().getSyncAutomatically(account, authority); } catch (RemoteException e) { throw new RuntimeException("the ContentService should always be reachable", e); } } /** * Set whether or not the provider is synced when it receives a network tickle. * * @param account the account whose setting we are querying * @param authority the provider whose behavior is being controlled * @param sync true if the provider should be synced when tickles are received for it */ public static void setSyncAutomatically(Account account, String authority, boolean sync) { try { getContentService().setSyncAutomatically(account, authority, sync); } catch (RemoteException e) { // exception ignored; if this is thrown then it means the runtime is in the midst of // being restarted } } /** * Specifies that a sync should be requested with the specified the account, authority, * and extras at the given frequency. If there is already another periodic sync scheduled * with the account, authority and extras then a new periodic sync won't be added, instead * the frequency of the previous one will be updated. *

* These periodic syncs honor the "syncAutomatically" and "masterSyncAutomatically" settings. * Although these sync are scheduled at the specified frequency, it may take longer for it to * actually be started if other syncs are ahead of it in the sync operation queue. This means * that the actual start time may drift. *

* Periodic syncs are not allowed to have any of {@link #SYNC_EXTRAS_DO_NOT_RETRY}, * {@link #SYNC_EXTRAS_IGNORE_BACKOFF}, {@link #SYNC_EXTRAS_IGNORE_SETTINGS}, * {@link #SYNC_EXTRAS_INITIALIZE}, {@link #SYNC_EXTRAS_FORCE}, * {@link #SYNC_EXTRAS_EXPEDITED}, {@link #SYNC_EXTRAS_MANUAL} set to true. * If any are supplied then an {@link IllegalArgumentException} will be thrown. * * @param account the account to specify in the sync * @param authority the provider to specify in the sync request * @param extras extra parameters to go along with the sync request * @param pollFrequency how frequently the sync should be performed, in seconds. * @throws IllegalArgumentException if an illegal extra was set or if any of the parameters * are null. */ public static void addPeriodicSync(Account account, String authority, Bundle extras, long pollFrequency) { validateSyncExtrasBundle(extras); if (account == null) { throw new IllegalArgumentException("account must not be null"); } if (authority == null) { throw new IllegalArgumentException("authority must not be null"); } if (extras.getBoolean(SYNC_EXTRAS_MANUAL, false) || extras.getBoolean(SYNC_EXTRAS_DO_NOT_RETRY, false) || extras.getBoolean(SYNC_EXTRAS_IGNORE_BACKOFF, false) || extras.getBoolean(SYNC_EXTRAS_IGNORE_SETTINGS, false) || extras.getBoolean(SYNC_EXTRAS_INITIALIZE, false) || extras.getBoolean(SYNC_EXTRAS_FORCE, false) || extras.getBoolean(SYNC_EXTRAS_EXPEDITED, false)) { throw new IllegalArgumentException("illegal extras were set"); } try { getContentService().addPeriodicSync(account, authority, extras, pollFrequency); } catch (RemoteException e) { // exception ignored; if this is thrown then it means the runtime is in the midst of // being restarted } } /** * Remove a periodic sync. Has no affect if account, authority and extras don't match * an existing periodic sync. * * @param account the account of the periodic sync to remove * @param authority the provider of the periodic sync to remove * @param extras the extras of the periodic sync to remove */ public static void removePeriodicSync(Account account, String authority, Bundle extras) { validateSyncExtrasBundle(extras); if (account == null) { throw new IllegalArgumentException("account must not be null"); } if (authority == null) { throw new IllegalArgumentException("authority must not be null"); } try { getContentService().removePeriodicSync(account, authority, extras); } catch (RemoteException e) { throw new RuntimeException("the ContentService should always be reachable", e); } } /** * Get the list of information about the periodic syncs for the given account and authority. * * @param account the account whose periodic syncs we are querying * @param authority the provider whose periodic syncs we are querying * @return a list of PeriodicSync objects. This list may be empty but will never be null. */ public static List getPeriodicSyncs(Account account, String authority) { if (account == null) { throw new IllegalArgumentException("account must not be null"); } if (authority == null) { throw new IllegalArgumentException("authority must not be null"); } try { return getContentService().getPeriodicSyncs(account, authority); } catch (RemoteException e) { throw new RuntimeException("the ContentService should always be reachable", e); } } /** * Check if this account/provider is syncable. * @return >0 if it is syncable, 0 if not, and <0 if the state isn't known yet. */ public static int getIsSyncable(Account account, String authority) { try { return getContentService().getIsSyncable(account, authority); } catch (RemoteException e) { throw new RuntimeException("the ContentService should always be reachable", e); } } /** * Set whether this account/provider is syncable. * @param syncable >0 denotes syncable, 0 means not syncable, <0 means unknown */ public static void setIsSyncable(Account account, String authority, int syncable) { try { getContentService().setIsSyncable(account, authority, syncable); } catch (RemoteException e) { // exception ignored; if this is thrown then it means the runtime is in the midst of // being restarted } } /** * Gets the master auto-sync setting that applies to all the providers and accounts. * If this is false then the per-provider auto-sync setting is ignored. * * @return the master auto-sync setting that applies to all the providers and accounts */ public static boolean getMasterSyncAutomatically() { try { return getContentService().getMasterSyncAutomatically(); } catch (RemoteException e) { throw new RuntimeException("the ContentService should always be reachable", e); } } /** * Sets the master auto-sync setting that applies to all the providers and accounts. * If this is false then the per-provider auto-sync setting is ignored. * * @param sync the master auto-sync setting that applies to all the providers and accounts */ public static void setMasterSyncAutomatically(boolean sync) { try { getContentService().setMasterSyncAutomatically(sync); } catch (RemoteException e) { // exception ignored; if this is thrown then it means the runtime is in the midst of // being restarted } } /** * Returns true if there is currently a sync operation for the given * account or authority in the pending list, or actively being processed. * @param account the account whose setting we are querying * @param authority the provider whose behavior is being queried * @return true if a sync is active for the given account or authority. */ public static boolean isSyncActive(Account account, String authority) { try { return getContentService().isSyncActive(account, authority); } catch (RemoteException e) { throw new RuntimeException("the ContentService should always be reachable", e); } } /** * If a sync is active returns the information about it, otherwise returns false. * @return the SyncInfo for the currently active sync or null if one is not active. */ public static SyncInfo getCurrentSync() { try { return getContentService().getCurrentSync(); } catch (RemoteException e) { throw new RuntimeException("the ContentService should always be reachable", e); } } /** * Returns the status that matches the authority. * @param account the account whose setting we are querying * @param authority the provider whose behavior is being queried * @return the SyncStatusInfo for the authority, or null if none exists * @hide */ public static SyncStatusInfo getSyncStatus(Account account, String authority) { try { return getContentService().getSyncStatus(account, authority); } catch (RemoteException e) { throw new RuntimeException("the ContentService should always be reachable", e); } } /** * Return true if the pending status is true of any matching authorities. * @param account the account whose setting we are querying * @param authority the provider whose behavior is being queried * @return true if there is a pending sync with the matching account and authority */ public static boolean isSyncPending(Account account, String authority) { try { return getContentService().isSyncPending(account, authority); } catch (RemoteException e) { throw new RuntimeException("the ContentService should always be reachable", e); } } /** * Request notifications when the different aspects of the SyncManager change. The * different items that can be requested are: *

    *
  • {@link #SYNC_OBSERVER_TYPE_PENDING} *
  • {@link #SYNC_OBSERVER_TYPE_ACTIVE} *
  • {@link #SYNC_OBSERVER_TYPE_SETTINGS} *
* The caller can set one or more of the status types in the mask for any * given listener registration. * @param mask the status change types that will cause the callback to be invoked * @param callback observer to be invoked when the status changes * @return a handle that can be used to remove the listener at a later time */ public static Object addStatusChangeListener(int mask, final SyncStatusObserver callback) { if (callback == null) { throw new IllegalArgumentException("you passed in a null callback"); } try { ISyncStatusObserver.Stub observer = new ISyncStatusObserver.Stub() { public void onStatusChanged(int which) throws RemoteException { callback.onStatusChanged(which); } }; getContentService().addStatusChangeListener(mask, observer); return observer; } catch (RemoteException e) { throw new RuntimeException("the ContentService should always be reachable", e); } } /** * Remove a previously registered status change listener. * @param handle the handle that was returned by {@link #addStatusChangeListener} */ public static void removeStatusChangeListener(Object handle) { if (handle == null) { throw new IllegalArgumentException("you passed in a null handle"); } try { getContentService().removeStatusChangeListener((ISyncStatusObserver.Stub) handle); } catch (RemoteException e) { // exception ignored; if this is thrown then it means the runtime is in the midst of // being restarted } } /** * Returns sampling percentage for a given duration. * * Always returns at least 1%. */ private int samplePercentForDuration(long durationMillis) { if (durationMillis >= SLOW_THRESHOLD_MILLIS) { return 100; } return (int) (100 * durationMillis / SLOW_THRESHOLD_MILLIS) + 1; } private void maybeLogQueryToEventLog(long durationMillis, Uri uri, String[] projection, String selection, String sortOrder) { int samplePercent = samplePercentForDuration(durationMillis); if (samplePercent < 100) { synchronized (mRandom) { if (mRandom.nextInt(100) >= samplePercent) { return; } } } StringBuilder projectionBuffer = new StringBuilder(100); if (projection != null) { for (int i = 0; i < projection.length; ++i) { // Note: not using a comma delimiter here, as the // multiple arguments to EventLog.writeEvent later // stringify with a comma delimiter, which would make // parsing uglier later. if (i != 0) projectionBuffer.append('/'); projectionBuffer.append(projection[i]); } } // ActivityThread.currentPackageName() only returns non-null if the // current thread is an application main thread. This parameter tells // us whether an event loop is blocked, and if so, which app it is. String blockingPackage = AppGlobals.getInitialPackage(); EventLog.writeEvent( EventLogTags.CONTENT_QUERY_SAMPLE, uri.toString(), projectionBuffer.toString(), selection != null ? selection : "", sortOrder != null ? sortOrder : "", durationMillis, blockingPackage != null ? blockingPackage : "", samplePercent); } private void maybeLogUpdateToEventLog( long durationMillis, Uri uri, String operation, String selection) { int samplePercent = samplePercentForDuration(durationMillis); if (samplePercent < 100) { synchronized (mRandom) { if (mRandom.nextInt(100) >= samplePercent) { return; } } } String blockingPackage = AppGlobals.getInitialPackage(); EventLog.writeEvent( EventLogTags.CONTENT_UPDATE_SAMPLE, uri.toString(), operation, selection != null ? selection : "", durationMillis, blockingPackage != null ? blockingPackage : "", samplePercent); } private final class CursorWrapperInner extends CursorWrapper { private IContentProvider mContentProvider; public static final String TAG="CursorWrapperInner"; private boolean mCloseFlag = false; CursorWrapperInner(Cursor cursor, IContentProvider icp) { super(cursor); mContentProvider = icp; } @Override public void close() { super.close(); ContentResolver.this.releaseProvider(mContentProvider); mCloseFlag = true; } @Override protected void finalize() throws Throwable { try { if(!mCloseFlag) { this.close(); } } finally { super.finalize(); } } } private final class ParcelFileDescriptorInner extends ParcelFileDescriptor { private IContentProvider mContentProvider; public static final String TAG="ParcelFileDescriptorInner"; private boolean mReleaseProviderFlag = false; ParcelFileDescriptorInner(ParcelFileDescriptor pfd, IContentProvider icp) { super(pfd); mContentProvider = icp; } @Override public void close() throws IOException { if(!mReleaseProviderFlag) { super.close(); ContentResolver.this.releaseProvider(mContentProvider); mReleaseProviderFlag = true; } } @Override protected void finalize() throws Throwable { if (!mReleaseProviderFlag) { close(); } } } /** @hide */ public static final String CONTENT_SERVICE_NAME = "content"; /** @hide */ public static IContentService getContentService() { if (sContentService != null) { return sContentService; } IBinder b = ServiceManager.getService(CONTENT_SERVICE_NAME); if (Config.LOGV) Log.v("ContentService", "default service binder = " + b); sContentService = IContentService.Stub.asInterface(b); if (Config.LOGV) Log.v("ContentService", "default service = " + sContentService); return sContentService; } private static IContentService sContentService; private final Context mContext; private static final String TAG = "ContentResolver"; }