android.arch.persistence.room.Room Java Examples

public static AppDatabase getAppDatabase(Context context) {
    if (INSTANCE == null) {
        INSTANCE =
                Room.databaseBuilder(context.getApplicationContext(),
                        AppDatabase.class, "adhell-database")
                        .addMigrations(MIGRATION_14_15)
                        .addMigrations(MIGRATION_15_16)
                        .addMigrations(MIGRATION_16_17)
                        .addMigrations(MIGRATION_17_18)
                        .addMigrations(MIGRATION_18_19)
                        .addMigrations(MIGRATION_19_20)
                        .addMigrations(MIGRATION_20_21)
                        .addMigrations(MIGRATION_21_22)
                        .build();
    }
    return INSTANCE;
}
 

public static ApplicationDatabase getInstance(final Context context) throws Exception {
    if (sInstance == null) {
        synchronized (ApplicationDatabase.class) {
            if (sInstance == null) {
                SafeHelperFactory factory = new SafeHelperFactory(KeyGenHelper.getSecretKeyAsChar(context));

                sInstance = Room.databaseBuilder(context.getApplicationContext(),ApplicationDatabase.class, DATABASE_NAME)
                        .openHelperFactory(factory)
                        .allowMainThreadQueries()
                        .addCallback(new Callback() {
                            @Override
                            public void onCreate(@NonNull SupportSQLiteDatabase db) {
                                super.onCreate(db);
                                try {
                                    ApplicationDatabase database = ApplicationDatabase.getInstance(context);
                                    // notify that the database was created and it's ready to be used
                                    database.setDatabaseCreated();
                                } catch (Exception e) {
                                    Log.e("ApplicationDatabase", e.getMessage());
                                }
                            }
                        }).build();

            }
        }
    }
    return sInstance;
}
 

public static AppDatabase getAppDatabase(Context context) {
    if (INSTANCE == null) {
        INSTANCE =
                Room.databaseBuilder(context.getApplicationContext(),
                        AppDatabase.class, "adhell-database")
                        .addMigrations(MIGRATION_14_15)
                        .addMigrations(MIGRATION_15_16)
                        .addMigrations(MIGRATION_16_17)
                        .addMigrations(MIGRATION_17_18)
                        .addMigrations(MIGRATION_18_19)
                        .addMigrations(MIGRATION_19_20)
                        .addMigrations(MIGRATION_20_21)
                        .addMigrations(MIGRATION_21_22)
                        .build();
    }
    return INSTANCE;
}
 

@Override
public <DB extends RoomDatabase> DB obtainRoomDatabase(Class<DB> database, String dbName) {
    if (mRoomDatabaseCache == null) {
        mRoomDatabaseCache = mCacheFactory.build(CacheType.ROOM_DATABASE_CACHE_TYPE);
    }
    Preconditions.checkNotNull(mRoomDatabaseCache, "Cannot return null from a Cache.Factory#build(int) method");
    DB roomDatabase;
    synchronized (mRoomDatabaseCache) {
        roomDatabase = (DB) mRoomDatabaseCache.get(database.getName());
        if (roomDatabase == null) {
            RoomDatabase.Builder builder = Room.databaseBuilder(mApplication, database, dbName);
            //自定义 Room 配置
            if (mRoomConfiguration != null) {
                mRoomConfiguration.configRoom(mApplication, builder);
            }
            roomDatabase = (DB) builder.build();
            mRoomDatabaseCache.put(database.getName(), roomDatabase);
        }
    }
    return roomDatabase;
}
 

public ApplicationModule(MyApplication application) {
    this.application = application;

    Timber.i("Build database");
    this.database = Room.databaseBuilder(
            application,
            StarterDatabase.class,
            StarterDatabase.DATABASE_NAME
    ).build();
}
 

public ApplicationModule(MyApplication application) {
    this.application = application;

    Timber.i("Build database");
    this.database = Room.databaseBuilder(
            application,
            StarterDatabase.class,
            StarterDatabase.DATABASE_NAME
    ).build();
}
 

public static synchronized CommentDatabase getInstance(Context context) {
    if (instance == null) {
        instance = Room
                .databaseBuilder(context.getApplicationContext(), CommentDatabase.class, ModelConstants.DB_NAME)
                .build();
    }
    return instance;
}
 

