androidx.room.Room Java Examples

/**
 * Returns the mesh database
 */
@RestrictTo(RestrictTo.Scope.LIBRARY)
static MeshNetworkDb getDatabase(final Context context) {
    if (INSTANCE == null) {
        synchronized (MeshNetworkDb.class) {
            if (INSTANCE == null) {
                INSTANCE = Room.databaseBuilder(context.getApplicationContext(),
                        MeshNetworkDb.class, "mesh_network_database.db")
                        .addCallback(sRoomDatabaseCallback)
                        .addMigrations(MIGRATION_1_2)
                        .addMigrations(MIGRATION_2_3)
                        .addMigrations(MIGRATION_3_4)
                        .addMigrations(MIGRATION_4_5)
                        .addMigrations(MIGRATION_5_6)
                        .addMigrations(MIGRATION_6_7)
                        .addMigrations(MIGRATION_7_8)
                        .addMigrations(MIGRATION_8_9)
                        .build();
            }

        }
    }
    return INSTANCE;
}
 

public void reopenDatabase(boolean truncate) throws SQLiteDatabaseCorruptException {
    if (appDB != null) {
        appDB.close();
    }

    appDB = Room.databaseBuilder(context, AppDatabase.class, DATABASE_NAME)
            .allowMainThreadQueries()
            .setJournalMode(truncate == true ? RoomDatabase.JournalMode.TRUNCATE : RoomDatabase.JournalMode.AUTOMATIC) // in truncate mode no sql cache files (-shm, -wal) are generated
            .addCallback(new RoomDatabase.Callback() {
                @Override
                public void onOpen(SupportSQLiteDatabase db) {
                    super.onOpen(db);
                    db.setForeignKeyConstraintsEnabled(true);
                }
            })
            .addMigrations(AppDatabase.MIGRATION_1_2, AppDatabase.MIGRATION_2_3, AppDatabase.MIGRATION_3_4, AppDatabase.MIGRATION_4_5)
            .build();
    measurementDAO = appDB.measurementDAO();
    userDAO = appDB.userDAO();
}
 

static StuffDatabase create(Context ctxt, boolean memoryOnly, boolean truncate) {
  RoomDatabase.Builder<StuffDatabase> b;

  if (memoryOnly) {
    b=Room.inMemoryDatabaseBuilder(ctxt.getApplicationContext(),
      StuffDatabase.class);
  }
  else {
    b=Room.databaseBuilder(ctxt.getApplicationContext(), StuffDatabase.class,
      DB_NAME);
  }

  if (truncate) {
    b.setJournalMode(JournalMode.TRUNCATE);
  }

  b.openHelperFactory(SafeHelperFactory.fromUser(new SpannableStringBuilder("sekrit")));

  return(b.build());
}
 

public DokitDatabase getDb() {
    if (mDB != null) {
        return mDB;
    }

    mDB = Room.databaseBuilder(DoraemonKit.APPLICATION,
            DokitDatabase.class,
            "dokit-database")
            //下面注释表示允许主线程进行数据库操作，但是不推荐这样做。
            //他可能造成主线程lock以及anr
            //所以我们的操作都是在新线程完成的
            .allowMainThreadQueries()
            .build();

    return mDB;
}
 

public static WordRoomDatabase getDatabase(final Context context) {
    if (INSTANCE == null) {
        synchronized (WordRoomDatabase.class) {
            if (INSTANCE == null) {
                // database creation goes here

                /*
                 * use databaseBuilder() to build Room database named "word_database".
                 * It uses destructive database migration (if database schema is changed, destroy and recreate database)
                 * Destructive migration is not preferred in real world apps
                 * */
                INSTANCE = Room.databaseBuilder(context.getApplicationContext(), WordRoomDatabase.class, "word_database")
                        .fallbackToDestructiveMigration()
                        .addCallback(sRoomDatabaseCallback)
                        .build();
            }
        }
    }
    return INSTANCE;
}
 

public static WordRoomDatabase getDatabase(final Context context) {
    if (INSTANCE == null) {
        synchronized (WordRoomDatabase.class) {
            if (INSTANCE == null) {
                // database creation goes here

                /*
                 * use databaseBuilder() to build Room database named "word_database".
                 * It uses destructive database migration (if database schema is changed, destroy and recreate database)
                 * Destructive migration is not preferred in real world apps
                 * */
                INSTANCE = Room.databaseBuilder(context.getApplicationContext(), WordRoomDatabase.class, "word_database")
                        .fallbackToDestructiveMigration()
                        .addCallback(sRoomDatabaseCallback)
                        .build();
            }
        }
    }
    return INSTANCE;
}
 

public static WordRoomDatabase getDatabase(final Context context){
    if (INSTANCE == null){
        synchronized (WordRoomDatabase.class){
            if (INSTANCE == null){
                // database creation goes here

                /*
                * use databaseBuilder() to build Room database named "word_database".
                * It uses destructive database migration (if database schema is changed, destroy and recreate database)
                * Destructive migration is not preferred in real world apps
                * */
                INSTANCE = Room.databaseBuilder(context.getApplicationContext(), WordRoomDatabase.class, "word_database")
                        .fallbackToDestructiveMigration()
                        .addCallback(sRoomDatabaseCallback)
                        .build();
            }
        }
    }
    return INSTANCE;
}
 

