Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
   /*
2
    * Copyright (C) 2006 The Android Open Source Project
3
    *
4
    * Licensed under the Apache License, Version 2.0 (the "License");
5
    * you may not use this file except in compliance with the License.
6
    * You may obtain a copy of the License at
7
    *
8
    *      http://www.apache.org/licenses/LICENSE-2.0
9
    *
10
   * Unless required by applicable law or agreed to in writing, software
11
   * distributed under the License is distributed on an "AS IS" BASIS,
12
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
   * See the License for the specific language governing permissions and
14
   * limitations under the License.
15
   */
16
  
17
  package android.content;
18
  
30
  import android.net.Uri;
31
  import android.os.Bundle;
40
  import android.util.Log;
41
  
42
  import java.io.File;
48
  import java.util.List;
49
  import java.util.Random;
This class provides applications access to the content model. 
55
  
56
  public abstract class ContentResolver {
    

Deprecated:
instead use requestSync(android.accounts.Account,java.lang.String,android.os.Bundle)
60
  
61
      @Deprecated
62
      public static final String SYNC_EXTRAS_ACCOUNT = "account";
63
      public static final String SYNC_EXTRAS_EXPEDITED = "expedited";
    

Deprecated:
instead use SYNC_EXTRAS_MANUAL
67
  
68
      @Deprecated
69
      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. 
74
  
75
      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. 
81
  
82
      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. 
86
  
87
      public static final String SYNC_EXTRAS_DO_NOT_RETRY = "do_not_retry";

    
Setting this extra is the equivalent of setting both SYNC_EXTRAS_IGNORE_SETTINGS and SYNC_EXTRAS_IGNORE_BACKOFF 
92
  
93
      public static final String SYNC_EXTRAS_MANUAL = "force";
94
  
95
      public static final String SYNC_EXTRAS_UPLOAD = "upload";
96
      public static final String SYNC_EXTRAS_OVERRIDE_TOO_MANY_DELETIONS = "deletions_override";
97
      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 setIsSyncable(android.accounts.Account,java.lang.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. 
105
 
106
     public static final String SYNC_EXTRAS_INITIALIZE = "initialize";
107
 
108
     public static final String SCHEME_CONTENT = "content";
109
     public static final String SCHEME_ANDROID_RESOURCE = "android.resource";
110
     public static final String SCHEME_FILE = "file";

    
This is the Android platform's base MIME type for a content: URI containing a Cursor of a single item. Applications should use this as the base type along with their own sub-type of their content: URIs that represent a particular item. For example, hypothetical IMAP email client may have a URI content://com.company.provider.imap/inbox/1 for a particular message in the inbox, whose MIME type would be reported as CURSOR_ITEM_BASE_TYPE + "/vnd.company.imap-msg"

Compare with CURSOR_DIR_BASE_TYPE. 

123
 
124
     public static final String CURSOR_ITEM_BASE_TYPE = "vnd.android.cursor.item";

    
This is the Android platform's base MIME type for a content: URI containing a Cursor of zero or more items. Applications should use this as the base type along with their own sub-type of their content: URIs that represent a directory of items. For example, hypothetical IMAP email client may have a URI content://com.company.provider.imap/inbox for all of the messages in its inbox, whose MIME type would be reported as CURSOR_DIR_BASE_TYPE + "/vnd.company.imap-msg"

Note how the base MIME type varies between this and 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. 

141
 
142
     public static final String CURSOR_DIR_BASE_TYPE = "vnd.android.cursor.dir";

    

Hide:
144
 
145
     public static final int SYNC_ERROR_SYNC_ALREADY_IN_PROGRESS = 1;
    

Hide:
146
 
147
     public static final int SYNC_ERROR_AUTHENTICATION = 2;
    

Hide:
148
 
149
     public static final int SYNC_ERROR_IO = 3;
    

Hide:
150
 
151
     public static final int SYNC_ERROR_PARSE = 4;
    

Hide:
152
 
153
     public static final int SYNC_ERROR_CONFLICT = 5;
    

Hide:
154
 
155
     public static final int SYNC_ERROR_TOO_MANY_DELETIONS = 6;
    

Hide:
156
 
157
     public static final int SYNC_ERROR_TOO_MANY_RETRIES = 7;
    

Hide:
158
 
159
     public static final int SYNC_ERROR_INTERNAL = 8;
160
 
161
     public static final int SYNC_OBSERVER_TYPE_SETTINGS = 1<<0;
162
     public static final int SYNC_OBSERVER_TYPE_PENDING = 1<<1;
163
     public static final int SYNC_OBSERVER_TYPE_ACTIVE = 1<<2;
    

Hide:
164
 
165
     public static final int SYNC_OBSERVER_TYPE_STATUS = 1<<3;
    

Hide:
166
 
167
     public static final int SYNC_OBSERVER_TYPE_ALL = 0x7fffffff;
168
 
169
     // Always log queries which take 500ms+; shorter queries are
170
     // sampled accordingly.
171
     private static final int SLOW_THRESHOLD_MILLIS = 500;
172
     private final Random mRandom = new Random();  // guarded by itself
173
 
174
     public ContentResolver(Context context) {
175
          = context;
176
     }

    

Hide:
178
 
179
     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:
182
 
183
     protected IContentProvider acquireExistingProvider(Context c, String name) {
184
         return acquireProvider(c, name);
185
     }
    

Hide:
186
 
187
     public abstract boolean releaseProvider(IContentProvider icp);

    
Return the MIME type of the given content URL.

Parameters:
url A Uri identifying content (either a list or specific type), using the content:// scheme.
Returns:
A MIME type for the content, or null if the URL is invalid or the type is unknown
195
 
196
     public final String getType(Uri url) {
197
         IContentProvider provider = acquireExistingProvider(url);
198
         if (provider != null) {
199
             try {
200
                 return provider.getType(url);
201
             } catch (RemoteException e) {
202
                 return null;
203
             } catch (java.lang.Exception e) {
204
                 return null;
205
             } finally {
206
                 releaseProvider(provider);
207
             }
208
         }
209
 
210
         if (!.equals(url.getScheme())) {
211
             return null;
212
         }
213
 
214
         try {
215
             String type = ActivityManagerNative.getDefault().getProviderMimeType(url);
216
             return type;
217
         } catch (RemoteException e) {
218
             return null;
219
         }
220
     }

    

Query the given URI, returning a android.database.Cursor over the result set.

For best performance, the caller should follow these guidelines:

  • Provide an explicit projection, to prevent reading data from storage that aren't going to be used.
  • Use question mark parameter markers such as 'phone=?' instead of explicit values in the selection parameter, so that queries that differ only by those values will be recognized as the same for caching purposes.

Parameters:
uri The URI, using the content:// scheme, for the content to retrieve.
projection A list of which columns to return. Passing null will return all columns, which is inefficient.
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.
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.
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.
Returns:
A Cursor object, which is positioned before the first entry, or null
See also:
android.database.Cursor
253
 
254
     public final Cursor query(Uri uri, String[] projection,
255
             String selection, String[] selectionArgs, String sortOrder) {
256
         IContentProvider provider = acquireProvider(uri);
257
         if (provider == null) {
258
             return null;
259
         }
260
         try {
261
             long startTime = SystemClock.uptimeMillis();
262
             Cursor qCursor = provider.query(uri, projection, selection, selectionArgs, sortOrder);
263
             if (qCursor == null) {
264
                 releaseProvider(provider);
265
                 return null;
266
             }
267
             // force query execution
268
             qCursor.getCount();
269
             long durationMillis = SystemClock.uptimeMillis() - startTime;
270
             maybeLogQueryToEventLog(durationMillis, uri, projection, selection, sortOrder);
271
             // Wrap the cursor object into CursorWrapperInner object
272
             return new CursorWrapperInner(qCursor, provider);
273
         } catch (RemoteException e) {
274
             releaseProvider(provider);
275
             return null;
276
         } catch(RuntimeException e) {
277
             releaseProvider(provider);
278
             throw e;
279
         }
280
     }

    
Open a stream on to the content associated with a content URI. If there is no data associated with the URI, FileNotFoundException is thrown.
Accepts the following URI schemes:

See openAssetFileDescriptor(android.net.Uri,java.lang.String) for more information on these schemes.

Parameters:
uri The desired URI.
Returns:
InputStream
Throws:
java.io.FileNotFoundException if the provided URI could not be opened.
See also:
openAssetFileDescriptor(android.net.Uri,java.lang.String)
300
 
301
     public final InputStream openInputStream(Uri uri)
302
             throws FileNotFoundException {
303
         String scheme = uri.getScheme();
304
         if (.equals(scheme)) {
305
             // Note: left here to avoid breaking compatibility.  May be removed
306
             // with sufficient testing.
307
             OpenResourceIdResult r = getResourceId(uri);
308
             try {
309
                 InputStream stream = r.r.openRawResource(r.id);
310
                 return stream;
311
             } catch (Resources.NotFoundException ex) {
312
                 throw new FileNotFoundException("Resource does not exist: " + uri);
313
             }
314
         } else if (.equals(scheme)) {
315
             // Note: left here to avoid breaking compatibility.  May be removed
316
             // with sufficient testing.
317
             return new FileInputStream(uri.getPath());
318
         } else {
319
             AssetFileDescriptor fd = openAssetFileDescriptor(uri, "r");
320
             try {
321
                 return fd != null ? fd.createInputStream() : null;
322
             } catch (IOException e) {
323
                 throw new FileNotFoundException("Unable to create stream");
324
             }
325
         }
326
     }

    
Synonym for openOutputStream(uri, "w").

Throws:
java.io.FileNotFoundException if the provided URI could not be opened.
332
 
333
     public final OutputStream openOutputStream(Uri uri)
334
             throws FileNotFoundException {
335
         return openOutputStream(uri, "w");
336
     }

    
Open a stream on to the content associated with a content URI. If there is no data associated with the URI, FileNotFoundException is thrown.
Accepts the following URI schemes:

See openAssetFileDescriptor(android.net.Uri,java.lang.String) for more information on these schemes.

Parameters:
uri The desired URI.
mode May be "w", "wa", "rw", or "rwt".
Returns:
OutputStream
Throws:
java.io.FileNotFoundException if the provided URI could not be opened.
See also:
openAssetFileDescriptor(android.net.Uri,java.lang.String)
356
 
357
     public final OutputStream openOutputStream(Uri uri, String mode)
358
             throws FileNotFoundException {
359
         AssetFileDescriptor fd = openAssetFileDescriptor(uri, mode);
360
         try {
361
             return fd != null ? fd.createOutputStream() : null;
362
         } catch (IOException e) {
363
             throw new FileNotFoundException("Unable to create stream");
364
         }
365
     }

    
Open a raw file descriptor to access data under a "content:" URI. This is like openAssetFileDescriptor(android.net.Uri,java.lang.String), but uses the underlying ContentProvider.openFile(android.net.Uri,java.lang.String) ContentProvider.openFile()} method, so will not work with providers that return sub-sections of files. If at all possible, you should use openAssetFileDescriptor(android.net.Uri,java.lang.String). You will receive a FileNotFoundException exception if the provider returns a sub-section of a file.
Accepts the following URI schemes:

See openAssetFileDescriptor(android.net.Uri,java.lang.String) for more information on these schemes.

Parameters:
uri The desired URI to open.
mode The file mode to use, as per ContentProvider.openFile.
Returns:
Returns a new ParcelFileDescriptor pointing to the file. You own this descriptor and are responsible for closing it when done.
Throws:
java.io.FileNotFoundException Throws FileNotFoundException of no file exists under the URI or the mode is invalid.
See also:
openAssetFileDescriptor(android.net.Uri,java.lang.String)
394
 
395
     public final ParcelFileDescriptor openFileDescriptor(Uri uri,
396
             String mode) throws FileNotFoundException {
397
         AssetFileDescriptor afd = openAssetFileDescriptor(uri, mode);
398
         if (afd == null) {
399
             return null;
400
         }
401
 
402
         if (afd.getDeclaredLength() < 0) {
403
             // This is a full file!
404
             return afd.getParcelFileDescriptor();
405
         }
406
 
407
         // Client can't handle a sub-section of a file, so close what
408
         // we got and bail with an exception.
409
         try {
410
             afd.close();
411
         } catch (IOException e) {
412
         }
413
 
414
         throw new FileNotFoundException("Not a whole file");
415
     }

    
Open a raw file descriptor to access data under a "content:" URI. This interacts with the underlying ContentProvider.openAssetFile(android.net.Uri,java.lang.String) ContentProvider.openAssetFile()} method of the provider associated with the given URI, to retrieve any file stored there.
Accepts the following URI schemes:
The android.resource (SCHEME_ANDROID_RESOURCE) Scheme

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

  • android.resource://package_name/id_number
    package_name is your package name as listed in your AndroidManifest.xml. For example com.example.myapp
    id_number is the int form of the ID.
    The easiest way to construct this form is 
    Uri uri = Uri.parse("android.resource://com.example.myapp/" + R.raw.my_resource");
  • android.resource://package_name/type/name
    package_name is your package name as listed in your AndroidManifest.xml. For example com.example.myapp
    type is the string form of the resource type. For example, raw or drawable. name 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 
    Uri uri = Uri.parse("android.resource://com.example.myapp/raw/my_resource");

Parameters:
uri The desired URI to open.
mode The file mode to use, as per ContentProvider.openAssetFile.
Returns:
Returns a new ParcelFileDescriptor pointing to the file. You own this descriptor and are responsible for closing it when done.
Throws:
java.io.FileNotFoundException Throws FileNotFoundException of no file exists under the URI or the mode is invalid.
460
 
461
     public final AssetFileDescriptor openAssetFileDescriptor(Uri uri,
462
             String mode) throws FileNotFoundException {
463
         String scheme = uri.getScheme();
464
         if (.equals(scheme)) {
465
             if (!"r".equals(mode)) {
466
                 throw new FileNotFoundException("Can't write resources: " + uri);
467
             }
468
             OpenResourceIdResult r = getResourceId(uri);
469
             try {
470
                 return r.r.openRawResourceFd(r.id);
471
             } catch (Resources.NotFoundException ex) {
472
                 throw new FileNotFoundException("Resource does not exist: " + uri);
473
             }
474
         } else if (.equals(scheme)) {
475
             ParcelFileDescriptor pfd = ParcelFileDescriptor.open(
476
                     new File(uri.getPath()), modeToMode(uri, mode));
477
             return new AssetFileDescriptor(pfd, 0, -1);
478
         } else {
479
             IContentProvider provider = acquireProvider(uri);
480
             if (provider == null) {
481
                 throw new FileNotFoundException("No content provider: " + uri);
482
             }
483
             try {
484
                 AssetFileDescriptor fd = provider.openAssetFile(uri, mode);
485
                 if(fd == null) {
486
                     releaseProvider(provider);
487
                     return null;
488
                 }
489
                 ParcelFileDescriptor pfd = new ParcelFileDescriptorInner(
490
                         fd.getParcelFileDescriptor(), provider);
491
                 return new AssetFileDescriptor(pfd, fd.getStartOffset(),
492
                         fd.getDeclaredLength());
493
             } catch (RemoteException e) {
494
                 releaseProvider(provider);
495
                 throw new FileNotFoundException("Dead content provider: " + uri);
496
             } catch (FileNotFoundException e) {
497
                 releaseProvider(provider);
498
                 throw e;
499
             } catch (RuntimeException e) {
500
                 releaseProvider(provider);
501
                 throw e;
502
             }
503
         }
504
     }

    
A resource identified by the android.content.res.Resources that contains it, and a resource id.

Hide:
510
 
511
     public class OpenResourceIdResult {
512
         public Resources r;
513
         public int id;
514
     }

    
Resolves an android.resource URI to a android.content.res.Resources and a resource id.

Hide:
520
 
521
     public OpenResourceIdResult getResourceId(Uri uri) throws FileNotFoundException {
522
         String authority = uri.getAuthority();
523
         Resources r;
524
         if (TextUtils.isEmpty(authority)) {
525
             throw new FileNotFoundException("No authority: " + uri);
526
         } else {
527
             try {
528
                 r = .getPackageManager().getResourcesForApplication(authority);
529
             } catch (NameNotFoundException ex) {
530
                 throw new FileNotFoundException("No package found for authority: " + uri);
531
             }
532
         }
533
         List<String> path = uri.getPathSegments();
534
         if (path == null) {
535
             throw new FileNotFoundException("No path: " + uri);
536
         }
537
         int len = path.size();
538
         int id;
539
         if (len == 1) {
540
             try {
541
                 id = Integer.parseInt(path.get(0));
542
             } catch (NumberFormatException e) {
543
                 throw new FileNotFoundException("Single path segment is not a resource ID: " + uri);
544
             }
545
         } else if (len == 2) {
546
             id = r.getIdentifier(path.get(1), path.get(0), authority);
547
         } else {
548
             throw new FileNotFoundException("More than two path segments: " + uri);
549
         }
550
         if (id == 0) {
551
             throw new FileNotFoundException("No resource found for: " + uri);
552
         }
553
         OpenResourceIdResult res = new OpenResourceIdResult();
554
         res.r = r;
555
         res.id = id;
556
         return res;
557
     }

    

Hide:
559
 
560
     static public int modeToMode(Uri uri, String mode) throws FileNotFoundException {
561
         int modeBits;
562
         if ("r".equals(mode)) {
563
             modeBits = .;
564
         } else if ("w".equals(mode) || "wt".equals(mode)) {
565
             modeBits = .
566
                     | .
567
                     | .;
568
         } else if ("wa".equals(mode)) {
569
             modeBits = .
570
                     | .
571
                     | .;
572
         } else if ("rw".equals(mode)) {
573
             modeBits = .
574
                     | .;
575
         } else if ("rwt".equals(mode)) {
576
             modeBits = .
577
                     | .
578
                     | .;
579
         } else {
580
             throw new FileNotFoundException("Bad mode for " + uri + ": "
581
                     + mode);
582
         }
583
         return modeBits;
584
     }

    
Inserts a row into a table at the given URL. If the content provider supports transactions the insertion will be atomic.

Parameters:
url The URL of the table to insert into.
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.
Returns:
the URL of the newly created row.
595
 
596
     public final Uri insert(Uri url, ContentValues values)
597
     {
598
         IContentProvider provider = acquireProvider(url);
599
         if (provider == null) {
600
             throw new IllegalArgumentException("Unknown URL " + url);
601
         }
602
         try {
603
             long startTime = SystemClock.uptimeMillis();
604
             Uri createdRow = provider.insert(url, values);
605
             long durationMillis = SystemClock.uptimeMillis() - startTime;
606
             maybeLogUpdateToEventLog(durationMillis, url, "insert", null /* where */);
607
             return createdRow;
608
         } catch (RemoteException e) {
609
             return null;
610
         } finally {
611
             releaseProvider(provider);
612
         }
613
     }

    
Applies each of the ContentProviderOperation objects and returns an array of their results. Passes through OperationApplicationException, which may be thrown by the call to ContentProviderOperation.apply(android.content.ContentProvider,android.content.ContentProviderResult[],int). If all the applications succeed then a 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 OperationApplicationException.

Parameters:
authority the authority of the ContentProvider to which this batch should be applied
operations the operations to apply
Returns:
the results of the applications
Throws:
OperationApplicationException thrown if an application fails. See ContentProviderOperation.apply(android.content.ContentProvider,android.content.ContentProviderResult[],int) for more information.
android.os.RemoteException thrown if a RemoteException is encountered while attempting to communicate with a remote provider.
630
 
631
     public ContentProviderResult[] applyBatch(String authority,
632
             ArrayList<ContentProviderOperation> operations)
633
             throws RemoteException, OperationApplicationException {
634
         ContentProviderClient provider = acquireContentProviderClient(authority);
635
         if (provider == null) {
636
             throw new IllegalArgumentException("Unknown authority " + authority);
637
         }
638
         try {
639
             return provider.applyBatch(operations);
640
         } finally {
641
             provider.release();
642
         }
643
     }

    
Inserts multiple rows into a table at the given URL. This function make no guarantees about the atomicity of the insertions.

Parameters:
url The URL of the table to insert into.
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.
Returns:
the number of newly created rows.
654
 
655
     public final int bulkInsert(Uri url, ContentValues[] values)
656
     {
657
         IContentProvider provider = acquireProvider(url);
658
         if (provider == null) {
659
             throw new IllegalArgumentException("Unknown URL " + url);
660
         }
661
         try {
662
             long startTime = SystemClock.uptimeMillis();
663
             int rowsCreated = provider.bulkInsert(url, values);
664
             long durationMillis = SystemClock.uptimeMillis() - startTime;
665
             maybeLogUpdateToEventLog(durationMillis, url, "bulkinsert", null /* where */);
666
             return rowsCreated;
667
         } catch (RemoteException e) {
668
             return 0;
669
         } finally {
670
             releaseProvider(provider);
671
         }
672
     }

    
Deletes row(s) specified by a content URI. If the content provider supports transactions, the deletion will be atomic.

Parameters:
url The URL of the row to delete.
where A filter to apply to rows before deleting, formatted as an SQL WHERE clause (excluding the WHERE itself).
Returns:
The number of rows deleted.
683
 
684
     public final int delete(Uri url, String where, String[] selectionArgs)
685
     {
686
         IContentProvider provider = acquireProvider(url);
687
         if (provider == null) {
688
             throw new IllegalArgumentException("Unknown URL " + url);
689
         }
690
         try {
691
             long startTime = SystemClock.uptimeMillis();
692
             int rowsDeleted = provider.delete(url, where, selectionArgs);
693
             long durationMillis = SystemClock.uptimeMillis() - startTime;
694
             maybeLogUpdateToEventLog(durationMillis, url, "delete", where);
695
             return rowsDeleted;
696
         } catch (RemoteException e) {
697
             return -1;
698
         } finally {
699
             releaseProvider(provider);
700
         }
701
     }

    
Update row(s) in a content URI. If the content provider supports transactions the update will be atomic.

Parameters:
uri The URI to modify.
values The new field values. The key is the column name for the field. A null value will remove an existing field value.
where A filter to apply to rows before updating, formatted as an SQL WHERE clause (excluding the WHERE itself).
Returns:
The number of rows updated.
Throws:
java.lang.NullPointerException if uri or values are null
715
 
716
     public final int update(Uri uri, ContentValues values, String where,
717
             String[] selectionArgs) {
718
         IContentProvider provider = acquireProvider(uri);
719
         if (provider == null) {
720
             throw new IllegalArgumentException("Unknown URI " + uri);
721
         }
722
         try {
723
             long startTime = SystemClock.uptimeMillis();
724
             int rowsUpdated = provider.update(uri, values, where, selectionArgs);
725
             long durationMillis = SystemClock.uptimeMillis() - startTime;
726
             maybeLogUpdateToEventLog(durationMillis, uri, "update", where);
727
             return rowsUpdated;
728
         } catch (RemoteException e) {
729
             return -1;
730
         } finally {
731
             releaseProvider(provider);
732
         }
733
     }

    
Returns the content provider for the given content URI.

Parameters:
uri The URI to a content provider
Returns:
The ContentProvider for the given URI, or null if no content provider is found.
Hide:
741
 
742
     public final IContentProvider acquireProvider(Uri uri) {
743
         if (!.equals(uri.getScheme())) {
744
             return null;
745
         }
746
         String auth = uri.getAuthority();
747
         if (auth != null) {
748
             return acquireProvider(, uri.getAuthority());
749
         }
750
         return null;
751
     }

    
Returns the content provider for the given content URI if the process already has a reference on it.

Parameters:
uri The URI to a content provider
Returns:
The ContentProvider for the given URI, or null if no content provider is found.
Hide:
760
 
761
     public final IContentProvider acquireExistingProvider(Uri uri) {
762
         if (!.equals(uri.getScheme())) {
763
             return null;
764
         }
765
         String auth = uri.getAuthority();
766
         if (auth != null) {
767
             return acquireExistingProvider(, uri.getAuthority());
768
         }
769
         return null;
770
     }

    

Hide:
774
 
775
     public final IContentProvider acquireProvider(String name) {
776
         if (name == null) {
777
             return null;
778
         }
779
         return acquireProvider(, name);
780
     }

    
Returns a ContentProviderClient that is associated with the 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 ContentProviderClient.release() which will allow the system to release the provider it it determines that there is no other reason for keeping it active.

Parameters:
uri specifies which provider should be acquired
Returns:
a ContentProviderClient that is associated with the ContentProvider that services the content at uri or null if there isn't one.
792
 
793
     public final ContentProviderClient acquireContentProviderClient(Uri uri) {
794
         IContentProvider provider = acquireProvider(uri);
795
         if (provider != null) {
796
             return new ContentProviderClient(this, provider);
797
         }
798
 
799
         return null;
800
     }

    
Returns a ContentProviderClient that is associated with the 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 ContentProviderClient.release() which will allow the system to release the provider it it determines that there is no other reason for keeping it active.

Parameters:
name specifies which provider should be acquired
Returns:
a ContentProviderClient that is associated with the ContentProvider with the authority of name or null if there isn't one.
812
 
814
         IContentProvider provider = acquireProvider(name);
815
         if (provider != null) {
816
             return new ContentProviderClient(this, provider);
817
         }
818
 
819
         return null;
820
     }

    
