eclair snapshot
[android/platform/packages/providers/DownloadProvider.git] / src / com / android / providers / downloads / DownloadProvider.java
1 /*
2  * Copyright (C) 2007 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 com.android.providers.downloads;
18
19 import android.content.ContentProvider;
20 import android.content.ContentValues;
21 import android.content.Context;
22 import android.content.Intent;
23 import android.content.UriMatcher;
24 import android.content.pm.PackageManager;
25 import android.database.CrossProcessCursor;
26 import android.database.Cursor;
27 import android.database.CursorWindow;
28 import android.database.CursorWrapper;
29 import android.database.SQLException;
30 import android.database.sqlite.SQLiteDatabase;
31 import android.database.sqlite.SQLiteOpenHelper;
32 import android.database.sqlite.SQLiteQueryBuilder;
33 import android.net.Uri;
34 import android.os.Binder;
35 import android.os.ParcelFileDescriptor;
36 import android.os.Process;
37 import android.provider.Downloads;
38 import android.util.Config;
39 import android.util.Log;
40
41 import java.io.File;
42 import java.io.FileNotFoundException;
43 import java.util.HashSet;
44
45
46 /**
47  * Allows application to interact with the download manager.
48  */
49 public final class DownloadProvider extends ContentProvider {
50
51     /** Database filename */
52     private static final String DB_NAME = "downloads.db";
53     /** Current database version */
54     private static final int DB_VERSION = 100;
55     /** Database version from which upgrading is a nop */
56     private static final int DB_VERSION_NOP_UPGRADE_FROM = 31;
57     /** Database version to which upgrading is a nop */
58     private static final int DB_VERSION_NOP_UPGRADE_TO = 100;
59     /** Name of table in the database */
60     private static final String DB_TABLE = "downloads";
61
62     /** MIME type for the entire download list */
63     private static final String DOWNLOAD_LIST_TYPE = "vnd.android.cursor.dir/download";
64     /** MIME type for an individual download */
65     private static final String DOWNLOAD_TYPE = "vnd.android.cursor.item/download";
66
67     /** URI matcher used to recognize URIs sent by applications */
68     private static final UriMatcher sURIMatcher = new UriMatcher(UriMatcher.NO_MATCH);
69     /** URI matcher constant for the URI of the entire download list */
70     private static final int DOWNLOADS = 1;
71     /** URI matcher constant for the URI of an individual download */
72     private static final int DOWNLOADS_ID = 2;
73     static {
74         sURIMatcher.addURI("downloads", "download", DOWNLOADS);
75         sURIMatcher.addURI("downloads", "download/#", DOWNLOADS_ID);
76     }
77
78     private static final String[] sAppReadableColumnsArray = new String[] {
79         Downloads._ID,
80         Downloads.COLUMN_APP_DATA,
81         Downloads._DATA,
82         Downloads.COLUMN_MIME_TYPE,
83         Downloads.COLUMN_VISIBILITY,
84         Downloads.COLUMN_DESTINATION,
85         Downloads.COLUMN_CONTROL,
86         Downloads.COLUMN_STATUS,
87         Downloads.COLUMN_LAST_MODIFICATION,
88         Downloads.COLUMN_NOTIFICATION_PACKAGE,
89         Downloads.COLUMN_NOTIFICATION_CLASS,
90         Downloads.COLUMN_TOTAL_BYTES,
91         Downloads.COLUMN_CURRENT_BYTES,
92         Downloads.COLUMN_TITLE,
93         Downloads.COLUMN_DESCRIPTION
94     };
95
96     private static HashSet<String> sAppReadableColumnsSet;
97     static {
98         sAppReadableColumnsSet = new HashSet<String>();
99         for (int i = 0; i < sAppReadableColumnsArray.length; ++i) {
100             sAppReadableColumnsSet.add(sAppReadableColumnsArray[i]);
101         }
102     }
103
104     /** The database that lies underneath this content provider */
105     private SQLiteOpenHelper mOpenHelper = null;
106
107     /**
108      * Creates and updated database on demand when opening it.
109      * Helper class to create database the first time the provider is
110      * initialized and upgrade it when a new version of the provider needs
111      * an updated version of the database.
112      */
113     private final class DatabaseHelper extends SQLiteOpenHelper {
114
115         public DatabaseHelper(final Context context) {
116             super(context, DB_NAME, null, DB_VERSION);
117         }
118
119         /**
120          * Creates database the first time we try to open it.
121          */
122         @Override
123         public void onCreate(final SQLiteDatabase db) {
124             if (Constants.LOGVV) {
125                 Log.v(Constants.TAG, "populating new database");
126             }
127             createTable(db);
128         }
129
130         /* (not a javadoc comment)
131          * Checks data integrity when opening the database.
132          */
133         /*
134          * @Override
135          * public void onOpen(final SQLiteDatabase db) {
136          *     super.onOpen(db);
137          * }
138          */
139
140         /**
141          * Updates the database format when a content provider is used
142          * with a database that was created with a different format.
143          */
144         // Note: technically, this could also be a downgrade, so if we want
145         //       to gracefully handle upgrades we should be careful about
146         //       what to do on downgrades.
147         @Override
148         public void onUpgrade(final SQLiteDatabase db, int oldV, final int newV) {
149             if (oldV == DB_VERSION_NOP_UPGRADE_FROM) {
150                 if (newV == DB_VERSION_NOP_UPGRADE_TO) { // that's a no-op upgrade.
151                     return;
152                 }
153                 // NOP_FROM and NOP_TO are identical, just in different codelines. Upgrading
154                 //     from NOP_FROM is the same as upgrading from NOP_TO.
155                 oldV = DB_VERSION_NOP_UPGRADE_TO;
156             }
157             Log.i(Constants.TAG, "Upgrading downloads database from version " + oldV + " to " + newV
158                     + ", which will destroy all old data");
159             dropTable(db);
160             createTable(db);
161         }
162     }
163
164     /**
165      * Initializes the content provider when it is created.
166      */
167     @Override
168     public boolean onCreate() {
169         mOpenHelper = new DatabaseHelper(getContext());
170         return true;
171     }
172
173     /**
174      * Returns the content-provider-style MIME types of the various
175      * types accessible through this content provider.
176      */
177     @Override
178     public String getType(final Uri uri) {
179         int match = sURIMatcher.match(uri);
180         switch (match) {
181             case DOWNLOADS: {
182                 return DOWNLOAD_LIST_TYPE;
183             }
184             case DOWNLOADS_ID: {
185                 return DOWNLOAD_TYPE;
186             }
187             default: {
188                 if (Constants.LOGV) {
189                     Log.v(Constants.TAG, "calling getType on an unknown URI: " + uri);
190                 }
191                 throw new IllegalArgumentException("Unknown URI: " + uri);
192             }
193         }
194     }
195
196     /**
197      * Creates the table that'll hold the download information.
198      */
199     private void createTable(SQLiteDatabase db) {
200         try {
201             db.execSQL("CREATE TABLE " + DB_TABLE + "(" +
202                     Downloads._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
203                     Downloads.COLUMN_URI + " TEXT, " +
204                     Constants.RETRY_AFTER_X_REDIRECT_COUNT + " INTEGER, " +
205                     Downloads.COLUMN_APP_DATA + " TEXT, " +
206                     Downloads.COLUMN_NO_INTEGRITY + " BOOLEAN, " +
207                     Downloads.COLUMN_FILE_NAME_HINT + " TEXT, " +
208                     Constants.OTA_UPDATE + " BOOLEAN, " +
209                     Downloads._DATA + " TEXT, " +
210                     Downloads.COLUMN_MIME_TYPE + " TEXT, " +
211                     Downloads.COLUMN_DESTINATION + " INTEGER, " +
212                     Constants.NO_SYSTEM_FILES + " BOOLEAN, " +
213                     Downloads.COLUMN_VISIBILITY + " INTEGER, " +
214                     Downloads.COLUMN_CONTROL + " INTEGER, " +
215                     Downloads.COLUMN_STATUS + " INTEGER, " +
216                     Constants.FAILED_CONNECTIONS + " INTEGER, " +
217                     Downloads.COLUMN_LAST_MODIFICATION + " BIGINT, " +
218                     Downloads.COLUMN_NOTIFICATION_PACKAGE + " TEXT, " +
219                     Downloads.COLUMN_NOTIFICATION_CLASS + " TEXT, " +
220                     Downloads.COLUMN_NOTIFICATION_EXTRAS + " TEXT, " +
221                     Downloads.COLUMN_COOKIE_DATA + " TEXT, " +
222                     Downloads.COLUMN_USER_AGENT + " TEXT, " +
223                     Downloads.COLUMN_REFERER + " TEXT, " +
224                     Downloads.COLUMN_TOTAL_BYTES + " INTEGER, " +
225                     Downloads.COLUMN_CURRENT_BYTES + " INTEGER, " +
226                     Constants.ETAG + " TEXT, " +
227                     Constants.UID + " INTEGER, " +
228                     Downloads.COLUMN_OTHER_UID + " INTEGER, " +
229                     Downloads.COLUMN_TITLE + " TEXT, " +
230                     Downloads.COLUMN_DESCRIPTION + " TEXT, " +
231                     Constants.MEDIA_SCANNED + " BOOLEAN);");
232         } catch (SQLException ex) {
233             Log.e(Constants.TAG, "couldn't create table in downloads database");
234             throw ex;
235         }
236     }
237
238     /**
239      * Deletes the table that holds the download information.
240      */
241     private void dropTable(SQLiteDatabase db) {
242         try {
243             db.execSQL("DROP TABLE IF EXISTS " + DB_TABLE);
244         } catch (SQLException ex) {
245             Log.e(Constants.TAG, "couldn't drop table in downloads database");
246             throw ex;
247         }
248     }
249
250     /**
251      * Inserts a row in the database
252      */
253     @Override
254     public Uri insert(final Uri uri, final ContentValues values) {
255         SQLiteDatabase db = mOpenHelper.getWritableDatabase();
256
257         if (sURIMatcher.match(uri) != DOWNLOADS) {
258             if (Config.LOGD) {
259                 Log.d(Constants.TAG, "calling insert on an unknown/invalid URI: " + uri);
260             }
261             throw new IllegalArgumentException("Unknown/Invalid URI " + uri);
262         }
263
264         ContentValues filteredValues = new ContentValues();
265
266         copyString(Downloads.COLUMN_URI, values, filteredValues);
267         copyString(Downloads.COLUMN_APP_DATA, values, filteredValues);
268         copyBoolean(Downloads.COLUMN_NO_INTEGRITY, values, filteredValues);
269         copyString(Downloads.COLUMN_FILE_NAME_HINT, values, filteredValues);
270         copyString(Downloads.COLUMN_MIME_TYPE, values, filteredValues);
271         Integer dest = values.getAsInteger(Downloads.COLUMN_DESTINATION);
272         if (dest != null) {
273             if (getContext().checkCallingPermission(Downloads.PERMISSION_ACCESS_ADVANCED)
274                     != PackageManager.PERMISSION_GRANTED
275                     && dest != Downloads.DESTINATION_EXTERNAL
276                     && dest != Downloads.DESTINATION_CACHE_PARTITION_PURGEABLE) {
277                 throw new SecurityException("unauthorized destination code");
278             }
279             filteredValues.put(Downloads.COLUMN_DESTINATION, dest);
280         }
281         Integer vis = values.getAsInteger(Downloads.COLUMN_VISIBILITY);
282         if (vis == null) {
283             if (dest == Downloads.DESTINATION_EXTERNAL) {
284                 filteredValues.put(Downloads.COLUMN_VISIBILITY,
285                         Downloads.VISIBILITY_VISIBLE_NOTIFY_COMPLETED);
286             } else {
287                 filteredValues.put(Downloads.COLUMN_VISIBILITY, Downloads.VISIBILITY_HIDDEN);
288             }
289         } else {
290             filteredValues.put(Downloads.COLUMN_VISIBILITY, vis);
291         }
292         copyInteger(Downloads.COLUMN_CONTROL, values, filteredValues);
293         filteredValues.put(Downloads.COLUMN_STATUS, Downloads.STATUS_PENDING);
294         filteredValues.put(Downloads.COLUMN_LAST_MODIFICATION, System.currentTimeMillis());
295         String pckg = values.getAsString(Downloads.COLUMN_NOTIFICATION_PACKAGE);
296         String clazz = values.getAsString(Downloads.COLUMN_NOTIFICATION_CLASS);
297         if (pckg != null && clazz != null) {
298             int uid = Binder.getCallingUid();
299             try {
300                 if (uid == 0 ||
301                         getContext().getPackageManager().getApplicationInfo(pckg, 0).uid == uid) {
302                     filteredValues.put(Downloads.COLUMN_NOTIFICATION_PACKAGE, pckg);
303                     filteredValues.put(Downloads.COLUMN_NOTIFICATION_CLASS, clazz);
304                 }
305             } catch (PackageManager.NameNotFoundException ex) {
306                 /* ignored for now */
307             }
308         }
309         copyString(Downloads.COLUMN_NOTIFICATION_EXTRAS, values, filteredValues);
310         copyString(Downloads.COLUMN_COOKIE_DATA, values, filteredValues);
311         copyString(Downloads.COLUMN_USER_AGENT, values, filteredValues);
312         copyString(Downloads.COLUMN_REFERER, values, filteredValues);
313         if (getContext().checkCallingPermission(Downloads.PERMISSION_ACCESS_ADVANCED)
314                 == PackageManager.PERMISSION_GRANTED) {
315             copyInteger(Downloads.COLUMN_OTHER_UID, values, filteredValues);
316         }
317         filteredValues.put(Constants.UID, Binder.getCallingUid());
318         if (Binder.getCallingUid() == 0) {
319             copyInteger(Constants.UID, values, filteredValues);
320         }
321         copyString(Downloads.COLUMN_TITLE, values, filteredValues);
322         copyString(Downloads.COLUMN_DESCRIPTION, values, filteredValues);
323
324         if (Constants.LOGVV) {
325             Log.v(Constants.TAG, "initiating download with UID "
326                     + filteredValues.getAsInteger(Constants.UID));
327             if (filteredValues.containsKey(Downloads.COLUMN_OTHER_UID)) {
328                 Log.v(Constants.TAG, "other UID " +
329                         filteredValues.getAsInteger(Downloads.COLUMN_OTHER_UID));
330             }
331         }
332
333         Context context = getContext();
334         context.startService(new Intent(context, DownloadService.class));
335
336         long rowID = db.insert(DB_TABLE, null, filteredValues);
337
338         Uri ret = null;
339
340         if (rowID != -1) {
341             context.startService(new Intent(context, DownloadService.class));
342             ret = Uri.parse(Downloads.CONTENT_URI + "/" + rowID);
343             context.getContentResolver().notifyChange(uri, null);
344         } else {
345             if (Config.LOGD) {
346                 Log.d(Constants.TAG, "couldn't insert into downloads database");
347             }
348         }
349
350         return ret;
351     }
352
353     /**
354      * Starts a database query
355      */
356     @Override
357     public Cursor query(final Uri uri, String[] projection,
358              final String selection, final String[] selectionArgs,
359              final String sort) {
360
361         Helpers.validateSelection(selection, sAppReadableColumnsSet);
362
363         SQLiteDatabase db = mOpenHelper.getReadableDatabase();
364
365         SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
366
367         int match = sURIMatcher.match(uri);
368         boolean emptyWhere = true;
369         switch (match) {
370             case DOWNLOADS: {
371                 qb.setTables(DB_TABLE);
372                 break;
373             }
374             case DOWNLOADS_ID: {
375                 qb.setTables(DB_TABLE);
376                 qb.appendWhere(Downloads._ID + "=");
377                 qb.appendWhere(uri.getPathSegments().get(1));
378                 emptyWhere = false;
379                 break;
380             }
381             default: {
382                 if (Constants.LOGV) {
383                     Log.v(Constants.TAG, "querying unknown URI: " + uri);
384                 }
385                 throw new IllegalArgumentException("Unknown URI: " + uri);
386             }
387         }
388
389         if (Binder.getCallingPid() != Process.myPid() && Binder.getCallingUid() != 0 &&
390                 Process.supportsProcesses()) {
391             if (!emptyWhere) {
392                 qb.appendWhere(" AND ");
393             }
394             qb.appendWhere("( " + Constants.UID + "=" +  Binder.getCallingUid() + " OR "
395                     + Downloads.COLUMN_OTHER_UID + "=" +  Binder.getCallingUid() + " )");
396             emptyWhere = false;
397
398             if (projection == null) {
399                 projection = sAppReadableColumnsArray;
400             } else {
401                 for (int i = 0; i < projection.length; ++i) {
402                     if (!sAppReadableColumnsSet.contains(projection[i])) {
403                         throw new IllegalArgumentException(
404                                 "column " + projection[i] + " is not allowed in queries");
405                     }
406                 }
407             }
408         }
409
410         if (Constants.LOGVV) {
411             java.lang.StringBuilder sb = new java.lang.StringBuilder();
412             sb.append("starting query, database is ");
413             if (db != null) {
414                 sb.append("not ");
415             }
416             sb.append("null; ");
417             if (projection == null) {
418                 sb.append("projection is null; ");
419             } else if (projection.length == 0) {
420                 sb.append("projection is empty; ");
421             } else {
422                 for (int i = 0; i < projection.length; ++i) {
423                     sb.append("projection[");
424                     sb.append(i);
425                     sb.append("] is ");
426                     sb.append(projection[i]);
427                     sb.append("; ");
428                 }
429             }
430             sb.append("selection is ");
431             sb.append(selection);
432             sb.append("; ");
433             if (selectionArgs == null) {
434                 sb.append("selectionArgs is null; ");
435             } else if (selectionArgs.length == 0) {
436                 sb.append("selectionArgs is empty; ");
437             } else {
438                 for (int i = 0; i < selectionArgs.length; ++i) {
439                     sb.append("selectionArgs[");
440                     sb.append(i);
441                     sb.append("] is ");
442                     sb.append(selectionArgs[i]);
443                     sb.append("; ");
444                 }
445             }
446             sb.append("sort is ");
447             sb.append(sort);
448             sb.append(".");
449             Log.v(Constants.TAG, sb.toString());
450         }
451
452         Cursor ret = qb.query(db, projection, selection, selectionArgs,
453                               null, null, sort);
454
455         if (ret != null) {
456            ret = new ReadOnlyCursorWrapper(ret);
457         }
458
459         if (ret != null) {
460             ret.setNotificationUri(getContext().getContentResolver(), uri);
461             if (Constants.LOGVV) {
462                 Log.v(Constants.TAG,
463                         "created cursor " + ret + " on behalf of " + Binder.getCallingPid());
464             }
465         } else {
466             if (Constants.LOGV) {
467                 Log.v(Constants.TAG, "query failed in downloads database");
468             }
469         }
470
471         return ret;
472     }
473
474     /**
475      * Updates a row in the database
476      */
477     @Override
478     public int update(final Uri uri, final ContentValues values,
479             final String where, final String[] whereArgs) {
480
481         Helpers.validateSelection(where, sAppReadableColumnsSet);
482
483         SQLiteDatabase db = mOpenHelper.getWritableDatabase();
484
485         int count;
486         long rowId = 0;
487         boolean startService = false;
488
489         ContentValues filteredValues;
490         if (Binder.getCallingPid() != Process.myPid()) {
491             filteredValues = new ContentValues();
492             copyString(Downloads.COLUMN_APP_DATA, values, filteredValues);
493             copyInteger(Downloads.COLUMN_VISIBILITY, values, filteredValues);
494             Integer i = values.getAsInteger(Downloads.COLUMN_CONTROL);
495             if (i != null) {
496                 filteredValues.put(Downloads.COLUMN_CONTROL, i);
497                 startService = true;
498             }
499             copyInteger(Downloads.COLUMN_CONTROL, values, filteredValues);
500             copyString(Downloads.COLUMN_TITLE, values, filteredValues);
501             copyString(Downloads.COLUMN_DESCRIPTION, values, filteredValues);
502         } else {
503             filteredValues = values;
504         }
505         int match = sURIMatcher.match(uri);
506         switch (match) {
507             case DOWNLOADS:
508             case DOWNLOADS_ID: {
509                 String myWhere;
510                 if (where != null) {
511                     if (match == DOWNLOADS) {
512                         myWhere = "( " + where + " )";
513                     } else {
514                         myWhere = "( " + where + " ) AND ";
515                     }
516                 } else {
517                     myWhere = "";
518                 }
519                 if (match == DOWNLOADS_ID) {
520                     String segment = uri.getPathSegments().get(1);
521                     rowId = Long.parseLong(segment);
522                     myWhere += " ( " + Downloads._ID + " = " + rowId + " ) ";
523                 }
524                 if (Binder.getCallingPid() != Process.myPid() && Binder.getCallingUid() != 0) {
525                     myWhere += " AND ( " + Constants.UID + "=" +  Binder.getCallingUid() + " OR "
526                             + Downloads.COLUMN_OTHER_UID + "=" +  Binder.getCallingUid() + " )";
527                 }
528                 if (filteredValues.size() > 0) {
529                     count = db.update(DB_TABLE, filteredValues, myWhere, whereArgs);
530                 } else {
531                     count = 0;
532                 }
533                 break;
534             }
535             default: {
536                 if (Config.LOGD) {
537                     Log.d(Constants.TAG, "updating unknown/invalid URI: " + uri);
538                 }
539                 throw new UnsupportedOperationException("Cannot update URI: " + uri);
540             }
541         }
542         getContext().getContentResolver().notifyChange(uri, null);
543         if (startService) {
544             Context context = getContext();
545             context.startService(new Intent(context, DownloadService.class));
546         }
547         return count;
548     }
549
550     /**
551      * Deletes a row in the database
552      */
553     @Override
554     public int delete(final Uri uri, final String where,
555             final String[] whereArgs) {
556
557         Helpers.validateSelection(where, sAppReadableColumnsSet);
558
559         SQLiteDatabase db = mOpenHelper.getWritableDatabase();
560         int count;
561         int match = sURIMatcher.match(uri);
562         switch (match) {
563             case DOWNLOADS:
564             case DOWNLOADS_ID: {
565                 String myWhere;
566                 if (where != null) {
567                     if (match == DOWNLOADS) {
568                         myWhere = "( " + where + " )";
569                     } else {
570                         myWhere = "( " + where + " ) AND ";
571                     }
572                 } else {
573                     myWhere = "";
574                 }
575                 if (match == DOWNLOADS_ID) {
576                     String segment = uri.getPathSegments().get(1);
577                     long rowId = Long.parseLong(segment);
578                     myWhere += " ( " + Downloads._ID + " = " + rowId + " ) ";
579                 }
580                 if (Binder.getCallingPid() != Process.myPid() && Binder.getCallingUid() != 0) {
581                     myWhere += " AND ( " + Constants.UID + "=" +  Binder.getCallingUid() + " OR "
582                             + Downloads.COLUMN_OTHER_UID + "=" +  Binder.getCallingUid() + " )";
583                 }
584                 count = db.delete(DB_TABLE, myWhere, whereArgs);
585                 break;
586             }
587             default: {
588                 if (Config.LOGD) {
589                     Log.d(Constants.TAG, "deleting unknown/invalid URI: " + uri);
590                 }
591                 throw new UnsupportedOperationException("Cannot delete URI: " + uri);
592             }
593         }
594         getContext().getContentResolver().notifyChange(uri, null);
595         return count;
596     }
597
598     /**
599      * Remotely opens a file
600      */
601     @Override
602     public ParcelFileDescriptor openFile(Uri uri, String mode)
603             throws FileNotFoundException {
604         if (Constants.LOGVV) {
605             Log.v(Constants.TAG, "openFile uri: " + uri + ", mode: " + mode
606                     + ", uid: " + Binder.getCallingUid());
607             Cursor cursor = query(Downloads.CONTENT_URI, new String[] { "_id" }, null, null, "_id");
608             if (cursor == null) {
609                 Log.v(Constants.TAG, "null cursor in openFile");
610             } else {
611                 if (!cursor.moveToFirst()) {
612                     Log.v(Constants.TAG, "empty cursor in openFile");
613                 } else {
614                     do {
615                         Log.v(Constants.TAG, "row " + cursor.getInt(0) + " available");
616                     } while(cursor.moveToNext());
617                 }
618                 cursor.close();
619             }
620             cursor = query(uri, new String[] { "_data" }, null, null, null);
621             if (cursor == null) {
622                 Log.v(Constants.TAG, "null cursor in openFile");
623             } else {
624                 if (!cursor.moveToFirst()) {
625                     Log.v(Constants.TAG, "empty cursor in openFile");
626                 } else {
627                     String filename = cursor.getString(0);
628                     Log.v(Constants.TAG, "filename in openFile: " + filename);
629                     if (new java.io.File(filename).isFile()) {
630                         Log.v(Constants.TAG, "file exists in openFile");
631                     }
632                 }
633                cursor.close();
634             }
635         }
636
637         // This logic is mostly copied form openFileHelper. If openFileHelper eventually
638         //     gets split into small bits (to extract the filename and the modebits),
639         //     this code could use the separate bits and be deeply simplified.
640         Cursor c = query(uri, new String[]{"_data"}, null, null, null);
641         int count = (c != null) ? c.getCount() : 0;
642         if (count != 1) {
643             // If there is not exactly one result, throw an appropriate exception.
644             if (c != null) {
645                 c.close();
646             }
647             if (count == 0) {
648                 throw new FileNotFoundException("No entry for " + uri);
649             }
650             throw new FileNotFoundException("Multiple items at " + uri);
651         }
652
653         c.moveToFirst();
654         String path = c.getString(0);
655         c.close();
656         if (path == null) {
657             throw new FileNotFoundException("No filename found.");
658         }
659         if (!Helpers.isFilenameValid(path)) {
660             throw new FileNotFoundException("Invalid filename.");
661         }
662
663         if (!"r".equals(mode)) {
664             throw new FileNotFoundException("Bad mode for " + uri + ": " + mode);
665         }
666         ParcelFileDescriptor ret = ParcelFileDescriptor.open(new File(path),
667                 ParcelFileDescriptor.MODE_READ_ONLY);
668
669         if (ret == null) {
670             if (Constants.LOGV) {
671                 Log.v(Constants.TAG, "couldn't open file");
672             }
673             throw new FileNotFoundException("couldn't open file");
674         } else {
675             ContentValues values = new ContentValues();
676             values.put(Downloads.COLUMN_LAST_MODIFICATION, System.currentTimeMillis());
677             update(uri, values, null, null);
678         }
679         return ret;
680     }
681
682     private static final void copyInteger(String key, ContentValues from, ContentValues to) {
683         Integer i = from.getAsInteger(key);
684         if (i != null) {
685             to.put(key, i);
686         }
687     }
688
689     private static final void copyBoolean(String key, ContentValues from, ContentValues to) {
690         Boolean b = from.getAsBoolean(key);
691         if (b != null) {
692             to.put(key, b);
693         }
694     }
695
696     private static final void copyString(String key, ContentValues from, ContentValues to) {
697         String s = from.getAsString(key);
698         if (s != null) {
699             to.put(key, s);
700         }
701     }
702
703     private class ReadOnlyCursorWrapper extends CursorWrapper implements CrossProcessCursor {
704         public ReadOnlyCursorWrapper(Cursor cursor) {
705             super(cursor);
706             mCursor = (CrossProcessCursor) cursor;
707         }
708
709         public boolean deleteRow() {
710             throw new SecurityException("Download manager cursors are read-only");
711         }
712
713         public boolean commitUpdates() {
714             throw new SecurityException("Download manager cursors are read-only");
715         }
716
717         public void fillWindow(int pos, CursorWindow window) {
718             mCursor.fillWindow(pos, window);
719         }
720
721         public CursorWindow getWindow() {
722             return mCursor.getWindow();
723         }
724
725         public boolean onMove(int oldPosition, int newPosition) {
726             return mCursor.onMove(oldPosition, newPosition);
727         }
728
729         private CrossProcessCursor mCursor;
730     }
731
732 }