public static LoginsDatabase getDatabase(Context context) {
    if (INSTANCE == null) {
        synchronized (LoginsDatabase.class) {
            if (INSTANCE == null) {
                INSTANCE = Room.databaseBuilder(context.getApplicationContext(), LoginsDatabase.class,
                        DATABASE_NAME).allowMainThreadQueries().build();
            }
        }
    }
    return INSTANCE;

}
 

@Before
public void before() throws Exception {
  // using an in-memory database because the information stored here disappears when the
  // process is killed
  database = Room.inMemoryDatabaseBuilder(InstrumentationRegistry.getContext(),
    SearchHistoryDatabase.class)
    // allowing main thread queries, just for testing
    .allowMainThreadQueries()
    .build();

  searchHistoryDao = database.searchHistoryDao();
}
 

@Test
public void encryptAndMigrate() throws IOException {
  assertEquals(SQLCipherUtils.State.DOES_NOT_EXIST, SQLCipherUtils.getDatabaseState(ctxt, DB_NAME));

  TestV1Database v1 = Room.databaseBuilder(ctxt, TestV1Database.class, DB_NAME).build();
  String keyOne = UUID.randomUUID().toString();
  TestEntity entity = new TestEntity(keyOne);

  v1.testStore().insert(entity);

  List<TestEntity> entitiesOne = v1.testStore().loadAll();

  assertEquals(1, entitiesOne.size());
  assertEquals(keyOne, entitiesOne.get(0).id);

  v1.close();

  assertEquals(SQLCipherUtils.State.UNENCRYPTED, SQLCipherUtils.getDatabaseState(ctxt, DB_NAME));
  SQLCipherUtils.encrypt(ctxt, ctxt.getDatabasePath(DB_NAME), PASSPHRASE.toCharArray());
  assertEquals(SQLCipherUtils.State.ENCRYPTED, SQLCipherUtils.getDatabaseState(ctxt, DB_NAME));

  SafeHelperFactory factory=
      SafeHelperFactory.fromUser(new SpannableStringBuilder(PASSPHRASE));
  TestV2Database v2 = Room.databaseBuilder(ctxt, TestV2Database.class, DB_NAME)
      .addMigrations(TestV2Database.MIGRATION_1_2)
      .openHelperFactory(factory)
      .build();

  List<com.commonsware.cwac.saferoom.test.room.migratecrypt.v2.TestEntity> entitiesTwo =
      v2.testStore().loadAll();

  assertEquals(1, entitiesTwo.size());
  assertEquals(keyOne, entitiesTwo.get(0).id);
}
 

public static GanderStorage getInstance(Context context) {
    if (GANDER_DATABASE_INSTANCE == null) {
        GANDER_DATABASE_INSTANCE = Room.databaseBuilder(context, GanderPersistence.class, "GanderDatabase")
                .fallbackToDestructiveMigration()
                .build();
    }
    return GANDER_DATABASE_INSTANCE;
}
 

public static DeadlineDatabase getDatabase(final Context context) {
    if (INSTANCE == null) {
        synchronized (DeadlineDatabase.class) {
            if (INSTANCE == null) {
                INSTANCE = Room.databaseBuilder(context.getApplicationContext(),
                        DeadlineDatabase.class, "event_database.db")
                        .build();
            }
        }
    }
    return INSTANCE;
}
 

private static SearchHistoryDatabase buildDatabase(final Context appContext) {
  return Room.databaseBuilder(appContext, SearchHistoryDatabase.class, DATABASE_NAME).addCallback(
    new Callback() {
      @Override
      public void onCreate(@NonNull SupportSQLiteDatabase db) {
        super.onCreate(db);
        SearchHistoryDatabase database = SearchHistoryDatabase.getInstance(appContext);
        database.setDatabaseCreated();
      }
    }).build();
}
 

static WordRoomDatabase getDatabase(final Context context) {
    if (INSTANCE == null) {
        synchronized (WordRoomDatabase.class) {
            if (INSTANCE == null) {
                INSTANCE = Room.databaseBuilder(context.getApplicationContext(), WordRoomDatabase.class, "word_database")
                        .fallbackToDestructiveMigration()
                        .addCallback(sRoomDatabaseCallback)
                        .build();
            }
        }
    }
    return INSTANCE;
}
 

public static RemindersDatabase getInstance(Context context) {
    synchronized (LOCK) {
        if (remindersDatabase == null)
            remindersDatabase = Room.databaseBuilder(context.getApplicationContext(),
                    RemindersDatabase.class, "reminders")
                    .allowMainThreadQueries()
                    .build();
        return remindersDatabase;
    }
}
 

public static AppsDatabase getInstance(Context context) {
    synchronized (LOCK) {
        if (appsDatabase == null)
            appsDatabase = Room.databaseBuilder(context.getApplicationContext(),
                    AppsDatabase.class, "applications").allowMainThreadQueries().build();
        return appsDatabase;
    }
}
 

