extends TabActivity {
17 |
18 | private volatile H helper;
19 | private volatile boolean created = false;
20 | private volatile boolean destroyed = false;
21 |
22 | /**
23 | * Get a helper for this action.
24 | */
25 | public H getHelper() {
26 | if (helper == null) {
27 | if (!created) {
28 | throw new IllegalStateException("A call has not been made to onCreate() yet so the helper is null");
29 | } else if (destroyed) {
30 | throw new IllegalStateException(
31 | "A call to onDestroy has already been made and the helper cannot be used after that point");
32 | } else {
33 | throw new IllegalStateException("Helper is null for some unknown reason");
34 | }
35 | } else {
36 | return helper;
37 | }
38 | }
39 |
40 | /**
41 | * Get a connection source for this action.
42 | */
43 | public ConnectionSource getConnectionSource() {
44 | return getHelper().getConnectionSource();
45 | }
46 |
47 | @Override
48 | protected void onCreate(Bundle savedInstanceState) {
49 | if (helper == null) {
50 | helper = getHelperInternal(this);
51 | created = true;
52 | }
53 | super.onCreate(savedInstanceState);
54 | }
55 |
56 | @Override
57 | protected void onDestroy() {
58 | super.onDestroy();
59 | releaseHelper(helper);
60 | destroyed = true;
61 | }
62 |
63 | /**
64 | * This is called internally by the class to populate the helper object instance. This should not be called directly
65 | * by client code unless you know what you are doing. Use {@link #getHelper()} to get a helper instance. If you are
66 | * managing your own helper creation, override this method to supply this activity with a helper instance.
67 | *
68 | *
69 | * NOTE: If you override this method, you most likely will need to override the
70 | * {@link #releaseHelper(OrmLiteSqliteOpenHelper)} method as well.
71 | *
72 | *
73 | * @see OpenHelperManager#getHelper(Context)
74 | */
75 | protected H getHelperInternal(Context context) {
76 | @SuppressWarnings({ "unchecked", "deprecation" })
77 | H newHelper = (H) OpenHelperManager.getHelper(context);
78 | return newHelper;
79 | }
80 |
81 | /**
82 | * Release the helper instance created in {@link #getHelperInternal(Context)}. You most likely will not need to call
83 | * this directly since {@link #onDestroy()} does it for you.
84 | *
85 | *
86 | * NOTE: If you override this method, you most likely will need to override the
87 | * {@link #getHelperInternal(Context)} method as well.
88 | *
89 | */
90 | protected void releaseHelper(H helper) {
91 | OpenHelperManager.releaseHelper();
92 | this.helper = null;
93 | }
94 | }
95 |
--------------------------------------------------------------------------------
/sqlcipher-old/src/main/java/com/j256/ormlite/sqlcipher/android/apptools/OrmLiteConfigUtil.java:
--------------------------------------------------------------------------------
1 | package com.j256.ormlite.sqlcipher.android.apptools;
2 |
3 | import com.j256.ormlite.dao.DaoManager;
4 | import com.j256.ormlite.db.DatabaseType;
5 | import com.j256.ormlite.field.DatabaseField;
6 | import com.j256.ormlite.field.DatabaseFieldConfig;
7 | import com.j256.ormlite.field.ForeignCollectionField;
8 | import com.j256.ormlite.sqlcipher.db.SqliteAndroidDatabaseType;
9 | import com.j256.ormlite.table.DatabaseTable;
10 | import com.j256.ormlite.table.DatabaseTableConfig;
11 | import com.j256.ormlite.table.DatabaseTableConfigLoader;
12 |
13 | import net.sqlcipher.database.SQLiteDatabase;
14 |
15 | import java.io.BufferedReader;
16 | import java.io.BufferedWriter;
17 | import java.io.File;
18 | import java.io.FileFilter;
19 | import java.io.FileOutputStream;
20 | import java.io.FileReader;
21 | import java.io.IOException;
22 | import java.io.OutputStream;
23 | import java.io.OutputStreamWriter;
24 | import java.lang.reflect.Field;
25 | import java.sql.SQLException;
26 | import java.text.SimpleDateFormat;
27 | import java.util.ArrayList;
28 | import java.util.Date;
29 | import java.util.List;
30 |
31 | /**
32 | * Database configuration file helper class that is used to write a configuration file into the raw resource
33 | * sub-directory to speed up DAO creation.
34 | *
35 | *
36 | * With help from the user list and especially Ian Dees, we discovered that calls to annotation methods in Android are
37 | * _very_ expensive because Method.equals() was doing a huge toString(). This was causing folks to see 2-3 seconds
38 | * startup time when configuring 10-15 DAOs because of 1000s of calls to @DatabaseField methods. See this Android bug report.
40 | *
41 | *
42 | *
43 | * I added this utility class which writes a configuration file into the raw resource "res/raw" directory inside of your
44 | * project containing the table and field names and associated details. This file can then be loaded into the
45 | * {@link DaoManager} with the help of the
46 | * {@link OrmLiteSqliteOpenHelper#OrmLiteSqliteOpenHelper(android.content.Context, String, SQLiteDatabase.CursorFactory, int, int)}
47 | * constructor. This means that you can configure your classes _without_ any runtime calls to annotations. It seems
48 | * significantly faster.
49 | *
50 | *
51 | *
52 | * WARNING: Although this is fast, the big problem is that you have to remember to regenerate the config file
53 | * whenever you edit one of your database classes. There is no way that I know of to do this automagically.
54 | *
55 | *
56 | * @author graywatson
57 | */
58 | public class OrmLiteConfigUtil {
59 |
60 | /**
61 | * Resource directory name that we are looking for.
62 | */
63 | protected static final String RESOURCE_DIR_NAME = "res";
64 | /**
65 | * Raw directory name that we are looking for.
66 | */
67 | protected static final String RAW_DIR_NAME = "raw";
68 |
69 | /**
70 | * Maximum recursion level while we are looking for source files.
71 | */
72 | protected static int maxFindSourceLevel = 20;
73 |
74 | private static final DatabaseType databaseType = new SqliteAndroidDatabaseType();
75 |
76 | /**
77 | * A call through to {@link #writeConfigFile(String)} taking the file name from the single command line argument.
78 | */
79 | public static void main(String[] args) throws Exception {
80 | if (args.length != 1) {
81 | throw new IllegalArgumentException("Main can take a single file-name argument.");
82 | }
83 | writeConfigFile(args[0]);
84 | }
85 |
86 | /**
87 | * Finds the annotated classes in the current directory or below and writes a configuration file to the file-name in
88 | * the raw folder.
89 | */
90 | public static void writeConfigFile(String fileName) throws SQLException, IOException {
91 | List> classList = new ArrayList>();
92 | findAnnotatedClasses(classList, new File("."), 0);
93 | writeConfigFile(fileName, classList.toArray(new Class[classList.size()]));
94 | }
95 |
96 | /**
97 | * Writes a configuration fileName in the raw directory with the configuration for classes.
98 | */
99 | public static void writeConfigFile(String fileName, Class[] classes) throws SQLException, IOException {
100 | File rawDir = findRawDir(new File("."));
101 | if (rawDir == null) {
102 | System.err.println("Could not find " + RAW_DIR_NAME + " directory which is typically in the "
103 | + RESOURCE_DIR_NAME + " directory");
104 | } else {
105 | File configFile = new File(rawDir, fileName);
106 | writeConfigFile(configFile, classes);
107 | }
108 | }
109 |
110 | /**
111 | * Finds the annotated classes in the current directory or below and writes a configuration file.
112 | */
113 | public static void writeConfigFile(File configFile) throws SQLException, IOException {
114 | writeConfigFile(configFile, new File("."));
115 | }
116 |
117 | /**
118 | * Finds the annotated classes in the specified search directory or below and writes a configuration file.
119 | */
120 | public static void writeConfigFile(File configFile, File searchDir) throws SQLException, IOException {
121 | List> classList = new ArrayList>();
122 | findAnnotatedClasses(classList, searchDir, 0);
123 | writeConfigFile(configFile, classList.toArray(new Class[classList.size()]));
124 | }
125 |
126 | /**
127 | * Write a configuration file with the configuration for classes.
128 | */
129 | public static void writeConfigFile(File configFile, Class[] classes) throws SQLException, IOException {
130 | System.out.println("Writing configurations to " + configFile.getAbsolutePath());
131 | writeConfigFile(new FileOutputStream(configFile), classes);
132 | }
133 |
134 | /**
135 | * Write a configuration file to an output stream with the configuration for classes.
136 | */
137 | public static void writeConfigFile(OutputStream outputStream, File searchDir) throws SQLException, IOException {
138 | List> classList = new ArrayList>();
139 | findAnnotatedClasses(classList, searchDir, 0);
140 | writeConfigFile(outputStream, classList.toArray(new Class[classList.size()]));
141 | }
142 |
143 | /**
144 | * Write a configuration file to an output stream with the configuration for classes.
145 | */
146 | public static void writeConfigFile(OutputStream outputStream, Class[] classes) throws SQLException, IOException {
147 | BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(outputStream), 4096);
148 | try {
149 | writeHeader(writer);
150 | for (Class clazz : classes) {
151 | writeConfigForTable(writer, clazz);
152 | }
153 | // NOTE: done is here because this is public
154 | System.out.println("Done.");
155 | } finally {
156 | writer.close();
157 | }
158 | }
159 |
160 | /**
161 | * Look for the resource-directory in the current directory or the directories above. Then look for the
162 | * raw-directory underneath the resource-directory.
163 | */
164 | protected static File findRawDir(File dir) {
165 | for (int i = 0; dir != null && i < 20; i++) {
166 | File rawDir = findResRawDir(dir);
167 | if (rawDir != null) {
168 | return rawDir;
169 | }
170 | dir = dir.getParentFile();
171 | }
172 | return null;
173 | }
174 |
175 | private static void writeHeader(BufferedWriter writer) throws IOException {
176 | writer.append('#');
177 | writer.newLine();
178 | writer.append("# generated on ").append(new SimpleDateFormat("yyyy/MM/dd hh:mm:ss").format(new Date()));
179 | writer.newLine();
180 | writer.append('#');
181 | writer.newLine();
182 | }
183 |
184 | private static void findAnnotatedClasses(List> classList, File dir, int level) throws SQLException,
185 | IOException {
186 | for (File file : dir.listFiles()) {
187 | if (file.isDirectory()) {
188 | // recurse if we aren't deep enough
189 | if (level < maxFindSourceLevel) {
190 | findAnnotatedClasses(classList, file, level + 1);
191 | }
192 | continue;
193 | }
194 | // skip non .java files
195 | if (!file.getName().endsWith(".java")) {
196 | continue;
197 | }
198 | String packageName = getPackageOfClass(file);
199 | if (packageName == null) {
200 | System.err.println("Could not find package name for: " + file);
201 | continue;
202 | }
203 | // get the filename and cut off the .java
204 | String name = file.getName();
205 | name = name.substring(0, name.length() - ".java".length());
206 | String className = packageName + "." + name;
207 | Class clazz;
208 | try {
209 | clazz = Class.forName(className);
210 | } catch (Throwable t) {
211 | // amazingly, this sometimes throws an Error
212 | System.err.println("Could not load class file for: " + file);
213 | System.err.println(" " + t);
214 | continue;
215 | }
216 | if (classHasAnnotations(clazz)) {
217 | classList.add(clazz);
218 | }
219 | // handle inner classes
220 | try {
221 | for (Class innerClazz : clazz.getDeclaredClasses()) {
222 | if (classHasAnnotations(innerClazz)) {
223 | classList.add(innerClazz);
224 | }
225 | }
226 | } catch (Throwable t) {
227 | // amazingly, this sometimes throws an Error
228 | System.err.println("Could not load inner classes for: " + clazz);
229 | System.err.println(" " + t);
230 | continue;
231 | }
232 | }
233 | }
234 |
235 | private static void writeConfigForTable(BufferedWriter writer, Class clazz) throws SQLException, IOException {
236 | String tableName = DatabaseTableConfig.extractTableName(clazz);
237 | List fieldConfigs = new ArrayList();
238 | // walk up the classes finding the fields
239 | try {
240 | for (Class working = clazz; working != null; working = working.getSuperclass()) {
241 | for (Field field : working.getDeclaredFields()) {
242 | DatabaseFieldConfig fieldConfig = DatabaseFieldConfig.fromField(databaseType, tableName, field);
243 | if (fieldConfig != null) {
244 | fieldConfigs.add(fieldConfig);
245 | }
246 | }
247 | }
248 | } catch (Error e) {
249 | System.err.println("Skipping " + clazz + " because we got an error finding its definition: "
250 | + e.getMessage());
251 | return;
252 | }
253 | if (fieldConfigs.isEmpty()) {
254 | System.out.println("Skipping " + clazz + " because no annotated fields found");
255 | return;
256 | }
257 | @SuppressWarnings({ "rawtypes", "unchecked" })
258 | DatabaseTableConfig tableConfig = new DatabaseTableConfig(clazz, tableName, fieldConfigs);
259 | DatabaseTableConfigLoader.write(writer, tableConfig);
260 | writer.append("#################################");
261 | writer.newLine();
262 | System.out.println("Wrote config for " + clazz);
263 | }
264 |
265 | private static boolean classHasAnnotations(Class clazz) {
266 | while (clazz != null) {
267 | if (clazz.getAnnotation(DatabaseTable.class) != null) {
268 | return true;
269 | }
270 | Field[] fields;
271 | try {
272 | fields = clazz.getDeclaredFields();
273 | } catch (Throwable t) {
274 | // amazingly, this sometimes throws an Error
275 | System.err.println("Could not load get delcared fields from: " + clazz);
276 | System.err.println(" " + t);
277 | return false;
278 | }
279 | for (Field field : fields) {
280 | if (field.getAnnotation(DatabaseField.class) != null
281 | || field.getAnnotation(ForeignCollectionField.class) != null) {
282 | return true;
283 | }
284 | }
285 | try {
286 | clazz = clazz.getSuperclass();
287 | } catch (Throwable t) {
288 | // amazingly, this sometimes throws an Error
289 | System.err.println("Could not get super class for: " + clazz);
290 | System.err.println(" " + t);
291 | return false;
292 | }
293 | }
294 |
295 | return false;
296 | }
297 |
298 | /**
299 | * Returns the package name of a file that has one of the annotations we are looking for.
300 | *
301 | * @return Package prefix string or null or no annotations.
302 | */
303 | private static String getPackageOfClass(File file) throws IOException {
304 | BufferedReader reader = new BufferedReader(new FileReader(file));
305 | try {
306 | while (true) {
307 | String line = reader.readLine();
308 | if (line == null) {
309 | return null;
310 | }
311 | if (line.contains("package")) {
312 | String[] parts = line.split("[ \t;]");
313 | if (parts.length > 1 && parts[0].equals("package")) {
314 | return parts[1];
315 | }
316 | }
317 | }
318 | } finally {
319 | reader.close();
320 | }
321 | }
322 |
323 | /**
324 | * Look for the resource directory with raw beneath it.
325 | */
326 | private static File findResRawDir(File dir) {
327 | for (File file : dir.listFiles()) {
328 | if (file.getName().equals(RESOURCE_DIR_NAME) && file.isDirectory()) {
329 | File[] rawFiles = file.listFiles(new FileFilter() {
330 | public boolean accept(File file) {
331 | return file.getName().equals(RAW_DIR_NAME) && file.isDirectory();
332 | }
333 | });
334 | if (rawFiles.length == 1) {
335 | return rawFiles[0];
336 | }
337 | }
338 | }
339 | return null;
340 | }
341 | }
342 |
--------------------------------------------------------------------------------
/sqlcipher-old/src/main/java/com/j256/ormlite/sqlcipher/android/compat/ApiCompatibility.java:
--------------------------------------------------------------------------------
1 | package com.j256.ormlite.sqlcipher.android.compat;
2 |
3 |
4 | import net.sqlcipher.Cursor;
5 | import net.sqlcipher.database.SQLiteDatabase;
6 |
7 | /**
8 | * Compatibility interface to support various different versions of the Android API.
9 | *
10 | * @author graywatson
11 | */
12 | public interface ApiCompatibility {
13 |
14 | /**
15 | * Perform a raw query on a database with an optional cancellation-hook.
16 | */
17 | public Cursor rawQuery(SQLiteDatabase db, String sql, String[] selectionArgs, CancellationHook cancellationHook);
18 |
19 | /**
20 | * Return a cancellation hook object that will be passed to the
21 | * {@link #rawQuery(SQLiteDatabase, String, String[], CancellationHook)}. If not supported then this will return
22 | * null.
23 | */
24 | public CancellationHook createCancellationHook();
25 |
26 | /**
27 | * Cancellation hook class returned by {@link ApiCompatibility#createCancellationHook()}.
28 | */
29 | public interface CancellationHook {
30 | /**
31 | * Cancel the associated query.
32 | */
33 | public void cancel();
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/sqlcipher-old/src/main/java/com/j256/ormlite/sqlcipher/android/compat/ApiCompatibilityUtils.java:
--------------------------------------------------------------------------------
1 | package com.j256.ormlite.sqlcipher.android.compat;
2 |
3 | import android.os.Build;
4 |
5 |
6 | /**
7 | * Utility class which loads the various classes based on which API version is being supported.
8 | *
9 | * @author graywatson
10 | */
11 | @SuppressWarnings("unused")
12 | public class ApiCompatibilityUtils {
13 |
14 | private static ApiCompatibility compatibility;
15 |
16 | /**
17 | * Copied from {@link Build.VERSION_CODES}. We don't use those codes because they won't be in certain versions of
18 | * Build.
19 | */
20 | private static final int BASE = 1;
21 | private static final int BASE_1_1 = 2;
22 | private static final int CUPCAKE = 3;
23 | private static final int DONUT = 4;
24 | private static final int ECLAIR = 5;
25 | private static final int ECLAIR_0_1 = 6;
26 | private static final int ECLAIR_MR1 = 7;
27 | private static final int FROYO = 8;
28 | private static final int GINGERBREAD = 9;
29 | private static final int GINGERBREAD_MR1 = 10;
30 | private static final int HONEYCOMB = 11;
31 | private static final int HONEYCOMB_MR1 = 12;
32 | private static final int HONEYCOMB_MR2 = 13;
33 | private static final int ICE_CREAM_SANDWICH = 14;
34 | private static final int ICE_CREAM_SANDWICH_MR1 = 15;
35 | private static final int JELLY_BEAN = 16;
36 | private static final int JELLY_BEAN_MR1 = 17;
37 | private static final int JELLY_BEAN_MR2 = 18;
38 |
39 | static {
40 | if (Build.VERSION.SDK_INT >= JELLY_BEAN) {
41 | compatibility = new com.j256.ormlite.sqlcipher.android.compat.JellyBeanApiCompatibility();
42 | } else {
43 | compatibility = new com.j256.ormlite.sqlcipher.android.compat.BasicApiCompatibility();
44 | }
45 | }
46 |
47 | /**
48 | * Return the compatibility class that matches our build number.
49 | */
50 | public static ApiCompatibility getCompatibility() {
51 | return compatibility;
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/sqlcipher-old/src/main/java/com/j256/ormlite/sqlcipher/android/compat/BasicApiCompatibility.java:
--------------------------------------------------------------------------------
1 | package com.j256.ormlite.sqlcipher.android.compat;
2 |
3 |
4 | import net.sqlcipher.Cursor;
5 | import net.sqlcipher.database.SQLiteDatabase;
6 |
7 | /**
8 | * Basic class which provides no-op methods for all Android version.
9 | *
10 | * @author graywatson
11 | */
12 | public class BasicApiCompatibility implements ApiCompatibility {
13 |
14 | public Cursor rawQuery(SQLiteDatabase db, String sql, String[] selectionArgs, CancellationHook cancellationHook) {
15 | // NOTE: cancellationHook will always be null
16 | return db.rawQuery(sql, selectionArgs);
17 | }
18 |
19 | public CancellationHook createCancellationHook() {
20 | return null;
21 | }
22 | }
23 |
--------------------------------------------------------------------------------
/sqlcipher-old/src/main/java/com/j256/ormlite/sqlcipher/android/compat/JellyBeanApiCompatibility.java:
--------------------------------------------------------------------------------
1 | package com.j256.ormlite.sqlcipher.android.compat;
2 |
3 | import android.annotation.TargetApi;
4 | import android.os.Build;
5 | import android.os.CancellationSignal;
6 |
7 | import net.sqlcipher.Cursor;
8 | import net.sqlcipher.database.SQLiteDatabase;
9 |
10 | /**
11 | * Basic class which provides no-op methods for all Android version.
12 | *
13 | *
14 | * NOTE: Will show as in error if compiled with previous Android versions.
15 | *
16 | *
17 | * @author graywatson
18 | */
19 | public class JellyBeanApiCompatibility extends BasicApiCompatibility {
20 |
21 | @Override
22 | public Cursor rawQuery(SQLiteDatabase db, String sql, String[] selectionArgs, CancellationHook cancellationHook) {
23 | // NOTE: in patched version this is the same as BasicApiCompatibility
24 | // because SqlCipher supports Android version lower than API level 16 (Jelly Bean)
25 | // if (cancellationHook == null) {
26 | return db.rawQuery(sql, selectionArgs);
27 | // } else {
28 | // return db.rawQuery(sql, selectionArgs, ((JellyBeanCancellationHook) cancellationHook).cancellationSignal);
29 | // }
30 | }
31 |
32 | @Override
33 | public CancellationHook createCancellationHook() {
34 | return new JellyBeanCancellationHook();
35 | }
36 |
37 | protected static class JellyBeanCancellationHook implements CancellationHook {
38 |
39 | private final CancellationSignal cancellationSignal;
40 |
41 | @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
42 | public JellyBeanCancellationHook() {
43 | this.cancellationSignal = new CancellationSignal();
44 | }
45 |
46 | @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
47 | public void cancel() {
48 | cancellationSignal.cancel();
49 | }
50 | }
51 | }
52 |
--------------------------------------------------------------------------------
/sqlcipher-old/src/main/java/com/j256/ormlite/sqlcipher/db/SqliteAndroidDatabaseType.java:
--------------------------------------------------------------------------------
1 | package com.j256.ormlite.sqlcipher.db;
2 |
3 | import com.j256.ormlite.db.BaseSqliteDatabaseType;
4 | import com.j256.ormlite.field.DataPersister;
5 | import com.j256.ormlite.field.FieldConverter;
6 | import com.j256.ormlite.field.FieldType;
7 | import com.j256.ormlite.field.types.DateStringType;
8 | import com.j256.ormlite.sqlcipher.android.DatabaseTableConfigUtil;
9 | import com.j256.ormlite.support.ConnectionSource;
10 | import com.j256.ormlite.table.DatabaseTableConfig;
11 |
12 | import java.sql.SQLException;
13 |
14 | /**
15 | * Sqlite database type information for the Android OS that makes native calls to the Android OS database APIs.
16 | *
17 | * @author graywatson
18 | */
19 | public class SqliteAndroidDatabaseType extends BaseSqliteDatabaseType {
20 |
21 | @Override
22 | public void loadDriver() {
23 | // noop
24 | }
25 |
26 | public boolean isDatabaseUrlThisType(String url, String dbTypePart) {
27 | // not used by the android code
28 | return true;
29 | }
30 |
31 | @Override
32 | protected String getDriverClassName() {
33 | // no driver to load in android-land
34 | return null;
35 | }
36 |
37 | public String getDatabaseName() {
38 | return "Android SQLite";
39 | }
40 |
41 | @Override
42 | protected void appendDateType(StringBuilder sb, FieldType fieldType, int fieldWidth) {
43 | // default is to store the date as a string
44 | appendStringType(sb, fieldType, fieldWidth);
45 | }
46 |
47 | @Override
48 | protected void appendBooleanType(StringBuilder sb, FieldType fieldType, int fieldWidth) {
49 | // we have to convert booleans to numbers
50 | appendShortType(sb, fieldType, fieldWidth);
51 | }
52 |
53 | @Override
54 | public FieldConverter getFieldConverter(DataPersister dataPersister) {
55 | // we are only overriding certain types
56 | switch (dataPersister.getSqlType()) {
57 | case DATE :
58 | return DateStringType.getSingleton();
59 | default :
60 | return super.getFieldConverter(dataPersister);
61 | }
62 | }
63 |
64 | @Override
65 | public boolean isNestedSavePointsSupported() {
66 | return false;
67 | }
68 |
69 | @Override
70 | public boolean isBatchUseTransaction() {
71 | return true;
72 | }
73 |
74 | @Override
75 | public DatabaseTableConfig extractDatabaseTableConfig(ConnectionSource connectionSource, Class clazz)
76 | throws SQLException {
77 | return DatabaseTableConfigUtil.fromClass(connectionSource, clazz);
78 | }
79 | }
80 |
--------------------------------------------------------------------------------
/sqlcipher-old/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
1 |
2 | database
3 |
4 |
--------------------------------------------------------------------------------
/sqlcipher/.gitignore:
--------------------------------------------------------------------------------
1 | /build
2 |
--------------------------------------------------------------------------------
/sqlcipher/build.gradle:
--------------------------------------------------------------------------------
1 | apply plugin: 'com.android.library'
2 | apply from: 'maven_upload.gradle'
3 | apply from: '../config.gradle'
4 |
5 | android {
6 | compileSdkVersion compileSdkVer
7 | buildToolsVersion buildToolsVer
8 |
9 | defaultConfig {
10 | minSdkVersion minSdkVer
11 | targetSdkVersion targetSdkVer
12 | versionCode 1
13 | versionName "1.0"
14 | }
15 | buildTypes {
16 | release {
17 | minifyEnabled false
18 | proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
19 | }
20 | }
21 |
22 | }
23 |
24 | repositories {
25 | flatDir {
26 | dirs 'libs' //this way we can find the .aar file in libs folder
27 | }
28 | }
29 |
30 | dependencies {
31 | compile 'net.zetetic:android-database-sqlcipher:3.5.4'
32 | compile 'com.j256.ormlite:ormlite-core:4.48'
33 | }
34 |
--------------------------------------------------------------------------------
/sqlcipher/maven_pom.properties:
--------------------------------------------------------------------------------
1 | POM_NAME=android
2 | POM_DESCRIPTION=app sql cipher lib
3 | POM_GROUP=com.xtc.data
4 | POM_ARTIFACT_ID=data-new-sqlcipher
5 | POM_PACKAGING=aar
6 | POM_VERSION=0.0.2-SNAPSHOT
--------------------------------------------------------------------------------
/sqlcipher/maven_upload.gradle:
--------------------------------------------------------------------------------
1 | apply plugin: 'maven'
2 |
3 | Properties user_properties = new Properties()
4 | user_properties.load(project.rootProject.file('maven_user.properties').newDataInputStream())
5 | def repoUrl = user_properties.getProperty("repository.url")
6 | def userName = user_properties.getProperty("repository.user")
7 | def userPassword = user_properties.getProperty("repository.password")
8 |
9 | Properties pom_properties = new Properties()
10 | pom_properties.load(project.file('maven_pom.properties').newDataInputStream())
11 | def pom_name = pom_properties.getProperty("POM_NAME")
12 | def pom_description = pom_properties.getProperty("POM_DESCRIPTION")
13 | def pom_group = pom_properties.getProperty("POM_GROUP")
14 | def pom_artifact_id = pom_properties.getProperty("POM_ARTIFACT_ID")
15 | def pom_packaging = pom_properties.getProperty("POM_PACKAGING")
16 | def pom_version = pom_properties.getProperty("POM_VERSION")
17 |
18 |
19 | uploadArchives {
20 |
21 | repositories.mavenDeployer {
22 | repository(url: repoUrl) {
23 | authentication(userName: userName,
24 | password: userPassword)
25 | }
26 |
27 | pom.project {
28 | name pom_name
29 | description pom_description
30 | groupId pom_group
31 | artifactId pom_artifact_id
32 | version pom_version
33 | packaging pom_packaging
34 | }
35 | }
36 | }
--------------------------------------------------------------------------------
/sqlcipher/proguard-rules.pro:
--------------------------------------------------------------------------------
1 | # Add project specific ProGuard rules here.
2 | # By default, the flags in this file are appended to flags specified
3 | # in /Users/Stay/develop/android-sdk-mac_x86/tools/proguard/proguard-android.txt
4 | # You can edit the include path and order by changing the proguardFiles
5 | # directive in build.gradle.
6 | #
7 | # For more details, see
8 | # http://developer.android.com/guide/developing/tools/proguard.html
9 |
10 | # Add any project specific keep options here:
11 |
12 | # If your project uses WebView with JS, uncomment the following
13 | # and specify the fully qualified class name to the JavaScript interface
14 | # class:
15 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
16 | # public *;
17 | #}
18 |
--------------------------------------------------------------------------------
/sqlcipher/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
--------------------------------------------------------------------------------
/sqlcipher/src/main/java/com/j256/ormlite/sqlcipher/DatabaseEncrypted.java:
--------------------------------------------------------------------------------
1 | package com.j256.ormlite.sqlcipher;
2 |
3 | import android.app.Application;
4 | import android.util.Log;
5 |
6 | import net.sqlcipher.database.SQLiteDatabase;
7 |
8 | import java.io.File;
9 |
10 |
11 | /**
12 | * 数据库加密
13 | */
14 | public class DatabaseEncrypted {
15 |
16 | private static final String TAG = "DatabaseEncrypted";
17 |
18 | /**
19 | * 将未加密数据库转换为加密数据库
20 | *
21 | * @param application application
22 | * @param unencryptedDbName 未加密数据库名
23 | * @param encryptedDbName 加密数据库名
24 | * @param password 加密数据库密码
25 | */
26 | public static boolean importUnencryptedDatabase(Application application, String unencryptedDbName,
27 | String encryptedDbName, String password) {
28 | File unencryptedFile = application.getDatabasePath(unencryptedDbName);
29 | if (!unencryptedFile.exists()) {
30 | Log.i(TAG, "unencrypted database not exist");
31 | return true;
32 | }
33 |
34 | File encryptedFile = application.getDatabasePath(encryptedDbName);
35 | if (encryptedFile.exists()) {
36 | Log.i(TAG, "encrypted database is exist");
37 | return true;
38 | }
39 |
40 | Log.i(TAG, "encrypted database");
41 | SQLiteDatabase database = null;
42 | try {
43 | database = SQLiteDatabase.openOrCreateDatabase(unencryptedFile, "", null);
44 |
45 | database.rawExecSQL(String.format("ATTACH DATABASE '%s' AS encrypted KEY '%s'",
46 | encryptedFile.getAbsolutePath(), password));
47 | database.rawExecSQL("select sqlcipher_export('encrypted')");
48 | database.rawExecSQL("DETACH DATABASE encrypted");
49 |
50 | return true;
51 | } catch (Exception e) {
52 | e.printStackTrace();
53 | return false;
54 | } finally {
55 | if (database != null) {
56 | database.close();
57 | }
58 | application.deleteDatabase(unencryptedDbName);
59 | SQLiteDatabase.releaseMemory();
60 | }
61 | }
62 |
63 | /**
64 | * 将加密数据库转换为常规数据库
65 | *
66 | * @param application application
67 | * @param encryptedDbName 加密数据库名
68 | * @param unencryptedDbName 未加密数据库名
69 | * @param password 加密数据库密码
70 | */
71 | public static boolean exportToUnencryptedDatabase(Application application, String encryptedDbName, String unencryptedDbName, String password) {
72 | File encryptedFile = application.getDatabasePath(encryptedDbName);
73 | if (!encryptedFile.exists()) {
74 | Log.i(TAG, "encrypted database not exist");
75 | return true;
76 | }
77 |
78 | File unencryptedFile = application.getDatabasePath(unencryptedDbName);
79 | if (unencryptedFile.exists()) {
80 | Log.i(TAG, "unencrypted database is exist");
81 | return true;
82 | }
83 |
84 | Log.i(TAG, "unencrypted database");
85 | SQLiteDatabase database = null;
86 | try {
87 | database = SQLiteDatabase.openOrCreateDatabase(encryptedFile, password, null);
88 |
89 | application.deleteDatabase(unencryptedDbName);
90 | database.rawExecSQL(String.format("ATTACH DATABASE '%s' as plaintext KEY '';",
91 | unencryptedFile.getAbsolutePath()));
92 | database.rawExecSQL("SELECT sqlcipher_export('plaintext');");
93 | database.rawExecSQL("DETACH DATABASE plaintext;");
94 |
95 | return true;
96 | } catch (Exception e) {
97 | e.printStackTrace();
98 | return false;
99 | } finally {
100 | if (database != null) {
101 | database.close();
102 | }
103 | application.deleteDatabase(encryptedDbName);
104 | SQLiteDatabase.releaseMemory();
105 | }
106 | }
107 |
108 | }
109 |
--------------------------------------------------------------------------------
/sqlcipher/src/main/java/com/j256/ormlite/sqlcipher/android/AndroidCompiledStatement.java:
--------------------------------------------------------------------------------
1 | package com.j256.ormlite.sqlcipher.android;
2 |
3 |
4 | import com.j256.ormlite.dao.ObjectCache;
5 | import com.j256.ormlite.field.SqlType;
6 | import com.j256.ormlite.logger.Logger;
7 | import com.j256.ormlite.logger.LoggerFactory;
8 | import com.j256.ormlite.misc.SqlExceptionUtil;
9 | import com.j256.ormlite.sqlcipher.android.compat.ApiCompatibility;
10 | import com.j256.ormlite.sqlcipher.android.compat.ApiCompatibilityUtils;
11 | import com.j256.ormlite.stmt.StatementBuilder.StatementType;
12 | import com.j256.ormlite.support.CompiledStatement;
13 | import com.j256.ormlite.support.DatabaseResults;
14 |
15 | import net.sqlcipher.Cursor;
16 | import net.sqlcipher.database.SQLiteDatabase;
17 | import net.sqlcipher.database.SQLiteStatement;
18 |
19 | import java.sql.SQLException;
20 | import java.util.ArrayList;
21 | import java.util.List;
22 |
23 | /**
24 | * Android implementation of the compiled statement.
25 | *
26 | * @author kevingalligan, graywatson
27 | */
28 | public class AndroidCompiledStatement implements CompiledStatement {
29 |
30 | private static Logger logger = LoggerFactory.getLogger(AndroidCompiledStatement.class);
31 |
32 | private static final String[] NO_STRING_ARGS = new String[0];
33 | private static final ApiCompatibility apiCompatibility = ApiCompatibilityUtils.getCompatibility();
34 |
35 | private final String sql;
36 | private final SQLiteDatabase db;
37 | private final StatementType type;
38 | private final boolean cancelQueriesEnabled;
39 |
40 | private Cursor cursor;
41 | private List