1453 lines
58 KiB
Java
1453 lines
58 KiB
Java
/*
|
|
* 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
|
|
* <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);
|
|
/** 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;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* <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;
|
|
}
|
|
|
|
/**
|
|
* 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 <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) {
|
|
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";
|
|
}
|