import android.arch.persistence.db.SupportSQLiteOpenHelper; //导入依赖的package包/类
@Override
public void tearDownDatabase(Context ctxt,
                             SupportSQLiteOpenHelper.Factory factory,
                             SupportSQLiteOpenHelper helper) {
  String name=helper.getDatabaseName();

  if (name!=null) {
    File db=ctxt.getDatabasePath(name);

    if (db.exists()) {
      db.delete();
    }

    File journal=new File(db.getParentFile(), name+"-journal");

    if (journal.exists()) {
      journal.delete();
    }
  }
}
 

import android.arch.persistence.db.SupportSQLiteOpenHelper; //导入依赖的package包/类
@Test
public void rekey() throws IOException {
  SafeHelperFactory factory=
    SafeHelperFactory.fromUser(new SpannableStringBuilder("sekrit"));
  SupportSQLiteOpenHelper helper=
    factory.create(InstrumentationRegistry.getTargetContext(), DB_NAME, 1,
      new Callback(1));
  SupportSQLiteDatabase db=helper.getWritableDatabase();

  assertOriginalContent(db);
  SafeHelperFactory.rekey(db, new SpannableStringBuilder(PASSPHRASE));
  assertOriginalContent(db);
  db.execSQL("UPDATE foo SET bar=?, goo=?", new Object[] {3, "four"});
  assertUpdatedContent(db);
  db.close();

  factory=SafeHelperFactory.fromUser(new SpannableStringBuilder(PASSPHRASE));
  helper=factory.create(InstrumentationRegistry.getTargetContext(), DB_NAME, 1,
    new Callback(1));
  db=helper.getWritableDatabase();
  assertUpdatedContent(db);
}
 

import android.arch.persistence.db.SupportSQLiteOpenHelper; //导入依赖的package包/类
@Before public void setUp() throws IOException {
  Configuration configuration = Configuration.builder(InstrumentationRegistry.getContext())
      .callback(testDb)
      .name(dbFolder.newFile().getPath())
      .build();

  Factory factory = new FrameworkSQLiteOpenHelperFactory();
  SupportSQLiteOpenHelper helper = factory.create(configuration);
  real = helper.getWritableDatabase();

  SqlBrite.Logger logger = new SqlBrite.Logger() {
    @Override public void log(String message) {
      logs.add(message);
    }
  };
  ObservableTransformer<Query, Query> queryTransformer =
      new ObservableTransformer<Query, Query>() {
        @Override public ObservableSource<Query> apply(Observable<Query> upstream) {
          return upstream.takeUntil(killSwitch);
        }
      };
  db = new BriteDatabase(helper, logger, scheduler, queryTransformer);
}
 

import android.arch.persistence.db.SupportSQLiteOpenHelper; //导入依赖的package包/类
public AutoContentProvider(ContentHelper contentHelper, Logger logger, SupportSQLiteOpenHelperFactoryProvider supportSQLiteOpenHelperFactoryProvider) {
    this.logger = logger != null ? logger : Logger.EmptyLogger.INSTANCE;
    this.contentHelper = contentHelper;
    this.supportSQLiteOpenHelperFactoryProvider = supportSQLiteOpenHelperFactoryProvider;
    defaultCallback = new SupportSQLiteOpenHelper.Callback(contentHelper.DATABASE_VERSION) {
        @Override
        public void onCreate(SupportSQLiteDatabase db) {
            onCreateDataBase(db);
        }

        @Override
        public void onUpgrade(SupportSQLiteDatabase db, int oldVersion, int newVersion) {
            onUpgradeDatabase(db, oldVersion, newVersion);
        }
    };
}
 

import android.arch.persistence.db.SupportSQLiteOpenHelper; //导入依赖的package包/类
@Override
public SupportSQLiteOpenHelper create(SupportSQLiteOpenHelper.Configuration configuration) {
    return new AssetSQLiteOpenHelper(
            configuration.context, configuration.name, null,
            configuration.version, configuration.errorHandler, configuration.callback
    );
}
 

import android.arch.persistence.db.SupportSQLiteOpenHelper; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public SupportSQLiteOpenHelper create(
  SupportSQLiteOpenHelper.Configuration configuration) {
  return(create(configuration.context, configuration.name,
    configuration.callback.version, configuration.callback));
}
 

import android.arch.persistence.db.SupportSQLiteOpenHelper; //导入依赖的package包/类
Helper(Context context, String name, int version,
       SupportSQLiteOpenHelper.Callback callback, char[] passphrase) {
  SQLiteDatabase.loadLibs(context);
  delegate=createDelegate(context, name, version, callback);
  this.passphrase=passphrase;
  this.name=name;
}
 

import android.arch.persistence.db.SupportSQLiteOpenHelper; //导入依赖的package包/类
@Test
public void reInitClosesPrev() {
  final DbConnectionImpl dbConnection = SqliteMagic.getDefaultDbConnection();
  final SupportSQLiteOpenHelper dbHelper = dbConnection.dbHelper;
  final SupportSQLiteDatabase readableDatabase = dbHelper.getReadableDatabase();
  final SupportSQLiteDatabase writableDatabase = dbHelper.getWritableDatabase();

  initDbWithNewConnection();

  assertThat(readableDatabase.isOpen()).isFalse();
  assertThat(writableDatabase.isOpen()).isFalse();
  assertThat(dbConnection.triggers.hasObservers()).isFalse();
  assertThat(dbConnection.triggers.hasComplete()).isTrue();
}
 