Register an observer class that gets callbacks when data identified by a given content URI changes.

Parameters:
uri The URI to watch for changes. This can be a specific row URI, or a base URI for a whole class of content.
notifyForDescendents If true changes to URIs beginning with uri will also cause notifications to be sent. If false only changes to the exact URI specified by uri will cause notifications to be sent. If true, than any URI values at or below the specified URI will also trigger a match.
observer The object that receives callbacks when changes occur.
See also:
unregisterContentObserver(android.database.ContentObserver)
834
 
835
     public final void registerContentObserver(Uri uri, boolean notifyForDescendents,
836
             ContentObserver observer)
837
     {
838
         try {
839
             getContentService().registerContentObserver(uri, notifyForDescendents,
840
                     observer.getContentObserver());
841
         } catch (RemoteException e) {
842
         }
843
     }

    
Unregisters a change observer.

Parameters:
observer The previously registered observer that is no longer needed.
See also:
registerContentObserver(android.net.Uri,boolean,android.database.ContentObserver)
850
 
851
     public final void unregisterContentObserver(ContentObserver observer) {
852
         try {
853
             IContentObserver contentObserver = observer.releaseContentObserver();
854
             if (contentObserver != null) {
855
                 getContentService().unregisterContentObserver(
856
                         contentObserver);
857
             }
858
         } catch (RemoteException e) {
859
         }
860
     }

    
