ContentProvider.java revision cca1f0e3476edd09cdd81b075a6b7780a2959b46
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 17package android.content; 18 19import android.content.pm.PackageManager; 20import android.content.pm.PathPermission; 21import android.content.pm.ProviderInfo; 22import android.content.res.AssetFileDescriptor; 23import android.content.res.Configuration; 24import android.database.Cursor; 25import android.database.CursorToBulkCursorAdaptor; 26import android.database.CursorWindow; 27import android.database.IBulkCursor; 28import android.database.IContentObserver; 29import android.database.SQLException; 30import android.net.Uri; 31import android.os.AsyncTask; 32import android.os.Binder; 33import android.os.Bundle; 34import android.os.ParcelFileDescriptor; 35import android.os.Process; 36import android.util.Log; 37 38import java.io.File; 39import java.io.FileNotFoundException; 40import java.io.IOException; 41import java.util.ArrayList; 42 43/** 44 * Content providers are one of the primary building blocks of Android applications, providing 45 * content to applications. They encapsulate data and provide it to applications through the single 46 * {@link ContentResolver} interface. A content provider is only required if you need to share 47 * data between multiple applications. For example, the contacts data is used by multiple 48 * applications and must be stored in a content provider. If you don't need to share data amongst 49 * multiple applications you can use a database directly via 50 * {@link android.database.sqlite.SQLiteDatabase}. 51 * 52 * <p>For more information, read <a href="{@docRoot}guide/topics/providers/content-providers.html">Content 53 * Providers</a>.</p> 54 * 55 * <p>When a request is made via 56 * a {@link ContentResolver} the system inspects the authority of the given URI and passes the 57 * request to the content provider registered with the authority. The content provider can interpret 58 * the rest of the URI however it wants. The {@link UriMatcher} class is helpful for parsing 59 * URIs.</p> 60 * 61 * <p>The primary methods that need to be implemented are: 62 * <ul> 63 * <li>{@link #onCreate} which is called to initialize the provider</li> 64 * <li>{@link #query} which returns data to the caller</li> 65 * <li>{@link #insert} which inserts new data into the content provider</li> 66 * <li>{@link #update} which updates existing data in the content provider</li> 67 * <li>{@link #delete} which deletes data from the content provider</li> 68 * <li>{@link #getType} which returns the MIME type of data in the content provider</li> 69 * </ul></p> 70 * 71 * <p class="caution">Data access methods (such as {@link #insert} and 72 * {@link #update}) may be called from many threads at once, and must be thread-safe. 73 * Other methods (such as {@link #onCreate}) are only called from the application 74 * main thread, and must avoid performing lengthy operations. See the method 75 * descriptions for their expected thread behavior.</p> 76 * 77 * <p>Requests to {@link ContentResolver} are automatically forwarded to the appropriate 78 * ContentProvider instance, so subclasses don't have to worry about the details of 79 * cross-process calls.</p> 80 */ 81public abstract class ContentProvider implements ComponentCallbacks { 82 private static final String TAG = "ContentProvider"; 83 84 /* 85 * Note: if you add methods to ContentProvider, you must add similar methods to 86 * MockContentProvider. 87 */ 88 89 private Context mContext = null; 90 private int mMyUid; 91 private String mReadPermission; 92 private String mWritePermission; 93 private PathPermission[] mPathPermissions; 94 private boolean mExported; 95 96 private Transport mTransport = new Transport(); 97 98 /** 99 * Construct a ContentProvider instance. Content providers must be 100 * <a href="{@docRoot}guide/topics/manifest/provider-element.html">declared 101 * in the manifest</a>, accessed with {@link ContentResolver}, and created 102 * automatically by the system, so applications usually do not create 103 * ContentProvider instances directly. 104 * 105 * <p>At construction time, the object is uninitialized, and most fields and 106 * methods are unavailable. Subclasses should initialize themselves in 107 * {@link #onCreate}, not the constructor. 108 * 109 * <p>Content providers are created on the application main thread at 110 * application launch time. The constructor must not perform lengthy 111 * operations, or application startup will be delayed. 112 */ 113 public ContentProvider() { 114 } 115 116 /** 117 * Constructor just for mocking. 118 * 119 * @param context A Context object which should be some mock instance (like the 120 * instance of {@link android.test.mock.MockContext}). 121 * @param readPermission The read permision you want this instance should have in the 122 * test, which is available via {@link #getReadPermission()}. 123 * @param writePermission The write permission you want this instance should have 124 * in the test, which is available via {@link #getWritePermission()}. 125 * @param pathPermissions The PathPermissions you want this instance should have 126 * in the test, which is available via {@link #getPathPermissions()}. 127 * @hide 128 */ 129 public ContentProvider( 130 Context context, 131 String readPermission, 132 String writePermission, 133 PathPermission[] pathPermissions) { 134 mContext = context; 135 mReadPermission = readPermission; 136 mWritePermission = writePermission; 137 mPathPermissions = pathPermissions; 138 } 139 140 /** 141 * Given an IContentProvider, try to coerce it back to the real 142 * ContentProvider object if it is running in the local process. This can 143 * be used if you know you are running in the same process as a provider, 144 * and want to get direct access to its implementation details. Most 145 * clients should not nor have a reason to use it. 146 * 147 * @param abstractInterface The ContentProvider interface that is to be 148 * coerced. 149 * @return If the IContentProvider is non-null and local, returns its actual 150 * ContentProvider instance. Otherwise returns null. 151 * @hide 152 */ 153 public static ContentProvider coerceToLocalContentProvider( 154 IContentProvider abstractInterface) { 155 if (abstractInterface instanceof Transport) { 156 return ((Transport)abstractInterface).getContentProvider(); 157 } 158 return null; 159 } 160 161 /** 162 * Binder object that deals with remoting. 163 * 164 * @hide 165 */ 166 class Transport extends ContentProviderNative { 167 ContentProvider getContentProvider() { 168 return ContentProvider.this; 169 } 170 171 /** 172 * Remote version of a query, which returns an IBulkCursor. The bulk 173 * cursor should be wrapped with BulkCursorToCursorAdaptor before use. 174 */ 175 public IBulkCursor bulkQuery(Uri uri, String[] projection, 176 String selection, String[] selectionArgs, String sortOrder, 177 IContentObserver observer, CursorWindow window) { 178 enforceReadPermission(uri); 179 Cursor cursor = ContentProvider.this.query(uri, projection, 180 selection, selectionArgs, sortOrder); 181 if (cursor == null) { 182 return null; 183 } 184 return new CursorToBulkCursorAdaptor(cursor, observer, 185 ContentProvider.this.getClass().getName(), 186 hasWritePermission(uri), window); 187 } 188 189 public Cursor query(Uri uri, String[] projection, 190 String selection, String[] selectionArgs, String sortOrder) { 191 enforceReadPermission(uri); 192 return ContentProvider.this.query(uri, projection, selection, 193 selectionArgs, sortOrder); 194 } 195 196 public String getType(Uri uri) { 197 return ContentProvider.this.getType(uri); 198 } 199 200 201 public Uri insert(Uri uri, ContentValues initialValues) { 202 enforceWritePermission(uri); 203 return ContentProvider.this.insert(uri, initialValues); 204 } 205 206 public int bulkInsert(Uri uri, ContentValues[] initialValues) { 207 enforceWritePermission(uri); 208 return ContentProvider.this.bulkInsert(uri, initialValues); 209 } 210 211 public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations) 212 throws OperationApplicationException { 213 for (ContentProviderOperation operation : operations) { 214 if (operation.isReadOperation()) { 215 enforceReadPermission(operation.getUri()); 216 } 217 218 if (operation.isWriteOperation()) { 219 enforceWritePermission(operation.getUri()); 220 } 221 } 222 return ContentProvider.this.applyBatch(operations); 223 } 224 225 public int delete(Uri uri, String selection, String[] selectionArgs) { 226 enforceWritePermission(uri); 227 return ContentProvider.this.delete(uri, selection, selectionArgs); 228 } 229 230 public int update(Uri uri, ContentValues values, String selection, 231 String[] selectionArgs) { 232 enforceWritePermission(uri); 233 return ContentProvider.this.update(uri, values, selection, selectionArgs); 234 } 235 236 public ParcelFileDescriptor openFile(Uri uri, String mode) 237 throws FileNotFoundException { 238 if (mode != null && mode.startsWith("rw")) enforceWritePermission(uri); 239 else enforceReadPermission(uri); 240 return ContentProvider.this.openFile(uri, mode); 241 } 242 243 public AssetFileDescriptor openAssetFile(Uri uri, String mode) 244 throws FileNotFoundException { 245 if (mode != null && mode.startsWith("rw")) enforceWritePermission(uri); 246 else enforceReadPermission(uri); 247 return ContentProvider.this.openAssetFile(uri, mode); 248 } 249 250 /** 251 * @hide 252 */ 253 public Bundle call(String method, String request, Bundle args) { 254 return ContentProvider.this.call(method, request, args); 255 } 256 257 @Override 258 public String[] getStreamTypes(Uri uri, String mimeTypeFilter) { 259 return ContentProvider.this.getStreamTypes(uri, mimeTypeFilter); 260 } 261 262 @Override 263 public AssetFileDescriptor openTypedAssetFile(Uri uri, String mimeType, Bundle opts) 264 throws FileNotFoundException { 265 enforceReadPermission(uri); 266 return ContentProvider.this.openTypedAssetFile(uri, mimeType, opts); 267 } 268 269 private void enforceReadPermission(Uri uri) { 270 final int uid = Binder.getCallingUid(); 271 if (uid == mMyUid) { 272 return; 273 } 274 275 final Context context = getContext(); 276 final String rperm = getReadPermission(); 277 final int pid = Binder.getCallingPid(); 278 if (mExported && (rperm == null 279 || context.checkPermission(rperm, pid, uid) 280 == PackageManager.PERMISSION_GRANTED)) { 281 return; 282 } 283 284 PathPermission[] pps = getPathPermissions(); 285 if (pps != null) { 286 final String path = uri.getPath(); 287 int i = pps.length; 288 while (i > 0) { 289 i--; 290 final PathPermission pp = pps[i]; 291 final String pprperm = pp.getReadPermission(); 292 if (pprperm != null && pp.match(path)) { 293 if (context.checkPermission(pprperm, pid, uid) 294 == PackageManager.PERMISSION_GRANTED) { 295 return; 296 } 297 } 298 } 299 } 300 301 if (context.checkUriPermission(uri, pid, uid, 302 Intent.FLAG_GRANT_READ_URI_PERMISSION) 303 == PackageManager.PERMISSION_GRANTED) { 304 return; 305 } 306 307 String msg = "Permission Denial: reading " 308 + ContentProvider.this.getClass().getName() 309 + " uri " + uri + " from pid=" + Binder.getCallingPid() 310 + ", uid=" + Binder.getCallingUid() 311 + " requires " + rperm; 312 throw new SecurityException(msg); 313 } 314 315 private boolean hasWritePermission(Uri uri) { 316 final int uid = Binder.getCallingUid(); 317 if (uid == mMyUid) { 318 return true; 319 } 320 321 final Context context = getContext(); 322 final String wperm = getWritePermission(); 323 final int pid = Binder.getCallingPid(); 324 if (mExported && (wperm == null 325 || context.checkPermission(wperm, pid, uid) 326 == PackageManager.PERMISSION_GRANTED)) { 327 return true; 328 } 329 330 PathPermission[] pps = getPathPermissions(); 331 if (pps != null) { 332 final String path = uri.getPath(); 333 int i = pps.length; 334 while (i > 0) { 335 i--; 336 final PathPermission pp = pps[i]; 337 final String ppwperm = pp.getWritePermission(); 338 if (ppwperm != null && pp.match(path)) { 339 if (context.checkPermission(ppwperm, pid, uid) 340 == PackageManager.PERMISSION_GRANTED) { 341 return true; 342 } 343 } 344 } 345 } 346 347 if (context.checkUriPermission(uri, pid, uid, 348 Intent.FLAG_GRANT_WRITE_URI_PERMISSION) 349 == PackageManager.PERMISSION_GRANTED) { 350 return true; 351 } 352 353 return false; 354 } 355 356 private void enforceWritePermission(Uri uri) { 357 if (hasWritePermission(uri)) { 358 return; 359 } 360 361 String msg = "Permission Denial: writing " 362 + ContentProvider.this.getClass().getName() 363 + " uri " + uri + " from pid=" + Binder.getCallingPid() 364 + ", uid=" + Binder.getCallingUid() 365 + " requires " + getWritePermission(); 366 throw new SecurityException(msg); 367 } 368 } 369 370 371 /** 372 * Retrieves the Context this provider is running in. Only available once 373 * {@link #onCreate} has been called -- this will return null in the 374 * constructor. 375 */ 376 public final Context getContext() { 377 return mContext; 378 } 379 380 /** 381 * Change the permission required to read data from the content 382 * provider. This is normally set for you from its manifest information 383 * when the provider is first created. 384 * 385 * @param permission Name of the permission required for read-only access. 386 */ 387 protected final void setReadPermission(String permission) { 388 mReadPermission = permission; 389 } 390 391 /** 392 * Return the name of the permission required for read-only access to 393 * this content provider. This method can be called from multiple 394 * threads, as described in 395 * <a href="{@docRoot}guide/topics/fundamentals.html#procthread">Application Fundamentals: 396 * Processes and Threads</a>. 397 */ 398 public final String getReadPermission() { 399 return mReadPermission; 400 } 401 402 /** 403 * Change the permission required to read and write data in the content 404 * provider. This is normally set for you from its manifest information 405 * when the provider is first created. 406 * 407 * @param permission Name of the permission required for read/write access. 408 */ 409 protected final void setWritePermission(String permission) { 410 mWritePermission = permission; 411 } 412 413 /** 414 * Return the name of the permission required for read/write access to 415 * this content provider. This method can be called from multiple 416 * threads, as described in 417 * <a href="{@docRoot}guide/topics/fundamentals.html#procthread">Application Fundamentals: 418 * Processes and Threads</a>. 419 */ 420 public final String getWritePermission() { 421 return mWritePermission; 422 } 423 424 /** 425 * Change the path-based permission required to read and/or write data in 426 * the content provider. This is normally set for you from its manifest 427 * information when the provider is first created. 428 * 429 * @param permissions Array of path permission descriptions. 430 */ 431 protected final void setPathPermissions(PathPermission[] permissions) { 432 mPathPermissions = permissions; 433 } 434 435 /** 436 * Return the path-based permissions required for read and/or write access to 437 * this content provider. This method can be called from multiple 438 * threads, as described in 439 * <a href="{@docRoot}guide/topics/fundamentals.html#procthread">Application Fundamentals: 440 * Processes and Threads</a>. 441 */ 442 public final PathPermission[] getPathPermissions() { 443 return mPathPermissions; 444 } 445 446 /** 447 * Implement this to initialize your content provider on startup. 448 * This method is called for all registered content providers on the 449 * application main thread at application launch time. It must not perform 450 * lengthy operations, or application startup will be delayed. 451 * 452 * <p>You should defer nontrivial initialization (such as opening, 453 * upgrading, and scanning databases) until the content provider is used 454 * (via {@link #query}, {@link #insert}, etc). Deferred initialization 455 * keeps application startup fast, avoids unnecessary work if the provider 456 * turns out not to be needed, and stops database errors (such as a full 457 * disk) from halting application launch. 458 * 459 * <p>If you use SQLite, {@link android.database.sqlite.SQLiteOpenHelper} 460 * is a helpful utility class that makes it easy to manage databases, 461 * and will automatically defer opening until first use. If you do use 462 * SQLiteOpenHelper, make sure to avoid calling 463 * {@link android.database.sqlite.SQLiteOpenHelper#getReadableDatabase} or 464 * {@link android.database.sqlite.SQLiteOpenHelper#getWritableDatabase} 465 * from this method. (Instead, override 466 * {@link android.database.sqlite.SQLiteOpenHelper#onOpen} to initialize the 467 * database when it is first opened.) 468 * 469 * @return true if the provider was successfully loaded, false otherwise 470 */ 471 public abstract boolean onCreate(); 472 473 /** 474 * {@inheritDoc} 475 * This method is always called on the application main thread, and must 476 * not perform lengthy operations. 477 * 478 * <p>The default content provider implementation does nothing. 479 * Override this method to take appropriate action. 480 * (Content providers do not usually care about things like screen 481 * orientation, but may want to know about locale changes.) 482 */ 483 public void onConfigurationChanged(Configuration newConfig) { 484 } 485 486 /** 487 * {@inheritDoc} 488 * This method is always called on the application main thread, and must 489 * not perform lengthy operations. 490 * 491 * <p>The default content provider implementation does nothing. 492 * Subclasses may override this method to take appropriate action. 493 */ 494 public void onLowMemory() { 495 } 496 497 /** 498 * Implement this to handle query requests from clients. 499 * This method can be called from multiple threads, as described in 500 * <a href="{@docRoot}guide/topics/fundamentals.html#procthread">Application Fundamentals: 501 * Processes and Threads</a>. 502 * <p> 503 * Example client call:<p> 504 * <pre>// Request a specific record. 505 * Cursor managedCursor = managedQuery( 506 ContentUris.withAppendedId(Contacts.People.CONTENT_URI, 2), 507 projection, // Which columns to return. 508 null, // WHERE clause. 509 null, // WHERE clause value substitution 510 People.NAME + " ASC"); // Sort order.</pre> 511 * Example implementation:<p> 512 * <pre>// SQLiteQueryBuilder is a helper class that creates the 513 // proper SQL syntax for us. 514 SQLiteQueryBuilder qBuilder = new SQLiteQueryBuilder(); 515 516 // Set the table we're querying. 517 qBuilder.setTables(DATABASE_TABLE_NAME); 518 519 // If the query ends in a specific record number, we're 520 // being asked for a specific record, so set the 521 // WHERE clause in our query. 522 if((URI_MATCHER.match(uri)) == SPECIFIC_MESSAGE){ 523 qBuilder.appendWhere("_id=" + uri.getPathLeafId()); 524 } 525 526 // Make the query. 527 Cursor c = qBuilder.query(mDb, 528 projection, 529 selection, 530 selectionArgs, 531 groupBy, 532 having, 533 sortOrder); 534 c.setNotificationUri(getContext().getContentResolver(), uri); 535 return c;</pre> 536 * 537 * @param uri The URI to query. This will be the full URI sent by the client; 538 * if the client is requesting a specific record, the URI will end in a record number 539 * that the implementation should parse and add to a WHERE or HAVING clause, specifying 540 * that _id value. 541 * @param projection The list of columns to put into the cursor. If 542 * null all columns are included. 543 * @param selection A selection criteria to apply when filtering rows. 544 * If null then all rows are included. 545 * @param selectionArgs You may include ?s in selection, which will be replaced by 546 * the values from selectionArgs, in order that they appear in the selection. 547 * The values will be bound as Strings. 548 * @param sortOrder How the rows in the cursor should be sorted. 549 * If null then the provider is free to define the sort order. 550 * @return a Cursor or null. 551 */ 552 public abstract Cursor query(Uri uri, String[] projection, 553 String selection, String[] selectionArgs, String sortOrder); 554 555 /** 556 * Implement this to handle requests for the MIME type of the data at the 557 * given URI. The returned MIME type should start with 558 * <code>vnd.android.cursor.item</code> for a single record, 559 * or <code>vnd.android.cursor.dir/</code> for multiple items. 560 * This method can be called from multiple threads, as described in 561 * <a href="{@docRoot}guide/topics/fundamentals.html#procthread">Application Fundamentals: 562 * Processes and Threads</a>. 563 * 564 * <p>Note that there are no permissions needed for an application to 565 * access this information; if your content provider requires read and/or 566 * write permissions, or is not exported, all applications can still call 567 * this method regardless of their access permissions. This allows them 568 * to retrieve the MIME type for a URI when dispatching intents. 569 * 570 * @param uri the URI to query. 571 * @return a MIME type string, or null if there is no type. 572 */ 573 public abstract String getType(Uri uri); 574 575 /** 576 * Implement this to handle requests to insert a new row. 577 * As a courtesy, call {@link ContentResolver#notifyChange(android.net.Uri ,android.database.ContentObserver) notifyChange()} 578 * after inserting. 579 * This method can be called from multiple threads, as described in 580 * <a href="{@docRoot}guide/topics/fundamentals.html#procthread">Application Fundamentals: 581 * Processes and Threads</a>. 582 * @param uri The content:// URI of the insertion request. 583 * @param values A set of column_name/value pairs to add to the database. 584 * @return The URI for the newly inserted item. 585 */ 586 public abstract Uri insert(Uri uri, ContentValues values); 587 588 /** 589 * Override this to handle requests to insert a set of new rows, or the 590 * default implementation will iterate over the values and call 591 * {@link #insert} on each of them. 592 * As a courtesy, call {@link ContentResolver#notifyChange(android.net.Uri ,android.database.ContentObserver) notifyChange()} 593 * after inserting. 594 * This method can be called from multiple threads, as described in 595 * <a href="{@docRoot}guide/topics/fundamentals.html#procthread">Application Fundamentals: 596 * Processes and Threads</a>. 597 * 598 * @param uri The content:// URI of the insertion request. 599 * @param values An array of sets of column_name/value pairs to add to the database. 600 * @return The number of values that were inserted. 601 */ 602 public int bulkInsert(Uri uri, ContentValues[] values) { 603 int numValues = values.length; 604 for (int i = 0; i < numValues; i++) { 605 insert(uri, values[i]); 606 } 607 return numValues; 608 } 609 610 /** 611 * Implement this to handle requests to delete one or more rows. 612 * The implementation should apply the selection clause when performing 613 * deletion, allowing the operation to affect multiple rows in a directory. 614 * As a courtesy, call {@link ContentResolver#notifyChange(android.net.Uri ,android.database.ContentObserver) notifyDelete()} 615 * after deleting. 616 * This method can be called from multiple threads, as described in 617 * <a href="{@docRoot}guide/topics/fundamentals.html#procthread">Application Fundamentals: 618 * Processes and Threads</a>. 619 * 620 * <p>The implementation is responsible for parsing out a row ID at the end 621 * of the URI, if a specific row is being deleted. That is, the client would 622 * pass in <code>content://contacts/people/22</code> and the implementation is 623 * responsible for parsing the record number (22) when creating a SQL statement. 624 * 625 * @param uri The full URI to query, including a row ID (if a specific record is requested). 626 * @param selection An optional restriction to apply to rows when deleting. 627 * @return The number of rows affected. 628 * @throws SQLException 629 */ 630 public abstract int delete(Uri uri, String selection, String[] selectionArgs); 631 632 /** 633 * Implement this to handle requests to update one or more rows. 634 * The implementation should update all rows matching the selection 635 * to set the columns according to the provided values map. 636 * As a courtesy, call {@link ContentResolver#notifyChange(android.net.Uri ,android.database.ContentObserver) notifyChange()} 637 * after updating. 638 * This method can be called from multiple threads, as described in 639 * <a href="{@docRoot}guide/topics/fundamentals.html#procthread">Application Fundamentals: 640 * Processes and Threads</a>. 641 * 642 * @param uri The URI to query. This can potentially have a record ID if this 643 * is an update request for a specific record. 644 * @param values A Bundle mapping from column names to new column values (NULL is a 645 * valid value). 646 * @param selection An optional filter to match rows to update. 647 * @return the number of rows affected. 648 */ 649 public abstract int update(Uri uri, ContentValues values, String selection, 650 String[] selectionArgs); 651 652 /** 653 * Override this to handle requests to open a file blob. 654 * The default implementation always throws {@link FileNotFoundException}. 655 * This method can be called from multiple threads, as described in 656 * <a href="{@docRoot}guide/topics/fundamentals.html#procthread">Application Fundamentals: 657 * Processes and Threads</a>. 658 * 659 * <p>This method returns a ParcelFileDescriptor, which is returned directly 660 * to the caller. This way large data (such as images and documents) can be 661 * returned without copying the content. 662 * 663 * <p>The returned ParcelFileDescriptor is owned by the caller, so it is 664 * their responsibility to close it when done. That is, the implementation 665 * of this method should create a new ParcelFileDescriptor for each call. 666 * 667 * @param uri The URI whose file is to be opened. 668 * @param mode Access mode for the file. May be "r" for read-only access, 669 * "rw" for read and write access, or "rwt" for read and write access 670 * that truncates any existing file. 671 * 672 * @return Returns a new ParcelFileDescriptor which you can use to access 673 * the file. 674 * 675 * @throws FileNotFoundException Throws FileNotFoundException if there is 676 * no file associated with the given URI or the mode is invalid. 677 * @throws SecurityException Throws SecurityException if the caller does 678 * not have permission to access the file. 679 * 680 * @see #openAssetFile(Uri, String) 681 * @see #openFileHelper(Uri, String) 682 */ 683 public ParcelFileDescriptor openFile(Uri uri, String mode) 684 throws FileNotFoundException { 685 throw new FileNotFoundException("No files supported by provider at " 686 + uri); 687 } 688 689 /** 690 * This is like {@link #openFile}, but can be implemented by providers 691 * that need to be able to return sub-sections of files, often assets 692 * inside of their .apk. 693 * This method can be called from multiple threads, as described in 694 * <a href="{@docRoot}guide/topics/fundamentals.html#procthread">Application Fundamentals: 695 * Processes and Threads</a>. 696 * 697 * <p>If you implement this, your clients must be able to deal with such 698 * file slices, either directly with 699 * {@link ContentResolver#openAssetFileDescriptor}, or by using the higher-level 700 * {@link ContentResolver#openInputStream ContentResolver.openInputStream} 701 * or {@link ContentResolver#openOutputStream ContentResolver.openOutputStream} 702 * methods. 703 * 704 * <p class="note">If you are implementing this to return a full file, you 705 * should create the AssetFileDescriptor with 706 * {@link AssetFileDescriptor#UNKNOWN_LENGTH} to be compatible with 707 * applications that can not handle sub-sections of files.</p> 708 * 709 * @param uri The URI whose file is to be opened. 710 * @param mode Access mode for the file. May be "r" for read-only access, 711 * "w" for write-only access (erasing whatever data is currently in 712 * the file), "wa" for write-only access to append to any existing data, 713 * "rw" for read and write access on any existing data, and "rwt" for read 714 * and write access that truncates any existing file. 715 * 716 * @return Returns a new AssetFileDescriptor which you can use to access 717 * the file. 718 * 719 * @throws FileNotFoundException Throws FileNotFoundException if there is 720 * no file associated with the given URI or the mode is invalid. 721 * @throws SecurityException Throws SecurityException if the caller does 722 * not have permission to access the file. 723 * 724 * @see #openFile(Uri, String) 725 * @see #openFileHelper(Uri, String) 726 */ 727 public AssetFileDescriptor openAssetFile(Uri uri, String mode) 728 throws FileNotFoundException { 729 ParcelFileDescriptor fd = openFile(uri, mode); 730 return fd != null ? new AssetFileDescriptor(fd, 0, -1) : null; 731 } 732 733 /** 734 * Convenience for subclasses that wish to implement {@link #openFile} 735 * by looking up a column named "_data" at the given URI. 736 * 737 * @param uri The URI to be opened. 738 * @param mode The file mode. May be "r" for read-only access, 739 * "w" for write-only access (erasing whatever data is currently in 740 * the file), "wa" for write-only access to append to any existing data, 741 * "rw" for read and write access on any existing data, and "rwt" for read 742 * and write access that truncates any existing file. 743 * 744 * @return Returns a new ParcelFileDescriptor that can be used by the 745 * client to access the file. 746 */ 747 protected final ParcelFileDescriptor openFileHelper(Uri uri, 748 String mode) throws FileNotFoundException { 749 Cursor c = query(uri, new String[]{"_data"}, null, null, null); 750 int count = (c != null) ? c.getCount() : 0; 751 if (count != 1) { 752 // If there is not exactly one result, throw an appropriate 753 // exception. 754 if (c != null) { 755 c.close(); 756 } 757 if (count == 0) { 758 throw new FileNotFoundException("No entry for " + uri); 759 } 760 throw new FileNotFoundException("Multiple items at " + uri); 761 } 762 763 c.moveToFirst(); 764 int i = c.getColumnIndex("_data"); 765 String path = (i >= 0 ? c.getString(i) : null); 766 c.close(); 767 if (path == null) { 768 throw new FileNotFoundException("Column _data not found."); 769 } 770 771 int modeBits = ContentResolver.modeToMode(uri, mode); 772 return ParcelFileDescriptor.open(new File(path), modeBits); 773 } 774 775 /** 776 * Called by a client to determine the types of data streams that this 777 * content provider supports for the given URI. The default implementation 778 * returns null, meaning no types. If your content provider stores data 779 * of a particular type, return that MIME type if it matches the given 780 * mimeTypeFilter. If it can perform type conversions, return an array 781 * of all supported MIME types that match mimeTypeFilter. 782 * 783 * @param uri The data in the content provider being queried. 784 * @param mimeTypeFilter The type of data the client desires. May be 785 * a pattern, such as *\/* to retrieve all possible data types. 786 * @return Returns null if there are no possible data streams for the 787 * given mimeTypeFilter. Otherwise returns an array of all available 788 * concrete MIME types. 789 * 790 * @see #getType(Uri) 791 * @see #openTypedAssetFile(Uri, String, Bundle) 792 * @see ClipDescription#compareMimeTypes(String, String) 793 */ 794 public String[] getStreamTypes(Uri uri, String mimeTypeFilter) { 795 return null; 796 } 797 798 /** 799 * Called by a client to open a read-only stream containing data of a 800 * particular MIME type. This is like {@link #openAssetFile(Uri, String)}, 801 * except the file can only be read-only and the content provider may 802 * perform data conversions to generate data of the desired type. 803 * 804 * <p>The default implementation compares the given mimeType against the 805 * result of {@link #getType(Uri)} and, if the match, simple calls 806 * {@link #openAssetFile(Uri, String)}. 807 * 808 * <p>See {@link ClipData} for examples of the use and implementation 809 * of this method. 810 * 811 * @param uri The data in the content provider being queried. 812 * @param mimeTypeFilter The type of data the client desires. May be 813 * a pattern, such as *\/*, if the caller does not have specific type 814 * requirements; in this case the content provider will pick its best 815 * type matching the pattern. 816 * @param opts Additional options from the client. The definitions of 817 * these are specific to the content provider being called. 818 * 819 * @return Returns a new AssetFileDescriptor from which the client can 820 * read data of the desired type. 821 * 822 * @throws FileNotFoundException Throws FileNotFoundException if there is 823 * no file associated with the given URI or the mode is invalid. 824 * @throws SecurityException Throws SecurityException if the caller does 825 * not have permission to access the data. 826 * @throws IllegalArgumentException Throws IllegalArgumentException if the 827 * content provider does not support the requested MIME type. 828 * 829 * @see #getStreamTypes(Uri, String) 830 * @see #openAssetFile(Uri, String) 831 * @see ClipDescription#compareMimeTypes(String, String) 832 */ 833 public AssetFileDescriptor openTypedAssetFile(Uri uri, String mimeTypeFilter, Bundle opts) 834 throws FileNotFoundException { 835 if ("*/*".equals(mimeTypeFilter)) { 836 // If they can take anything, the untyped open call is good enough. 837 return openAssetFile(uri, "r"); 838 } 839 String baseType = getType(uri); 840 if (baseType != null && ClipDescription.compareMimeTypes(baseType, mimeTypeFilter)) { 841 // Use old untyped open call if this provider has a type for this 842 // URI and it matches the request. 843 return openAssetFile(uri, "r"); 844 } 845 throw new FileNotFoundException("Can't open " + uri + " as type " + mimeTypeFilter); 846 } 847 848 /** 849 * Interface to write a stream of data to a pipe. Use with 850 * {@link ContentProvider#openPipeHelper}. 851 */ 852 public interface PipeDataWriter<T> { 853 /** 854 * Called from a background thread to stream data out to a pipe. 855 * Note that the pipe is blocking, so this thread can block on 856 * writes for an arbitrary amount of time if the client is slow 857 * at reading. 858 * 859 * @param output The pipe where data should be written. This will be 860 * closed for you upon returning from this function. 861 * @param uri The URI whose data is to be written. 862 * @param mimeType The desired type of data to be written. 863 * @param opts Options supplied by caller. 864 * @param args Your own custom arguments. 865 */ 866 public void writeDataToPipe(ParcelFileDescriptor output, Uri uri, String mimeType, 867 Bundle opts, T args); 868 } 869 870 /** 871 * A helper function for implementing {@link #openTypedAssetFile}, for 872 * creating a data pipe and background thread allowing you to stream 873 * generated data back to the client. This function returns a new 874 * ParcelFileDescriptor that should be returned to the caller (the caller 875 * is responsible for closing it). 876 * 877 * @param uri The URI whose data is to be written. 878 * @param mimeType The desired type of data to be written. 879 * @param opts Options supplied by caller. 880 * @param args Your own custom arguments. 881 * @param func Interface implementing the function that will actually 882 * stream the data. 883 * @return Returns a new ParcelFileDescriptor holding the read side of 884 * the pipe. This should be returned to the caller for reading; the caller 885 * is responsible for closing it when done. 886 */ 887 public <T> ParcelFileDescriptor openPipeHelper(final Uri uri, final String mimeType, 888 final Bundle opts, final T args, final PipeDataWriter<T> func) 889 throws FileNotFoundException { 890 try { 891 final ParcelFileDescriptor[] fds = ParcelFileDescriptor.createPipe(); 892 893 AsyncTask<Object, Object, Object> task = new AsyncTask<Object, Object, Object>() { 894 @Override 895 protected Object doInBackground(Object... params) { 896 func.writeDataToPipe(fds[1], uri, mimeType, opts, args); 897 try { 898 fds[1].close(); 899 } catch (IOException e) { 900 Log.w(TAG, "Failure closing pipe", e); 901 } 902 return null; 903 } 904 }; 905 task.execute((Object[])null); 906 907 return fds[0]; 908 } catch (IOException e) { 909 throw new FileNotFoundException("failure making pipe"); 910 } 911 } 912 913 /** 914 * Returns true if this instance is a temporary content provider. 915 * @return true if this instance is a temporary content provider 916 */ 917 protected boolean isTemporary() { 918 return false; 919 } 920 921 /** 922 * Returns the Binder object for this provider. 923 * 924 * @return the Binder object for this provider 925 * @hide 926 */ 927 public IContentProvider getIContentProvider() { 928 return mTransport; 929 } 930 931 /** 932 * After being instantiated, this is called to tell the content provider 933 * about itself. 934 * 935 * @param context The context this provider is running in 936 * @param info Registered information about this content provider 937 */ 938 public void attachInfo(Context context, ProviderInfo info) { 939 /* 940 * We may be using AsyncTask from binder threads. Make it init here 941 * so its static handler is on the main thread. 942 */ 943 AsyncTask.init(); 944 945 /* 946 * Only allow it to be set once, so after the content service gives 947 * this to us clients can't change it. 948 */ 949 if (mContext == null) { 950 mContext = context; 951 mMyUid = Process.myUid(); 952 if (info != null) { 953 setReadPermission(info.readPermission); 954 setWritePermission(info.writePermission); 955 setPathPermissions(info.pathPermissions); 956 mExported = info.exported; 957 } 958 ContentProvider.this.onCreate(); 959 } 960 } 961 962 /** 963 * Override this to handle requests to perform a batch of operations, or the 964 * default implementation will iterate over the operations and call 965 * {@link ContentProviderOperation#apply} on each of them. 966 * If all calls to {@link ContentProviderOperation#apply} succeed 967 * then a {@link ContentProviderResult} array with as many 968 * elements as there were operations will be returned. If any of the calls 969 * fail, it is up to the implementation how many of the others take effect. 970 * This method can be called from multiple threads, as described in 971 * <a href="{@docRoot}guide/topics/fundamentals.html#procthread">Application Fundamentals: 972 * Processes and Threads</a>. 973 * 974 * @param operations the operations to apply 975 * @return the results of the applications 976 * @throws OperationApplicationException thrown if any operation fails. 977 * @see ContentProviderOperation#apply 978 */ 979 public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations) 980 throws OperationApplicationException { 981 final int numOperations = operations.size(); 982 final ContentProviderResult[] results = new ContentProviderResult[numOperations]; 983 for (int i = 0; i < numOperations; i++) { 984 results[i] = operations.get(i).apply(this, results, i); 985 } 986 return results; 987 } 988 989 /** 990 * @hide -- until interface has proven itself 991 * 992 * Call a provider-defined method. This can be used to implement 993 * interfaces that are cheaper than using a Cursor. 994 * 995 * @param method Method name to call. Opaque to framework. 996 * @param request Nullable String argument passed to method. 997 * @param args Nullable Bundle argument passed to method. 998 */ 999 public Bundle call(String method, String request, Bundle args) { 1000 return null; 1001 } 1002 1003 /** 1004 * Implement this to shut down the ContentProvider instance. You can then 1005 * invoke this method in unit tests. 1006 * 1007 * <p> 1008 * Android normally handles ContentProvider startup and shutdown 1009 * automatically. You do not need to start up or shut down a 1010 * ContentProvider. When you invoke a test method on a ContentProvider, 1011 * however, a ContentProvider instance is started and keeps running after 1012 * the test finishes, even if a succeeding test instantiates another 1013 * ContentProvider. A conflict develops because the two instances are 1014 * usually running against the same underlying data source (for example, an 1015 * sqlite database). 1016 * </p> 1017 * <p> 1018 * Implementing shutDown() avoids this conflict by providing a way to 1019 * terminate the ContentProvider. This method can also prevent memory leaks 1020 * from multiple instantiations of the ContentProvider, and it can ensure 1021 * unit test isolation by allowing you to completely clean up the test 1022 * fixture before moving on to the next test. 1023 * </p> 1024 */ 1025 public void shutdown() { 1026 Log.w(TAG, "implement ContentProvider shutdown() to make sure all database " + 1027 "connections are gracefully shutdown"); 1028 } 1029} 1030