public static RoomFileDatabase getRoomFileDatabase(final Context context) {
    if (roomFileDatabase == null) {
        synchronized (RoomFileDatabase.class) {
            if (roomFileDatabase == null) {
                roomFileDatabase = Room.databaseBuilder(context.getApplicationContext(),
                        RoomFileDatabase.class,
                        "room_file_database")
                        .build();
            }
        }
    }
    return roomFileDatabase;
}
 

static NoteRoomDatabase getDatabase(final Context context) {
    if (INSTANCE == null) {
        synchronized (NoteRoomDatabase.class) {
            if (INSTANCE == null) {
                INSTANCE = Room.databaseBuilder(context.getApplicationContext(), NoteRoomDatabase.class, "note_database")
                        .fallbackToDestructiveMigration()
                        .addCallback(sRoomDatabaseCallback)
                        .build();
            }
        }
    }
    return INSTANCE;
}
 

public static synchronized HistoryDatabase getInstance(Context context){
    if (instance == null){
        historyDatabaseHelper = new DatabaseHelper(context);
        instance = Room.databaseBuilder(context.getApplicationContext(), HistoryDatabase.class, "history_database").fallbackToDestructiveMigration().addCallback(roomCallback).build();
    }
    return instance;
}
 

static AppDatabase getDatabase(Context context) {
	if (instance == null) {
		synchronized (AppDatabase.class) {
			if (instance == null) {
				instance = Room.databaseBuilder(context.getApplicationContext(),
						AppDatabase.class, "apps-database.db").build();
			}
		}
	}
	return instance;
}
 

static WordRoomDatabase getDatabase(final Context context) {
    if (INSTANCE == null) {
        synchronized (WordRoomDatabase.class) {
            if (INSTANCE == null) {
                INSTANCE = Room.databaseBuilder(context.getApplicationContext(),
                        WordRoomDatabase.class, "word_database")
                        .addCallback(sRoomDatabaseCallback)
                        .build();
            }
        }
    }
    return INSTANCE;
}
 

@Before
public void createDb() {
    Context context = ApplicationProvider.getApplicationContext();
    // Using an in-memory database because the information stored here disappears when the
    // process is killed.
    mDb = Room.inMemoryDatabaseBuilder(context, WordRoomDatabase.class)
            // Allowing main thread queries, just for testing.
            .allowMainThreadQueries()
            .build();
    mWordDao = mDb.wordDao();
}
 

public static ZephyrDatabase buildDatabase(final Context appContext) {
    return Room.databaseBuilder(appContext, ZephyrDatabase.class, Constants.DB_NAME)
            .addMigrations(DatabaseMigrationFactory.getMigrations())
            .fallbackToDestructiveMigration()
            .fallbackToDestructiveMigrationOnDowngrade()
            .build();
}
 

static ActivityRoomDatabase getInstance(Context context) {
    if (INSTANCE == null) {
        synchronized (ActivityRoomDatabase.class) {
            if (INSTANCE == null) {
                INSTANCE = Room.databaseBuilder(context.getApplicationContext(),
                        ActivityRoomDatabase.class,"activity_database.db")
                        .setJournalMode(JournalMode.TRUNCATE)
                        .build();
            }
        }
    }
    return INSTANCE;
}
 

public static UserDataBase getDatabase() {
    if (sInstance == null) {
        sInstance = Room.databaseBuilder(RootApplication.getContext(),
                UserDataBase.class, "User.db")
                .addMigrations(MIGRATION_2_3)
                .build();
    }
    return sInstance;
}
 

public static synchronized MaterialisticDatabase getInstance(Context context) {
    if (sInstance == null) {
        sInstance = setupBuilder(Room.databaseBuilder(context.getApplicationContext(),
                MaterialisticDatabase.class,
                DbConstants.DB_NAME))
                .build();
    }
    return sInstance;
}
 

public static synchronized MaterialisticDatabase getInstance(Context context) {
    if (sInstance == null) {
        sInstance = setupBuilder(Room.inMemoryDatabaseBuilder(context.getApplicationContext(),
                MaterialisticDatabase.class))
                .allowMainThreadQueries()
                .build();
    }
    return sInstance;
}
 

@Provides
@Singleton
public PlaybackStateDatabase providePlaybackStateDatabase(Context context) {
    return Room.databaseBuilder(context, PlaybackStateDatabase.class, "playerState")
            .allowMainThreadQueries()
            .build();
}
 

@Before
public void initDatabase() {
    Context context = InstrumentationRegistry.getInstrumentation().getTargetContext();
    appDB = Room.inMemoryDatabaseBuilder(context, AppDatabase.class).build();
    userDao = appDB.userDAO();
    measurementDAO = appDB.measurementDAO();
}
 

@Override
  public void onCreate() {
      super.onCreate();
      // when upgrading versions, kill the original tables by using
// fallbackToDestructiveMigration()
      myDatabase = Room.databaseBuilder(this, MyDatabase.class,
              MyDatabase.NAME).fallbackToDestructiveMigration().build();

      // use chrome://inspect to inspect your SQL database
      Stetho.initializeWithDefaults(this);
  }