Notify registered observers that a row was updated. To register, call registerContentObserver(). By default, CursorAdapter objects will get this notification.

Parameters:
uri
observer The observer that originated the change, may be null</null>
869
 
870
     public void notifyChange(Uri uri, ContentObserver observer) {
871
         notifyChange(uri, observer, true /* sync to network */);
872
     }

    
Notify registered observers that a row was updated. To register, call registerContentObserver(). By default, CursorAdapter objects will get this notification.

Parameters:
uri
observer The observer that originated the change, may be null</null>
syncToNetwork If true, attempt to sync the change to the network.
882
 
883
     public void notifyChange(Uri uri, ContentObserver observer, boolean syncToNetwork) {
884
         try {
885
             getContentService().notifyChange(
886
                     uri, observer == null ? null : observer.getContentObserver(),
887
                     observer != null && observer.deliverSelfNotifications(), syncToNetwork);
888
         } catch (RemoteException e) {
889
         }
890
     }

    
Start an asynchronous sync operation. If you want to monitor the progress of the sync you may register a SyncObserver. Only values of the following types may be used in the extras bundle:
  • Integer
  • Long
  • Boolean
  • Float
  • Double
  • String

Deprecated:
instead use requestSync(android.accounts.Account,java.lang.String,android.os.Bundle)
Parameters:
uri the uri of the provider to sync or null to sync all providers.
extras any extras to pass to the SyncAdapter.
909
 
