ContentProvider.java revision 1040dc465cbf5ca8f834a87c949e476abefa3f76
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 * @param uri the URI to query. 565 * @return a MIME type string, or null if there is no type. 566 */ 567 public abstract String getType(Uri uri); 568 569 /** 570 * Implement this to handle requests to insert a new row. 571 * As a courtesy, call {@link ContentResolver#notifyChange(android.net.Uri ,android.database.ContentObserver) notifyChange()} 572 * after inserting. 573 * This method can be called from multiple threads, as described in 574 * <a href="{@docRoot}guide/topics/fundamentals.html#procthread">Application Fundamentals: 575 * Processes and Threads</a>. 576 * @param uri The content:// URI of the insertion request. 577 * @param values A set of column_name/value pairs to add to the database. 578 * @return The URI for the newly inserted item. 579 */ 580 public abstract Uri insert(Uri uri, ContentValues values); 581 582 /** 583 * Override this to handle requests to insert a set of new rows, or the 584 * default implementation will iterate over the values and call 585 * {@link #insert} on each of them. 586 * As a courtesy, call {@link ContentResolver#notifyChange(android.net.Uri ,android.database.ContentObserver) notifyChange()} 587 * after inserting. 588 * This method can be called from multiple threads, as described in 589 * <a href="{@docRoot}guide/topics/fundamentals.html#procthread">Application Fundamentals: 590 * Processes and Threads</a>. 591 * 592 * @param uri The content:// URI of the insertion request. 593 * @param values An array of sets of column_name/value pairs to add to the database. 594 * @return The number of values that were inserted. 595 */ 596 public int bulkInsert(Uri uri, ContentValues[] values) { 597 int numValues = values.length; 598 for (int i = 0; i < numValues; i++) { 599 insert(uri, values[i]); 600 } 601 return numValues; 602 } 603 604 /** 605 * Implement this to handle requests to delete one or more rows. 606 * The implementation should apply the selection clause when performing 607 * deletion, allowing the operation to affect multiple rows in a directory. 608 * As a courtesy, call {@link ContentResolver#notifyChange(android.net.Uri ,android.database.ContentObserver) notifyDelete()} 609 * after deleting. 610 * This method can be called from multiple threads, as described in 611 * <a href="{@docRoot}guide/topics/fundamentals.html#procthread">Application Fundamentals: 612 * Processes and Threads</a>. 613 * 614 * <p>The implementation is responsible for parsing out a row ID at the end 615 * of the URI, if a specific row is being deleted. That is, the client would 616 * pass in <code>content://contacts/people/22</code> and the implementation is 617 * responsible for parsing the record number (22) when creating a SQL statement. 618 * 619 * @param uri The full URI to query, including a row ID (if a specific record is requested). 620 * @param selection An optional restriction to apply to rows when deleting. 621 * @return The number of rows affected. 622 * @throws SQLException 623 */ 624 public abstract int delete(Uri uri, String selection, String[] selectionArgs); 625 626 /** 627 * Implement this to handle requests to update one or more rows. 628 * The implementation should update all rows matching the selection 629 * to set the columns according to the provided values map. 630 * As a courtesy, call {@link ContentResolver#notifyChange(android.net.Uri ,android.database.ContentObserver) notifyChange()} 631 * after updating. 632 * This method can be called from multiple threads, as described in 633 * <a href="{@docRoot}guide/topics/fundamentals.html#procthread">Application Fundamentals: 634 * Processes and Threads</a>. 635 * 636 * @param uri The URI to query. This can potentially have a record ID if this 637 * is an update request for a specific record. 638 * @param values A Bundle mapping from column names to new column values (NULL is a 639 * valid value). 640 * @param selection An optional filter to match rows to update. 641 * @return the number of rows affected. 642 */ 643 public abstract int update(Uri uri, ContentValues values, String selection, 644 String[] selectionArgs); 645 646 /** 647 * Override this to handle requests to open a file blob. 648 * The default implementation always throws {@link FileNotFoundException}. 649 * This method can be called from multiple threads, as described in 650 * <a href="{@docRoot}guide/topics/fundamentals.html#procthread">Application Fundamentals: 651 * Processes and Threads</a>. 652 * 653 * <p>This method returns a ParcelFileDescriptor, which is returned directly 654 * to the caller. This way large data (such as images and documents) can be 655 * returned without copying the content. 656 * 657 * <p>The returned ParcelFileDescriptor is owned by the caller, so it is 658 * their responsibility to close it when done. That is, the implementation 659 * of this method should create a new ParcelFileDescriptor for each call. 660 * 661 * @param uri The URI whose file is to be opened. 662 * @param mode Access mode for the file. May be "r" for read-only access, 663 * "rw" for read and write access, or "rwt" for read and write access 664 * that truncates any existing file. 665 * 666 * @return Returns a new ParcelFileDescriptor which you can use to access 667 * the file. 668 * 669 * @throws FileNotFoundException Throws FileNotFoundException if there is 670 * no file associated with the given URI or the mode is invalid. 671 * @throws SecurityException Throws SecurityException if the caller does 672 * not have permission to access the file. 673 * 674 * @see #openAssetFile(Uri, String) 675 * @see #openFileHelper(Uri, String) 676 */ 677 public ParcelFileDescriptor openFile(Uri uri, String mode) 678 throws FileNotFoundException { 679 throw new FileNotFoundException("No files supported by provider at " 680 + uri); 681 } 682 683 /** 684 * This is like {@link #openFile}, but can be implemented by providers 685 * that need to be able to return sub-sections of files, often assets 686 * inside of their .apk. 687 * This method can be called from multiple threads, as described in 688 * <a href="{@docRoot}guide/topics/fundamentals.html#procthread">Application Fundamentals: 689 * Processes and Threads</a>. 690 * 691 * <p>If you implement this, your clients must be able to deal with such 692 * file slices, either directly with 693 * {@link ContentResolver#openAssetFileDescriptor}, or by using the higher-level 694 * {@link ContentResolver#openInputStream ContentResolver.openInputStream} 695 * or {@link ContentResolver#openOutputStream ContentResolver.openOutputStream} 696 * methods. 697 * 698 * <p class="note">If you are implementing this to return a full file, you 699 * should create the AssetFileDescriptor with 700 * {@link AssetFileDescriptor#UNKNOWN_LENGTH} to be compatible with 701 * applications that can not handle sub-sections of files.</p> 702 * 703 * @param uri The URI whose file is to be opened. 704 * @param mode Access mode for the file. May be "r" for read-only access, 705 * "w" for write-only access (erasing whatever data is currently in 706 * the file), "wa" for write-only access to append to any existing data, 707 * "rw" for read and write access on any existing data, and "rwt" for read 708 * and write access that truncates any existing file. 709 * 710 * @return Returns a new AssetFileDescriptor which you can use to access 711 * the file. 712 * 713 * @throws FileNotFoundException Throws FileNotFoundException if there is 714 * no file associated with the given URI or the mode is invalid. 715 * @throws SecurityException Throws SecurityException if the caller does 716 * not have permission to access the file. 717 * 718 * @see #openFile(Uri, String) 719 * @see #openFileHelper(Uri, String) 720 */ 721 public AssetFileDescriptor openAssetFile(Uri uri, String mode) 722 throws FileNotFoundException { 723 ParcelFileDescriptor fd = openFile(uri, mode); 724 return fd != null ? new AssetFileDescriptor(fd, 0, -1) : null; 725 } 726 727 /** 728 * Convenience for subclasses that wish to implement {@link #openFile} 729 * by looking up a column named "_data" at the given URI. 730 * 731 * @param uri The URI to be opened. 732 * @param mode The file mode. May be "r" for read-only access, 733 * "w" for write-only access (erasing whatever data is currently in 734 * the file), "wa" for write-only access to append to any existing data, 735 * "rw" for read and write access on any existing data, and "rwt" for read 736 * and write access that truncates any existing file. 737 * 738 * @return Returns a new ParcelFileDescriptor that can be used by the 739 * client to access the file. 740 */ 741 protected final ParcelFileDescriptor openFileHelper(Uri uri, 742 String mode) throws FileNotFoundException { 743 Cursor c = query(uri, new String[]{"_data"}, null, null, null); 744 int count = (c != null) ? c.getCount() : 0; 745 if (count != 1) { 746 // If there is not exactly one result, throw an appropriate 747 // exception. 748 if (c != null) { 749 c.close(); 750 } 751 if (count == 0) { 752 throw new FileNotFoundException("No entry for " + uri); 753 } 754 throw new FileNotFoundException("Multiple items at " + uri); 755 } 756 757 c.moveToFirst(); 758 int i = c.getColumnIndex("_data"); 759 String path = (i >= 0 ? c.getString(i) : null); 760 c.close(); 761 if (path == null) { 762 throw new FileNotFoundException("Column _data not found."); 763 } 764 765 int modeBits = ContentResolver.modeToMode(uri, mode); 766 return ParcelFileDescriptor.open(new File(path), modeBits); 767 } 768 769 /** 770 * Called by a client to determine the types of data streams that this 771 * content provider supports for the given URI. The default implementation 772 * returns null, meaning no types. If your content provider stores data 773 * of a particular type, return that MIME type if it matches the given 774 * mimeTypeFilter. If it can perform type conversions, return an array 775 * of all supported MIME types that match mimeTypeFilter. 776 * 777 * @param uri The data in the content provider being queried. 778 * @param mimeTypeFilter The type of data the client desires. May be 779 * a pattern, such as *\/* to retrieve all possible data types. 780 * @return Returns null if there are no possible data streams for the 781 * given mimeTypeFilter. Otherwise returns an array of all available 782 * concrete MIME types. 783 * 784 * @see #getType(Uri) 785 * @see #openTypedAssetFile(Uri, String, Bundle) 786 * @see ClipDescription#compareMimeTypes(String, String) 787 */ 788 public String[] getStreamTypes(Uri uri, String mimeTypeFilter) { 789 return null; 790 } 791 792 /** 793 * Called by a client to open a read-only stream containing data of a 794 * particular MIME type. This is like {@link #openAssetFile(Uri, String)}, 795 * except the file can only be read-only and the content provider may 796 * perform data conversions to generate data of the desired type. 797 * 798 * <p>The default implementation compares the given mimeType against the 799 * result of {@link #getType(Uri)} and, if the match, simple calls 800 * {@link #openAssetFile(Uri, String)}. 801 * 802 * <p>See {@link ClipData} for examples of the use and implementation 803 * of this method. 804 * 805 * @param uri The data in the content provider being queried. 806 * @param mimeTypeFilter The type of data the client desires. May be 807 * a pattern, such as *\/*, if the caller does not have specific type 808 * requirements; in this case the content provider will pick its best 809 * type matching the pattern. 810 * @param opts Additional options from the client. The definitions of 811 * these are specific to the content provider being called. 812 * 813 * @return Returns a new AssetFileDescriptor from which the client can 814 * read data of the desired type. 815 * 816 * @throws FileNotFoundException Throws FileNotFoundException if there is 817 * no file associated with the given URI or the mode is invalid. 818 * @throws SecurityException Throws SecurityException if the caller does 819 * not have permission to access the data. 820 * @throws IllegalArgumentException Throws IllegalArgumentException if the 821 * content provider does not support the requested MIME type. 822 * 823 * @see #getStreamTypes(Uri, String) 824 * @see #openAssetFile(Uri, String) 825 * @see ClipDescription#compareMimeTypes(String, String) 826 */ 827 public AssetFileDescriptor openTypedAssetFile(Uri uri, String mimeTypeFilter, Bundle opts) 828 throws FileNotFoundException { 829 if ("*/*".equals(mimeTypeFilter)) { 830 // If they can take anything, the untyped open call is good enough. 831 return openAssetFile(uri, "r"); 832 } 833 String baseType = getType(uri); 834 if (baseType != null && ClipDescription.compareMimeTypes(baseType, mimeTypeFilter)) { 835 // Use old untyped open call if this provider has a type for this 836 // URI and it matches the request. 837 return openAssetFile(uri, "r"); 838 } 839 throw new FileNotFoundException("Can't open " + uri + " as type " + mimeTypeFilter); 840 } 841 842 /** 843 * Interface to write a stream of data to a pipe. Use with 844 * {@link ContentProvider#openPipeHelper}. 845 */ 846 public interface PipeDataWriter<T> { 847 /** 848 * Called from a background thread to stream data out to a pipe. 849 * Note that the pipe is blocking, so this thread can block on 850 * writes for an arbitrary amount of time if the client is slow 851 * at reading. 852 * 853 * @param output The pipe where data should be written. This will be 854 * closed for you upon returning from this function. 855 * @param uri The URI whose data is to be written. 856 * @param mimeType The desired type of data to be written. 857 * @param opts Options supplied by caller. 858 * @param args Your own custom arguments. 859 */ 860 public void writeDataToPipe(ParcelFileDescriptor output, Uri uri, String mimeType, 861 Bundle opts, T args); 862 } 863 864 /** 865 * A helper function for implementing {@link #openTypedAssetFile}, for 866 * creating a data pipe and background thread allowing you to stream 867 * generated data back to the client. This function returns a new 868 * ParcelFileDescriptor that should be returned to the caller (the caller 869 * is responsible for closing it). 870 * 871 * @param uri The URI whose data is to be written. 872 * @param mimeType The desired type of data to be written. 873 * @param opts Options supplied by caller. 874 * @param args Your own custom arguments. 875 * @param func Interface implementing the function that will actually 876 * stream the data. 877 * @return Returns a new ParcelFileDescriptor holding the read side of 878 * the pipe. This should be returned to the caller for reading; the caller 879 * is responsible for closing it when done. 880 */ 881 public <T> ParcelFileDescriptor openPipeHelper(final Uri uri, final String mimeType, 882 final Bundle opts, final T args, final PipeDataWriter<T> func) 883 throws FileNotFoundException { 884 try { 885 final ParcelFileDescriptor[] fds = ParcelFileDescriptor.createPipe(); 886 887 AsyncTask<Object, Object, Object> task = new AsyncTask<Object, Object, Object>() { 888 @Override 889 protected Object doInBackground(Object... params) { 890 func.writeDataToPipe(fds[1], uri, mimeType, opts, args); 891 try { 892 fds[1].close(); 893 } catch (IOException e) { 894 Log.w(TAG, "Failure closing pipe", e); 895 } 896 return null; 897 } 898 }; 899 task.execute((Object[])null); 900 901 return fds[0]; 902 } catch (IOException e) { 903 throw new FileNotFoundException("failure making pipe"); 904 } 905 } 906 907 /** 908 * Returns true if this instance is a temporary content provider. 909 * @return true if this instance is a temporary content provider 910 */ 911 protected boolean isTemporary() { 912 return false; 913 } 914 915 /** 916 * Returns the Binder object for this provider. 917 * 918 * @return the Binder object for this provider 919 * @hide 920 */ 921 public IContentProvider getIContentProvider() { 922 return mTransport; 923 } 924 925 /** 926 * After being instantiated, this is called to tell the content provider 927 * about itself. 928 * 929 * @param context The context this provider is running in 930 * @param info Registered information about this content provider 931 */ 932 public void attachInfo(Context context, ProviderInfo info) { 933 /* 934 * We may be using AsyncTask from binder threads. Make it init here 935 * so its static handler is on the main thread. 936 */ 937 AsyncTask.init(); 938 939 /* 940 * Only allow it to be set once, so after the content service gives 941 * this to us clients can't change it. 942 */ 943 if (mContext == null) { 944 mContext = context; 945 mMyUid = Process.myUid(); 946 if (info != null) { 947 setReadPermission(info.readPermission); 948 setWritePermission(info.writePermission); 949 setPathPermissions(info.pathPermissions); 950 mExported = info.exported; 951 } 952 ContentProvider.this.onCreate(); 953 } 954 } 955 956 /** 957 * Override this to handle requests to perform a batch of operations, or the 958 * default implementation will iterate over the operations and call 959 * {@link ContentProviderOperation#apply} on each of them. 960 * If all calls to {@link ContentProviderOperation#apply} succeed 961 * then a {@link ContentProviderResult} array with as many 962 * elements as there were operations will be returned. If any of the calls 963 * fail, it is up to the implementation how many of the others take effect. 964 * This method can be called from multiple threads, as described in 965 * <a href="{@docRoot}guide/topics/fundamentals.html#procthread">Application Fundamentals: 966 * Processes and Threads</a>. 967 * 968 * @param operations the operations to apply 969 * @return the results of the applications 970 * @throws OperationApplicationException thrown if any operation fails. 971 * @see ContentProviderOperation#apply 972 */ 973 public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations) 974 throws OperationApplicationException { 975 final int numOperations = operations.size(); 976 final ContentProviderResult[] results = new ContentProviderResult[numOperations]; 977 for (int i = 0; i < numOperations; i++) { 978 results[i] = operations.get(i).apply(this, results, i); 979 } 980 return results; 981 } 982 983 /** 984 * @hide -- until interface has proven itself 985 * 986 * Call a provider-defined method. This can be used to implement 987 * interfaces that are cheaper than using a Cursor. 988 * 989 * @param method Method name to call. Opaque to framework. 990 * @param request Nullable String argument passed to method. 991 * @param args Nullable Bundle argument passed to method. 992 */ 993 public Bundle call(String method, String request, Bundle args) { 994 return null; 995 } 996 997 /** 998 * Implement this to shut down the ContentProvider instance. You can then 999 * invoke this method in unit tests. 1000 * 1001 * <p> 1002 * Android normally handles ContentProvider startup and shutdown 1003 * automatically. You do not need to start up or shut down a 1004 * ContentProvider. When you invoke a test method on a ContentProvider, 1005 * however, a ContentProvider instance is started and keeps running after 1006 * the test finishes, even if a succeeding test instantiates another 1007 * ContentProvider. A conflict develops because the two instances are 1008 * usually running against the same underlying data source (for example, an 1009 * sqlite database). 1010 * </p> 1011 * <p> 1012 * Implementing shutDown() avoids this conflict by providing a way to 1013 * terminate the ContentProvider. This method can also prevent memory leaks 1014 * from multiple instantiations of the ContentProvider, and it can ensure 1015 * unit test isolation by allowing you to completely clean up the test 1016 * fixture before moving on to the next test. 1017 * </p> 1018 */ 1019 public void shutdown() { 1020 Log.w(TAG, "implement ContentProvider shutdown() to make sure all database " + 1021 "connections are gracefully shutdown"); 1022 } 1023} 1024