| /* |
| * 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.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 |
| * <code>content://com.company.provider.imap/inbox/1</code> for a particular |
| * message in the inbox, whose MIME type would be reported as |
| * <code>CURSOR_ITEM_BASE_TYPE + "/vnd.company.imap-msg"</code> |
| * |
| * <p>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 |
| * <code>content://com.company.provider.imap/inbox</code> for all of the |
| * messages in its inbox, whose MIME type would be reported as |
| * <code>CURSOR_DIR_BASE_TYPE + "/vnd.company.imap-msg"</code> |
| * |
| * <p>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); |
| /** @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 = acquireProvider(url); |
| if (provider == null) { |
| return null; |
| } |
| try { |
| return provider.getType(url); |
| } catch (RemoteException e) { |
| return null; |
| } catch (java.lang.Exception e) { |
| return null; |
| } finally { |
| releaseProvider(provider); |
| } |
| } |
| |
| /** |
| * <p> |
| * Query the given URI, returning a {@link Cursor} over the result set. |
| * </p> |
| * <p> |
| * For best performance, the caller should follow these guidelines: |
| * <ul> |
| * <li>Provide an explicit projection, to prevent |
| * reading data from storage that aren't going to be used.</li> |
| * <li>Use question mark parameter markers such as 'phone=?' instead of |
| * explicit values in the {@code selection} parameter, so that queries |
| * that differ only by those values will be recognized as the same |
| * for caching purposes.</li> |
| * </ul> |
| * </p> |
| * |
| * @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. |
| * |
| * <h5>Accepts the following URI schemes:</h5> |
| * <ul> |
| * <li>content ({@link #SCHEME_CONTENT})</li> |
| * <li>android.resource ({@link #SCHEME_ANDROID_RESOURCE})</li> |
| * <li>file ({@link #SCHEME_FILE})</li> |
| * </ul> |
| * |
| * <p>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. |
| * |
| * <h5>Accepts the following URI schemes:</h5> |
| * <ul> |
| * <li>content ({@link #SCHEME_CONTENT})</li> |
| * <li>file ({@link #SCHEME_FILE})</li> |
| * </ul> |
| * |
| * <p>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 <em>not</em> 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. |
| * |
| * <h5>Accepts the following URI schemes:</h5> |
| * <ul> |
| * <li>content ({@link #SCHEME_CONTENT})</li> |
| * <li>file ({@link #SCHEME_FILE})</li> |
| * </ul> |
| * |
| * <p>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. |
| * |
| * <h5>Accepts the following URI schemes:</h5> |
| * <ul> |
| * <li>content ({@link #SCHEME_CONTENT})</li> |
| * <li>android.resource ({@link #SCHEME_ANDROID_RESOURCE})</li> |
| * <li>file ({@link #SCHEME_FILE})</li> |
| * </ul> |
| * <h5>The android.resource ({@link #SCHEME_ANDROID_RESOURCE}) Scheme</h5> |
| * <p> |
| * A Uri object can be used to reference a resource in an APK file. The |
| * Uri should be one of the following formats: |
| * <ul> |
| * <li><code>android.resource://package_name/id_number</code><br/> |
| * <code>package_name</code> is your package name as listed in your AndroidManifest.xml. |
| * For example <code>com.example.myapp</code><br/> |
| * <code>id_number</code> is the int form of the ID.<br/> |
| * The easiest way to construct this form is |
| * <pre>Uri uri = Uri.parse("android.resource://com.example.myapp/" + R.raw.my_resource");</pre> |
| * </li> |
| * <li><code>android.resource://package_name/type/name</code><br/> |
| * <code>package_name</code> is your package name as listed in your AndroidManifest.xml. |
| * For example <code>com.example.myapp</code><br/> |
| * <code>type</code> is the string form of the resource type. For example, <code>raw</code> |
| * or <code>drawable</code>. |
| * <code>name</code> is the string form of the resource name. That is, whatever the file |
| * name was in your res directory, without the type extension. |
| * The easiest way to construct this form is |
| * <pre>Uri uri = Uri.parse("android.resource://com.example.myapp/raw/my_resource");</pre> |
| * </li> |
| * </ul> |
| * |
| * @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<String> 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<ContentProviderOperation> 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; |
| } |
| |
| /** |
| * @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 <code>true</code> changes to URIs beginning with <code>uri</code> |
| * will also cause notifications to be sent. If <code>false</code> only changes to the exact URI |
| * specified by <em>uri</em> 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 <code>null</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 <code>null</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: |
| * <ul> |
| * <li>Integer</li> |
| * <li>Long</li> |
| * <li>Boolean</li> |
| * <li>Float</li> |
| * <li>Double</li> |
| * <li>String</li> |
| * </ul> |
| * |
| * @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: |
| * <ul> |
| * <li>Integer</li> |
| * <li>Long</li> |
| * <li>Boolean</li> |
| * <li>Float</li> |
| * <li>Double</li> |
| * <li>String</li> |
| * </ul> |
| * |
| * @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: |
| * <ul> |
| * <li>Integer</li> |
| * <li>Long</li> |
| * <li>Boolean</li> |
| * <li>Float</li> |
| * <li>Double</li> |
| * <li>String</li> |
| * <li>Account</li> |
| * <li>null</li> |
| * </ul> |
| * @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. |
| * <p> |
| * 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. |
| * <p> |
| * 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<PeriodicSync> 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: |
| * <ul> |
| * <li> {@link #SYNC_OBSERVER_TYPE_PENDING} |
| * <li> {@link #SYNC_OBSERVER_TYPE_ACTIVE} |
| * <li> {@link #SYNC_OBSERVER_TYPE_SETTINGS} |
| * </ul> |
| * 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) { |
| ContentResolver.this.releaseProvider(mContentProvider); |
| } |
| } 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"; |
| } |