910
     @Deprecated
911
     public void startSync(Uri uri, Bundle extras) {
912
         Account account = null;
913
         if (extras != null) {
914
             String accountName = extras.getString();
915
             if (!TextUtils.isEmpty(accountName)) {
916
                 account = new Account(accountName, "com.google");
917
             }
918
             extras.remove();
919
         }
920
         requestSync(account, uri != null ? uri.getAuthority() : null, extras);
921
     }

    
Start an asynchronous sync operation. If you want to monitor the progress of the sync you may register a SyncObserver. Only values of the following types may be used in the extras bundle:
  • Integer
  • Long
  • Boolean
  • Float
  • Double
  • String

Parameters:
account which account should be synced
authority which authority should be synced
extras any extras to pass to the SyncAdapter.
939
 
940
     public static void requestSync(Account account, String authority, Bundle extras) {
941
         validateSyncExtrasBundle(extras);
942
         try {
943
             getContentService().requestSync(account, authority, extras);
944
         } catch (RemoteException e) {
945
         }
946
     }

    
Check that only values of the following types are in the Bundle:
  • Integer
  • Long
  • Boolean
  • Float
  • Double
  • String
  • Account
  • null

Parameters:
extras the Bundle to check
961
 
962
     public static void validateSyncExtrasBundle(Bundle extras) {
963
         try {
964
             for (String key : extras.keySet()) {
965
                 Object value = extras.get(key);
966
                 if (value == null) continue;
967
                 if (value instanceof Long) continue;
968
                 if (value instanceof Integer) continue;
969
                 if (value instanceof Boolean) continue;
970
                 if (value instanceof Float) continue;
971
                 if (value instanceof Double) continue;
972
                 if (value instanceof String) continue;
973
                 if (value instanceof Account) continue;
974
                 throw new IllegalArgumentException("unexpected value type: "
975
                         + value.getClass().getName());
976
             }
977
         } catch (IllegalArgumentException e) {
978
             throw e;
979
         } catch (RuntimeException exc) {
980
             throw new IllegalArgumentException("error unparceling Bundle", exc);
981
         }
982
     }

    