public static AppDatabase getDatabase(Context context) {
    if (INSTANCE == null) {
        INSTANCE = Room.databaseBuilder(context.getApplicationContext(), AppDatabase.class, "zomato_room_db")
                .build();
    }
    return INSTANCE;
}
 

/**
 * Creates the user repository, with the required application reference.
 */
public UserRepository(@NonNull OpenYoloDemoApplication application) {
    mUserDatabase = Room.databaseBuilder(application, UserDatabase.class, USER_DB_NAME)
            .build();
    mSharedPrefs = application.getSharedPreferences(
            AUTH_INFO_SHARED_PREFS,
            Context.MODE_PRIVATE);
}
 

public synchronized static PersonDatabase getPersonDatabase(Context context){
    if(personDatabase == null) {
        synchronized (LOCK) {
            if (personDatabase == null) {
                personDatabase = Room.databaseBuilder(context,
                        PersonDatabase.class, "person db").build();
            }
        }
    }
    return personDatabase;
}
 

public static AppDataBase getInstance(Context context) {
  if (appDataBaseInstance == null) {
    appDataBaseInstance = Room.databaseBuilder(context, AppDataBase.class, DATABASE_NAME).build();
    appDataBaseInstance.recordItemDataSource =
        new RecordItemDataSource(appDataBaseInstance.recordItemDao());
  } return appDataBaseInstance;
}
 

private void initDatabase() {
    db = Room.databaseBuilder(getApplicationContext(),
            Database.class, "database-name-pow")
            .fallbackToDestructiveMigration()
            .build();
    dbExecutor = Executors.newSingleThreadExecutor();
}
 

@Override
public void onCreate() {
    super.onCreate();
    appDatabase = Room.databaseBuilder(getApplicationContext(), AppDatabase.class, "gsoc-database")
            .fallbackToDestructiveMigration()
            .build();
}
 

public static EarthquakeDatabase getInstance(Context context) {
  if (EarthquakeDatabaseInstance == null) {
    // Create or open a new SQLite database, and return it as
    // a Room Database instance.
    EarthquakeDatabaseInstance = Room.databaseBuilder(context,
      EarthquakeDatabase.class, EARTHQUAKE_DB_NAME).build();
  }

  return EarthquakeDatabaseInstance;
}
 

public static WaitDataBase getDatabase() {
    if (sInstance == null) {
        sInstance = Room.databaseBuilder(ReadhubApplication.getInstance(), WaitDataBase.class,
                "Readhub").build();
    }
    return sInstance;
}
 

@Override
public void onCreate() {
    super.onCreate();

    // create database
    database = Room.databaseBuilder(getApplicationContext(), MyDatabase.class, DATABASE_NAME)
            .addMigrations(MyDatabase.MIGRATION_1_2)
            .build();

    INSTANCE = this;
}
 

public static AppDatabase getInMemoryDatabase(Context context) {
    if (INSTANCE == null) {
        INSTANCE =
                Room.inMemoryDatabaseBuilder(context.getApplicationContext(), AppDatabase.class)
                // To simplify the codelab, allow queries on the main thread.
                // Don't do this on a real app! See PersistenceBasicSample for an example.
                .allowMainThreadQueries()
                .build();
    }
    return INSTANCE;
}
 

@Override
public void onCreate() {
    super.onCreate();
    Fabric.with(this, new Crashlytics());
    Security.insertProviderAt(new BouncyCastleProvider(), 1);

    bitsharesDatabase = Room.databaseBuilder(
            this,
            BitsharesDatabase.class,
            "bitshares.db"
    ).build();

    // 注册回调，保证数据更新
}
 

public static AppDatabase getInMemoryDatabase(Context context) {
    if (IN_MEMORY_INSTANCE == null) {
        IN_MEMORY_INSTANCE =
                Room.inMemoryDatabaseBuilder(context.getApplicationContext(), AppDatabase.class)
                        // To simplify the codelab, allow queries on the main thread.
                        // Don't do this on a real app! See PersistenceBasicSample for an example.
                        .allowMainThreadQueries()
                        .build();
    }
    return IN_MEMORY_INSTANCE;
}
 

