1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
|
/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.unit_tests.content;
import android.content.ContentProvider;
import android.content.ContentValues;
import android.content.Context;
import android.content.UriMatcher;
import android.content.res.AssetFileDescriptor;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.net.Uri;
import android.os.MemoryFile;
import android.os.ParcelFileDescriptor;
import android.util.Log;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.OutputStream;
/** Simple test provider that runs in the local process. */
public class MemoryFileProvider extends ContentProvider {
private static final String TAG = "MemoryFileProvider";
private static final String DATA_FILE = "data.bin";
// some random data
public static final byte[] TEST_BLOB = new byte[] {
-12, 127, 0, 3, 1, 2, 3, 4, 5, 6, 1, -128, -1, -54, -65, 35,
-53, -96, -74, -74, -55, -43, -69, 3, 52, -58,
-121, 127, 87, -73, 16, -13, -103, -65, -128, -36,
107, 24, 118, -17, 97, 97, -88, 19, -94, -54,
53, 43, 44, -27, -124, 28, -74, 26, 35, -36,
16, -124, -31, -31, -128, -79, 108, 116, 43, -17 };
private SQLiteOpenHelper mOpenHelper;
private static final int DATA_ID_BLOB = 1;
private static final int HUGE = 2;
private static final int FILE = 3;
private static final UriMatcher sURLMatcher = new UriMatcher(
UriMatcher.NO_MATCH);
static {
sURLMatcher.addURI("*", "data/#/blob", DATA_ID_BLOB);
sURLMatcher.addURI("*", "huge", HUGE);
sURLMatcher.addURI("*", "file", FILE);
}
private static class DatabaseHelper extends SQLiteOpenHelper {
private static final String DATABASE_NAME = "local.db";
private static final int DATABASE_VERSION = 1;
public DatabaseHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE TABLE data (" +
"_id INTEGER PRIMARY KEY," +
"_blob TEXT, " +
"integer INTEGER);");
// insert alarms
ContentValues values = new ContentValues();
values.put("_id", 1);
values.put("_blob", TEST_BLOB);
values.put("integer", 100);
db.insert("data", null, values);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int currentVersion) {
Log.w(TAG, "Upgrading test database from version " +
oldVersion + " to " + currentVersion +
", which will destroy all old data");
db.execSQL("DROP TABLE IF EXISTS data");
onCreate(db);
}
}
public MemoryFileProvider() {
}
@Override
public boolean onCreate() {
mOpenHelper = new DatabaseHelper(getContext());
try {
OutputStream out = getContext().openFileOutput(DATA_FILE, Context.MODE_PRIVATE);
out.write(TEST_BLOB);
out.close();
} catch (IOException ex) {
ex.printStackTrace();
}
return true;
}
@Override
public Cursor query(Uri url, String[] projectionIn, String selection,
String[] selectionArgs, String sort) {
throw new UnsupportedOperationException("query not supported");
}
@Override
public String getType(Uri url) {
int match = sURLMatcher.match(url);
switch (match) {
case DATA_ID_BLOB:
return "application/octet-stream";
case FILE:
return "application/octet-stream";
default:
throw new IllegalArgumentException("Unknown URL");
}
}
@Override
public AssetFileDescriptor openAssetFile(Uri url, String mode) throws FileNotFoundException {
int match = sURLMatcher.match(url);
switch (match) {
case DATA_ID_BLOB:
String sql = "SELECT _blob FROM data WHERE _id=" + url.getPathSegments().get(1);
return getBlobColumnAsAssetFile(url, mode, sql);
case HUGE:
try {
MemoryFile memoryFile = new MemoryFile(null, 5000000);
memoryFile.writeBytes(TEST_BLOB, 0, 1000000, TEST_BLOB.length);
memoryFile.deactivate();
return AssetFileDescriptor.fromMemoryFile(memoryFile);
} catch (IOException ex) {
throw new FileNotFoundException("Error reading " + url + ":" + ex.toString());
}
case FILE:
File file = getContext().getFileStreamPath(DATA_FILE);
ParcelFileDescriptor fd =
ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY);
return new AssetFileDescriptor(fd, 0, AssetFileDescriptor.UNKNOWN_LENGTH);
default:
throw new FileNotFoundException("No files supported by provider at " + url);
}
}
private AssetFileDescriptor getBlobColumnAsAssetFile(Uri url, String mode, String sql)
throws FileNotFoundException {
if (!"r".equals(mode)) {
throw new FileNotFoundException("Mode " + mode + " not supported for " + url);
}
try {
SQLiteDatabase db = mOpenHelper.getReadableDatabase();
MemoryFile file = simpleQueryForBlobMemoryFile(db, sql);
if (file == null) throw new FileNotFoundException("No such entry: " + url);
AssetFileDescriptor afd = AssetFileDescriptor.fromMemoryFile(file);
file.deactivate();
// need to dup and then close? openFileHelper() doesn't do that though
return afd;
} catch (IOException ex) {
throw new FileNotFoundException("Error reading " + url + ":" + ex.toString());
}
}
private MemoryFile simpleQueryForBlobMemoryFile(SQLiteDatabase db, String sql) throws IOException {
Cursor cursor = db.rawQuery(sql, null);
try {
if (!cursor.moveToFirst()) {
return null;
}
byte[] bytes = cursor.getBlob(0);
MemoryFile file = new MemoryFile(null, bytes.length);
file.writeBytes(bytes, 0, 0, bytes.length);
return file;
} finally {
if (cursor != null) {
cursor.close();
}
}
}
@Override
public int update(Uri url, ContentValues values, String where, String[] whereArgs) {
throw new UnsupportedOperationException("update not supported");
}
@Override
public Uri insert(Uri url, ContentValues initialValues) {
throw new UnsupportedOperationException("insert not supported");
}
@Override
public int delete(Uri url, String where, String[] whereArgs) {
throw new UnsupportedOperationException("delete not supported");
}
}
|