Cancel any active or pending syncs that match the Uri. If the uri is null then all syncs will be canceled.

Deprecated:
instead use cancelSync(android.accounts.Account,java.lang.String)
Parameters:
uri the uri of the provider to sync or null to sync all providers.
990
 
991
     @Deprecated
992
     public void cancelSync(Uri uri) {
993
         cancelSync(null /* all accounts */, uri != null ? uri.getAuthority() : null);
994
     }

    
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.

Parameters:
account filters the syncs that match by this account
authority filters the syncs that match by this authority
1004
    public static void cancelSync(Account account, String authority) {
1005
        try {
1006
            getContentService().cancelSync(account, authority);
1007
        } catch (RemoteException e) {
1008
        }
1009
    }

    
Get information about the SyncAdapters that are known to the system.

Returns:
an array of SyncAdapters that have registered with the system
1015
    public static SyncAdapterType[] getSyncAdapterTypes() {
1016
        try {
1017
            return getContentService().getSyncAdapterTypes();
1018
        } catch (RemoteException e) {
1019
            throw new RuntimeException("the ContentService should always be reachable", e);
1020
        }
1021
    }

    
Check if the provider should be synced when a network tickle is received

Parameters:
account the account whose setting we are querying
authority the provider whose setting we are querying
Returns:
true if the provider should be synced when a network tickle is received
1030
    public static boolean getSyncAutomatically(Account account, String authority) {
1031
        try {
1032
            return getContentService().getSyncAutomatically(account, authority);
1033
        } catch (RemoteException e) {
1034
            throw new RuntimeException("the ContentService should always be reachable", e);
1035
        }
1036
    }

    