@Before
public void setup() {
    // using an in-memory database because the information stored here disappears when the
    // process is killed
    mDatabase = Room.inMemoryDatabaseBuilder(InstrumentationRegistry.getContext(),
            AutofillDatabase.class).build();

}
 

public static NewsDatabase getInstance(Context context) {
    if (sInstance == null) {
        synchronized (LOCK) {
            sInstance = Room.databaseBuilder(
                    context.getApplicationContext(),
                    NewsDatabase.class,
                    DATABASE_NAME).build();
        }
    }
    return sInstance;
}
 

public static ToDoDatabase getInstance(Context context) {
    synchronized (sLock) {
        if (INSTANCE == null) {
            INSTANCE = Room.databaseBuilder(context.getApplicationContext(),
                    ToDoDatabase.class, "Tasks.db")
                    .build();
        }
        return INSTANCE;
    }
}
 

public static EarthquakeDatabase getInstance(Context context) {
  if (EarthquakeDatabaseInstance == null) {
    // Create or open a new SQLite database, and return it as
    // a Room Database instance.
    EarthquakeDatabaseInstance = Room.databaseBuilder(context,
      EarthquakeDatabase.class, EARTHQUAKE_DB_NAME).build();
  }

  return EarthquakeDatabaseInstance;
}
 

public static EarthquakeDatabase getInstance(Context context) {
  if (EarthquakeDatabaseInstance == null) {
    // Create or open a new SQLite database, and return it as
    // a Room Database instance.
    EarthquakeDatabaseInstance = Room.databaseBuilder(context,
      EarthquakeDatabase.class, EARTHQUAKE_DB_NAME).build();
  }

  return EarthquakeDatabaseInstance;
}
 

public static InfoDB getInstance(Context context) {
    synchronized (sLock) {
        String dbName = PreferenceUtils.getAccount();
        if (INSTANCE == null) {
            INSTANCE =
                Room.databaseBuilder(context.getApplicationContext(), InfoDB.class, dbName)
                    .allowMainThreadQueries()
                    .addMigrations(MIGRATION_32_33, MIGRATION_33_34, MIGRATION_34_35)
                    .build();
        }
        return INSTANCE;
    }
}
 

public static EarthquakeDatabase getInstance(Context context) {
  if (EarthquakeDatabaseInstance == null) {
    // Create or open a new SQLite database, and return it as
    // a Room Database instance.
    EarthquakeDatabaseInstance = Room.databaseBuilder(context,
      EarthquakeDatabase.class, EARTHQUAKE_DB_NAME).build();
  }

  return EarthquakeDatabaseInstance;
}
 

public static EarthquakeDatabase getInstance(Context context) {
  if (EarthquakeDatabaseInstance == null) {
    // Create or open a new SQLite database, and return it as
    // a Room Database instance.
    EarthquakeDatabaseInstance = Room.databaseBuilder(context,
      EarthquakeDatabase.class, EARTHQUAKE_DB_NAME).build();
  }

  return EarthquakeDatabaseInstance;
}
 

public static EarthquakeDatabase getInstance(Context context) {
  if (EarthquakeDatabaseInstance == null) {
    // Create or open a new SQLite database, and return it as
    // a Room Database instance.
    EarthquakeDatabaseInstance = Room.databaseBuilder(context,
      EarthquakeDatabase.class, EARTHQUAKE_DB_NAME).build();
  }

  return EarthquakeDatabaseInstance;
}
 

public static EarthquakeDatabase getInstance(Context context) {
  if (EarthquakeDatabaseInstance == null) {
    // Create or open a new SQLite database, and return it as
    // a Room Database instance.
    EarthquakeDatabaseInstance = Room.databaseBuilder(context,
      EarthquakeDatabase.class, EARTHQUAKE_DB_NAME).build();
  }

  return EarthquakeDatabaseInstance;
}
 

public static EarthquakeDatabase getInstance(Context context) {
  if (EarthquakeDatabaseInstance == null) {
    // Create or open a new SQLite database, and return it as
    // a Room Database instance.
    EarthquakeDatabaseInstance = Room.databaseBuilder(context,
      EarthquakeDatabase.class, EARTHQUAKE_DB_NAME).build();
  }

  return EarthquakeDatabaseInstance;
}