import android.arch.persistence.db.SupportSQLiteOpenHelper; //导入依赖的package包/类
DbConnectionImpl(@NonNull SupportSQLiteOpenHelper dbHelper, @NonNull Scheduler queryScheduler) {
  this.dbHelper = dbHelper;
  this.queryScheduler = queryScheduler;
  final int nrOfTables = getNrOfTables();
  final EntityDbManager[] cachedEntityData = new EntityDbManager[nrOfTables];
  for (int i = 0; i < nrOfTables; i++) {
    cachedEntityData[i] = new EntityDbManager(this);
  }
  this.entityDbManagers = cachedEntityData;
}
 

import android.arch.persistence.db.SupportSQLiteOpenHelper; //导入依赖的package包/类
static DbConnectionImpl openConnection(@NonNull Application context,
                                       @NonNull DatabaseSetupBuilder databaseSetupBuilder) {
  final Factory sqliteFactory = databaseSetupBuilder.sqliteFactory;
  if (sqliteFactory == null) {
    throw new NullPointerException("SQLite Factory cannot be null");
  }
  try {
    String name = databaseSetupBuilder.name;
    if (name == null || name.isEmpty()) {
      name = getDbName();
    }
    final int version = getDbVersion();
    final DbCallback dbCallback = new DbCallback(context, version);
    final Configuration configuration = Configuration
        .builder(context)
        .name(name)
        .callback(dbCallback)
        .build();
    final SupportSQLiteOpenHelper helper = sqliteFactory.create(configuration);
    LogUtil.logInfo("Initializing database with [name=%s, version=%s, logging=%s]",
        name, version, LOGGING_ENABLED);
    return new DbConnectionImpl(helper, databaseSetupBuilder.queryScheduler);
  } catch (Exception e) {
    throw new IllegalStateException("Error initializing database. " +
        "Make sure there is at least one model annotated with @Table", e);
  }
}
 

import android.arch.persistence.db.SupportSQLiteOpenHelper; //导入依赖的package包/类
BriteDatabase(SupportSQLiteOpenHelper helper, Logger logger, Scheduler scheduler,
    ObservableTransformer<Query, Query> queryTransformer) {
  this.helper = helper;
  this.logger = logger;
  this.scheduler = scheduler;
  this.queryTransformer = queryTransformer;
}
 

import android.arch.persistence.db.SupportSQLiteOpenHelper; //导入依赖的package包/类
@Before public void setUp() {
  Configuration configuration = Configuration.builder(InstrumentationRegistry.getContext())
      .callback(new TestDb())
      .build();

  Factory factory = new FrameworkSQLiteOpenHelperFactory();
  SupportSQLiteOpenHelper helper = factory.create(configuration);

  SqlBrite sqlBrite = new SqlBrite.Builder().build();
  db = sqlBrite.wrapDatabaseHelper(helper, Schedulers.trampoline());
}
 

import android.arch.persistence.db.SupportSQLiteOpenHelper; //导入依赖的package包/类
@Provides @Singleton BriteDatabase provideDatabase(SqlBrite sqlBrite, Application application) {
  Configuration configuration = Configuration.builder(application)
      .name("todo.db")
      .callback(new DbCallback())
      .build();
  Factory factory = new FrameworkSQLiteOpenHelperFactory();
  SupportSQLiteOpenHelper helper = factory.create(configuration);
  BriteDatabase db = sqlBrite.wrapDatabaseHelper(helper, Schedulers.io());
  db.setLoggingEnabled(true);
  return db;
}
 

import android.arch.persistence.db.SupportSQLiteOpenHelper; //导入依赖的package包/类
public TestProvider() {
    super(CONTENT_HELPER, Logger.EmptyLogger.INSTANCE,
            new SupportSQLiteOpenHelperFactoryProvider() {
                @Override
                public SupportSQLiteOpenHelper.Factory createFactory(Context context) {
                    return new FrameworkSQLiteOpenHelperFactory();
                }
            });
}
 

import android.arch.persistence.db.SupportSQLiteOpenHelper; //导入依赖的package包/类
@Override
public SupportSQLiteOpenHelper.Factory getFactory() {
  return SafeHelperFactory.fromUser(new SpannableStringBuilder("sekrit"));
}
 

import android.arch.persistence.db.SupportSQLiteOpenHelper; //导入依赖的package包/类
/**
 * @deprecated use {@link io.requery.android.database.sqlite.RequerySQLiteOpenHelperFactory} instead
 */
@Deprecated
@Override
public SupportSQLiteOpenHelper create(SupportSQLiteOpenHelper.Configuration config) {
    return factory.create(config);
}
 

import android.arch.persistence.db.SupportSQLiteOpenHelper; //导入依赖的package包/类
@Override
public SupportSQLiteOpenHelper create(Configuration config) {
    return new CallbackSQLiteOpenHelper(config.context, config.name, config.callback);
}
 

import android.arch.persistence.db.SupportSQLiteOpenHelper; //导入依赖的package包/类
@Override
public SupportSQLiteOpenHelper.Factory createFactory(Context context) {
    return new SqlCipherOpenHelperFactory("test");
}
 

import android.arch.persistence.db.SupportSQLiteOpenHelper; //导入依赖的package包/类
@Override
public SupportSQLiteOpenHelper.Factory createFactory(Context context) {
    return new FrameworkSQLiteOpenHelperFactory();
}
 

import android.arch.persistence.db.SupportSQLiteOpenHelper; //导入依赖的package包/类
@Override
public SupportSQLiteOpenHelper create(SupportSQLiteOpenHelper.Configuration configuration) {
    SQLiteDatabase.loadLibs(configuration.context);
    return new SqlCipherOpenHelper(
            configuration.context, configuration.name, configuration.callback, password);
}