Set whether or not the provider is synced when it receives a network tickle.

Parameters:
account the account whose setting we are querying
authority the provider whose behavior is being controlled
sync true if the provider should be synced when tickles are received for it
1045
    public static void setSyncAutomatically(Account account, String authority, boolean sync) {
1046
        try {
1047
            getContentService().setSyncAutomatically(account, authority, sync);
1048
        } catch (RemoteException e) {
1049
            // exception ignored; if this is thrown then it means the runtime is in the midst of
1050
            // being restarted
1051
        }
1052
    }

    
Specifies that a sync should be requested with the specified the account, authority, and extras at the given frequency. If there is already another periodic sync scheduled with the account, authority and extras then a new periodic sync won't be added, instead the frequency of the previous one will be updated.

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

Periodic syncs are not allowed to have any of SYNC_EXTRAS_DO_NOT_RETRY, SYNC_EXTRAS_IGNORE_BACKOFF, SYNC_EXTRAS_IGNORE_SETTINGS, SYNC_EXTRAS_INITIALIZE, SYNC_EXTRAS_FORCE, SYNC_EXTRAS_EXPEDITED, SYNC_EXTRAS_MANUAL set to true. If any are supplied then an java.lang.IllegalArgumentException will be thrown.

Parameters:
account the account to specify in the sync
authority the provider to specify in the sync request
extras extra parameters to go along with the sync request
pollFrequency how frequently the sync should be performed, in seconds.
Throws:
java.lang.IllegalArgumentException if an illegal extra was set or if any of the parameters are null.
1078
    public static void addPeriodicSync(Account account, String authority, Bundle extras,
1079
            long pollFrequency) {
1080
        validateSyncExtrasBundle(extras);
1081
        if (account == null) {
1082
            throw new IllegalArgumentException("account must not be null");
1083
        }
1084
        if (authority == null) {
1085
            throw new IllegalArgumentException("authority must not be null");
1086
        }
1087
        if (extras.getBoolean(, false)
1088
                || extras.getBoolean(, false)
1089
                || extras.getBoolean(, false)
1090
                || extras.getBoolean(, false)
1091
                || extras.getBoolean(, false)
1092
                || extras.getBoolean(, false)
1093
                || extras.getBoolean(, false)) {
1094
            throw new IllegalArgumentException("illegal extras were set");
1095
        }
1096
        try {
1097
            getContentService().addPeriodicSync(account, authority, extras, pollFrequency);
1098
        } catch (RemoteException e) {
1099
            // exception ignored; if this is thrown then it means the runtime is in the midst of
1100
            // being restarted
1101
        }
1102
    }

    
Remove a periodic sync. Has no affect if account, authority and extras don't match an existing periodic sync.

Parameters:
account the account of the periodic sync to remove
authority the provider of the periodic sync to remove
extras the extras of the periodic sync to remove
1112
    public static void removePeriodicSync(Account account, String authority, Bundle extras) {
1113
        validateSyncExtrasBundle(extras);
1114
        if (account == null) {
1115
            throw new IllegalArgumentException("account must not be null");
1116
        }
1117
        if (authority == null) {
1118
            throw new IllegalArgumentException("authority must not be null");
1119
        }
1120
        try {
1121
            getContentService().removePeriodicSync(account, authority, extras);
1122
        } catch (RemoteException e) {
1123
            throw new RuntimeException("the ContentService should always be reachable", e);
1124
        }
1125
    }

    
Get the list of information about the periodic syncs for the given account and authority.

Parameters:
account the account whose periodic syncs we are querying
authority the provider whose periodic syncs we are querying
Returns:
a list of PeriodicSync objects. This list may be empty but will never be null.
1134
    public static List<PeriodicSync> getPeriodicSyncs(Account account, String authority) {
1135
        if (account == null) {
1136
            throw new IllegalArgumentException("account must not be null");
1137
        }
1138
        if (authority == null) {
1139
            throw new IllegalArgumentException("authority must not be null");
1140
        }
1141
        try {
1142
            return getContentService().getPeriodicSyncs(account, authority);
1143
        } catch (RemoteException e) {
1144
            throw new RuntimeException("the ContentService should always be reachable", e);
1145
        }
1146
    }

    
Check if this account/provider is syncable.

Returns:
>0 if it is syncable, 0 if not, and <0 if the state isn't known yet.
1152
    public static int getIsSyncable(Account account, String authority) {
1153
        try {
1154
            return getContentService().getIsSyncable(account, authority);
1155
        } catch (RemoteException e) {
1156
            throw new RuntimeException("the ContentService should always be reachable", e);
1157
        }
1158
    }

    
Set whether this account/provider is syncable.

Parameters:
syncable >0 denotes syncable, 0 means not syncable, <0 means unknown
1164
    public static void setIsSyncable(Account account, String authority, int syncable) {
1165
        try {
1166
            getContentService().setIsSyncable(account, authority, syncable);
1167
        } catch (RemoteException e) {
1168
            // exception ignored; if this is thrown then it means the runtime is in the midst of
1169
            // being restarted
1170
        }
1171
    }

    
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.

Returns:
the master auto-sync setting that applies to all the providers and accounts
1179
    public static boolean getMasterSyncAutomatically() {
1180
        try {
1181
            return getContentService().getMasterSyncAutomatically();
1182
        } catch (RemoteException e) {
1183
            throw new RuntimeException("the ContentService should always be reachable", e);
1184
        }
1185
    }

    
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.

Parameters:
sync the master auto-sync setting that applies to all the providers and accounts
1193
    public static void setMasterSyncAutomatically(boolean sync) {
1194
        try {
1195
            getContentService().setMasterSyncAutomatically(sync);
1196
        } catch (RemoteException e) {
1197
            // exception ignored; if this is thrown then it means the runtime is in the midst of
1198
            // being restarted
1199
        }
1200
    }

    
Returns true if there is currently a sync operation for the given account or authority in the pending list, or actively being processed.

Parameters:
account the account whose setting we are querying
authority the provider whose behavior is being queried
Returns:
true if a sync is active for the given account or authority.
1209
    public static boolean isSyncActive(Account account, String authority) {
1210
        try {
1211
            return getContentService().isSyncActive(account, authority);
1212
        } catch (RemoteException e) {
1213
            throw new RuntimeException("the ContentService should always be reachable", e);
1214
        }
1215
    }

    
If a sync is active returns the information about it, otherwise returns false.

Returns:
the SyncInfo for the currently active sync or null if one is not active.
1221
    public static SyncInfo getCurrentSync() {
1222
        try {
1223
            return getContentService().getCurrentSync();
1224
        } catch (RemoteException e) {
1225
            throw new RuntimeException("the ContentService should always be reachable", e);
1226
        }
1227
    }

    
Returns the status that matches the authority.

Parameters:
account the account whose setting we are querying
authority the provider whose behavior is being queried
Returns:
the SyncStatusInfo for the authority, or null if none exists
Hide:
1236
    public static SyncStatusInfo getSyncStatus(Account account, String authority) {
1237
        try {
1238
            return getContentService().getSyncStatus(account, authority);
1239
        } catch (RemoteException e) {
1240
            throw new RuntimeException("the ContentService should always be reachable", e);
1241
        }
1242
    }

    
Return true if the pending status is true of any matching authorities.

Parameters:
account the account whose setting we are querying
authority the provider whose behavior is being queried
Returns:
true if there is a pending sync with the matching account and authority
1250
    public static boolean isSyncPending(Account account, String authority) {
1251
        try {
1252
            return getContentService().isSyncPending(account, authority);
1253
        } catch (RemoteException e) {
1254
            throw new RuntimeException("the ContentService should always be reachable", e);
1255
        }
1256
    }

    
Request notifications when the different aspects of the SyncManager change. The different items that can be requested are: The caller can set one or more of the status types in the mask for any given listener registration.

Parameters:
mask the status change types that will cause the callback to be invoked
callback observer to be invoked when the status changes
Returns:
a handle that can be used to remove the listener at a later time
1272
    public static Object addStatusChangeListener(int mask, final SyncStatusObserver callback) {
1273
        if (callback == null) {
1274
            throw new IllegalArgumentException("you passed in a null callback");
1275
        }
1276
        try {
1277
            ISyncStatusObserver.Stub observer = new ISyncStatusObserver.Stub() {
1278
                public void onStatusChanged(int which) throws RemoteException {
1279
                    callback.onStatusChanged(which);
1280
                }
1281
            };
1282
            getContentService().addStatusChangeListener(mask, observer);
1283
            return observer;
1284
        } catch (RemoteException e) {
1285
            throw new RuntimeException("the ContentService should always be reachable", e);
1286
        }
1287
    }

    
Remove a previously registered status change listener.

Parameters:
handle the handle that was returned by addStatusChangeListener(int,android.content.SyncStatusObserver)
1293
    public static void removeStatusChangeListener(Object handle) {
1294
        if (handle == null) {
1295
            throw new IllegalArgumentException("you passed in a null handle");
1296
        }
1297
        try {
1299
        } catch (RemoteException e) {
1300
            // exception ignored; if this is thrown then it means the runtime is in the midst of
1301
            // being restarted
1302
        }
1303
    }

    
Returns sampling percentage for a given duration. Always returns at least 1%. 
1310
    private int samplePercentForDuration(long durationMillis) {
1311
        if (durationMillis >= ) {
1312
            return 100;
1313
        }
1314
        return (int) (100 * durationMillis / ) + 1;
1315
    }
1317
    private void maybeLogQueryToEventLog(long durationMillis,
1318
                                         Uri uri, String[] projection,
1319
                                         String selection, String sortOrder) {
1320
        int samplePercent = samplePercentForDuration(durationMillis);
1321
        if (samplePercent < 100) {
1322
            synchronized () {
1323
                if (.nextInt(100) >= samplePercent) {
1324
                    return;
1325
                }
1326
            }
1327
        }
1329
        StringBuilder projectionBuffer = new StringBuilder(100);
1330
        if (projection != null) {
1331
            for (int i = 0; i < projection.length; ++i) {
1332
                // Note: not using a comma delimiter here, as the
1333
                // multiple arguments to EventLog.writeEvent later
1334
                // stringify with a comma delimiter, which would make
1335
                // parsing uglier later.
1336
                if (i != 0) projectionBuffer.append('/');
1337
                projectionBuffer.append(projection[i]);
1338
            }
1339
        }
1341
        // ActivityThread.currentPackageName() only returns non-null if the
1342
        // current thread is an application main thread.  This parameter tells
1343
        // us whether an event loop is blocked, and if so, which app it is.
1344
        String blockingPackage = AppGlobals.getInitialPackage();
1346
        EventLog.writeEvent(
1347
            .,
1348
            uri.toString(),
1349
            projectionBuffer.toString(),
1350
            selection != null ? selection : "",
1351
            sortOrder != null ? sortOrder : "",
1352
            durationMillis,
1353
            blockingPackage != null ? blockingPackage : "",
1354
            samplePercent);
1355
    }
1357
    private void maybeLogUpdateToEventLog(
1358
        long durationMillis, Uri uri, String operation, String selection) {
1359
        int samplePercent = samplePercentForDuration(durationMillis);
1360
        if (samplePercent < 100) {
1361
            synchronized () {
1362
                if (.nextInt(100) >= samplePercent) {
1363
                    return;
1364
                }
1365
            }
1366
        }
1367
        String blockingPackage = AppGlobals.getInitialPackage();
1368
        EventLog.writeEvent(
1369
            .,
1370
            uri.toString(),
1371
            operation,
1372
            selection != null ? selection : "",
1373
            durationMillis,
1374
            blockingPackage != null ? blockingPackage : "",
1375
            samplePercent);
1376
    }
1378
    private final class CursorWrapperInner extends CursorWrapper {
1379
        private IContentProvider mContentProvider;
1380
        public static final String TAG="CursorWrapperInner";
1381
        private boolean mCloseFlag = false;
1383
        CursorWrapperInner(Cursor cursor, IContentProvider icp) {
1384
            super(cursor);
1385
             = icp;
1386
        }
1388
        @Override
1389
        public void close() {
1390
            super.close();
1392
             = true;
1393
        }
1395
        @Override
1396
        protected void finalize() throws Throwable {
1397
            try {
1398
                if(!) {
1399
                    ContentResolver.this.releaseProvider();
1400
                }
1401
            } finally {
1402
                super.finalize();
1403
            }
1404
        }
1405
    }
1407
    private final class ParcelFileDescriptorInner extends ParcelFileDescriptor {
1408
        private IContentProvider mContentProvider;
1409
        public static final String TAG="ParcelFileDescriptorInner";
1410
        private boolean mReleaseProviderFlag = false;
1413
            super(pfd);
1414
             = icp;
1415
        }
1417
        @Override
1418
        public void close() throws IOException {
1419
            if(!) {
1420
                super.close();
1421
                ContentResolver.this.releaseProvider();
1422
                 = true;
1423
            }
1424
        }
1426
        @Override
1427
        protected void finalize() throws Throwable {
1428
            if (!) {
1429
                close();
1430
            }
1431
        }
1432
    }

    

Hide:
1435
    public static final String CONTENT_SERVICE_NAME = "content";

    

Hide:
1438
    public static IContentService getContentService() {
1439
        if ( != null) {
1440
            return ;
1441
        }
1442
        IBinder b = ServiceManager.getService();
1443
        if (.) Log.v("ContentService", "default service binder = " + b);
1444
         = IContentService.Stub.asInterface(b);
1445
        if (.) Log.v("ContentService", "default service = " + );
1446
        return ;
1447
    }
1449
    private static IContentService sContentService;
1450
    private final Context mContext;
1451
    private static final String TAG = "ContentResolver";
New to GrepCode? Check out our FAQ X