public static Completable completableExec(final RealmConfiguration configuration,
    final Consumer<Realm> transaction) {
  return Completable.fromAction(new Action() {
    @Override
    public void run() throws Exception {
      try (Realm realm = Realm.getInstance(configuration)) {
        realm.executeTransaction(new Transaction() {
          @Override
          public void execute(Realm r) {
            try {
              transaction.accept(r);
            } catch (Exception e) {
              e.printStackTrace();
            }
          }
        });
      }
    }
  });
}
 

@Override
public void onCreate() {
    super.onCreate();
    sInstance = this;

    //initialize Realm
    RealmConfiguration realmConfiguration = new RealmConfiguration.Builder(instance())
            .name("happ.realm")
            .schemaVersion(0)
            .deleteRealmIfMigrationNeeded() // TODO: 03/08/2016 remove
            .build();
    Realm.setDefaultConfiguration(realmConfiguration);


    Migration.runMigrationCheck();
}
 

public static void createDb(String userName) {


        if (dbName != null && dbName.equals(userName)) {
            return;
        }
        dbName = userName;
        config = new RealmConfiguration.Builder()
                .name( dbName + ".realm") //文件名
                .deleteRealmIfMigrationNeeded()
                .schemaVersion(0) //版本号
                .build();
        if (mRealm != null) {
            mRealm.close();
        }

        mainHandler.post(new Runnable() {
            @Override
            public void run() {

                mRealm = Realm.getInstance(config);
            }
        });
    }
 

@Override
public SaklarHolder onCreateViewHolder(ViewGroup parent, int viewType) {

    context = parent.getContext();

    View itemView = LayoutInflater.from(context)
            .inflate(R.layout.item_recycler_saklar, parent, false);

    // Init Realm
    RealmConfiguration config = new RealmConfiguration.Builder(context)
            .name("agnosthings.realm")
            .schemaVersion(1)
            .build();

    realm = Realm.getInstance(config);

    return new SaklarHolder(itemView);
}
 

@Override
public RemoteViews getViewAt(int i) {
    RemoteViews remoteViews = new RemoteViews(
            context.getPackageName(), R.layout.item_list_app_widget);
    Realm realm=Realm.getInstance(new RealmConfiguration.Builder()
            .deleteRealmIfMigrationNeeded()
            .name(RealmHelper.DATABASE_NAME)
            .build());
    List<ReadLaterArticleData> list = realm.copyFromRealm(
            realm.where(ReadLaterArticleData.class)
                    .equalTo("userId", userId)
                    .sort("timestamp", Sort.DESCENDING)
                    .findAll());
    ReadLaterArticleData data = list.get(i);
    remoteViews.setTextViewText(R.id.text_view_author,data.getAuthor());
    remoteViews.setTextViewText(R.id.text_view_title, StringUtil.replaceInvalidChar(data.getTitle()));
    Intent intent = new Intent();
    intent.putExtra(DetailActivity.ID, data.getId());
    intent.putExtra(DetailActivity.TITLE, data.getTitle());
    intent.putExtra(DetailActivity.URL, data.getLink());
    intent.putExtra(DetailActivity.FROM_FAVORITE_FRAGMENT, false);
    intent.putExtra(DetailActivity.FROM_BANNER, false);
    remoteViews.setOnClickFillInIntent(R.id.item_main, intent);
    return remoteViews;
}
 

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

    ActiveAndroid.initialize(new Configuration.Builder(this)
                                     .setDatabaseName("activeandroid")
                                     .setDatabaseVersion(1)
                                     .setModelClasses(SimpleAddressItem.class, AddressItem.class,
                                                      AddressBook.class, Contact.class).create());

    Ollie.with(this)
            .setName("ollie")
            .setVersion(1)
            .setLogLevel(Ollie.LogLevel.FULL)
            .init();

    FlowManager.init(this);

    Sprinkles.init(this, "sprinkles.db", 2);

    RealmConfiguration realmConfig = new RealmConfiguration.Builder(this).build();
    Realm.setDefaultConfiguration(realmConfig);

    mDatabase = getDatabase();
}
 

@Before
public void setUp() throws KeyStoreException {
    Realm.init(InstrumentationRegistry.getTargetContext());

    // This will set the 'm_metadata_manager' in 'sync_manager.cpp' to be 'null'
    // causing the SyncUser to remain in memory.
    // They're actually not persisted into disk.
    // move this call to `tearDown` to clean in-memory & on-disk users
    // once https://github.com/realm/realm-object-store/issues/207 is resolved
    TestHelper.resetSyncMetadata();

    RealmConfiguration realmConfig = configFactory.createConfiguration();
    realm = Realm.getInstance(realmConfig);

    userStore = new SecureUserStore(InstrumentationRegistry.getTargetContext());
    assertTrue("KeyStore Should be Unlocked before running tests on device!", userStore.isKeystoreUnlocked());
    SyncManager.setUserStore(userStore);
}
 

private static boolean tryRealmStorage(File path) {
    // check where we can actually store the databases on this device
    RealmConfiguration realmTestConfiguration;

    // catch all errors when creating directory and db
    try {
        realmTestConfiguration = new RealmConfiguration.Builder()
                .directory(path)
                .name("test_storage.realm")
                .deleteRealmIfMigrationNeeded()
                .build();
        Realm testInstance = Realm.getInstance(realmTestConfiguration);
        testInstance.close();
        Realm.deleteRealm(realmTestConfiguration);
    } catch (Throwable e) {
        Log.i(LOG_ID, "Test creation of realm failed for: '" + path.toString() + "': " + e.toString());
        return false;
    }

    return true;
}
 

@Override
public void onCreate() {
    super.onCreate();
    sContext = this;

    Hawk.init(this)
            .setEncryptionMethod(HawkBuilder.EncryptionMethod.MEDIUM)
            .setStorage(HawkBuilder.newSharedPrefStorage(this))
            .setLogLevel(BuildConfig.DEBUG ? LogLevel.FULL : LogLevel.NONE)
            .build();

    RealmConfiguration configuration = new RealmConfiguration.Builder(this)
            .rxFactory(new RealmObservableFactory())
            .build();
    Realm.setDefaultConfiguration(configuration);

    ApiFactory.recreate();
    RepositoryProvider.init();
}
 

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

    Timber.plant(new Timber.DebugTree());

    RealmConfiguration configuration = new RealmConfiguration.Builder(this)
            .deleteRealmIfMigrationNeeded()
            .build();

    Realm.setDefaultConfiguration(configuration);

    FacebookSdk.sdkInitialize(getApplicationContext());
    Timber.i("Signature " +  FacebookSdk.getApplicationSignature(getApplicationContext()));
}
 

@Override
protected void after() {
    try {
        for (RealmConfiguration configuration : configurations) {
            Realm.deleteRealm(configuration);
        }
    } catch (IllegalStateException e) {
        // Only throw the exception caused by deleting the opened Realm if the test case itself doesn't throw.
        if (!unitTestFailed) {
            throw e;
        }
    } finally {
        // This will delete the temp directory.
        super.after();
    }
}
 

/**
 * @return RealmConfiguration
 */
public RealmConfiguration getConfig() {
    initRealmKey();
    Realm.init(mContext);

    if (DEBUG_DATABASE) {
        writeKeyToFile();
    }

    boolean existsUnencryptedRealm = new File(mContext.getFilesDir(), DATABASE_NAME).exists();
    if (existsUnencryptedRealm) {
        RealmConfiguration unencryptedConfig = getUnencryptedConfig();
        try {
            migrateToEncryptedConfig(unencryptedConfig);
            log.debug("migration to encrypted realm successful");
        } catch (IOException e) {
            log.error("error migrating encrypted realm", e);
            return unencryptedConfig;
        }
    }

    return getEncryptedConfig();
}
 

@Override
public void onCreate() {

  super.onCreate();
  mAppContext = this;
  // 配置Realm数据库
  RealmConfiguration configuration = new RealmConfiguration
      .Builder(this)
      .deleteRealmIfMigrationNeeded()
      .schemaVersion(6)
      .migration(new RealmMigration() {

        @Override
        public void migrate(DynamicRealm realm, long oldVersion, long newVersion) {

        }
      }).build();

  Realm.setDefaultConfiguration(configuration);

  //配置腾讯bugly
  CrashReport.initCrashReport(getApplicationContext(), ConstantUtil.BUGLY_ID, false);
}
 

@Override
public void onCreate() {
    super.onCreate();
    sInstance = this;

    Picasso picasso = new Picasso.Builder(this)
            .downloader(new OkHttp3Downloader(this))
            .build();
    Picasso.setSingletonInstance(picasso);

    RealmConfiguration configuration = new RealmConfiguration.Builder(this)
            .rxFactory(new RealmObservableFactory())
            .build();
    Realm.setDefaultConfiguration(configuration);
}
 

@Override
public void onCreate() {
    super.onCreate();
    RealmConfiguration realmConfiguration = new RealmConfiguration.Builder(this)
            .deleteRealmIfMigrationNeeded()
            .build();
    Realm.setDefaultConfiguration(realmConfiguration);
    Github.init();
}
 

@Override
public void registerComponents(Context context, IRepositoryManager repositoryManager) {
  repositoryManager.injectRealmConfigs(
      new RealmConfiguration.Builder()
          .name(SystemConstant.DB_NAME)
          .schemaVersion(SystemConstant.DB_VERSION)
          .modules(Realm.getDefaultModule(), new AcgScheduleRealmModule())
          .build()
  );
}
 

public static <T> Flowable<T> flowableExec(final RealmConfiguration configuration,
    final Consumer<Pair<FlowableEmitter, Realm>> emitter) {
  return Flowable.create(new FlowableOnSubscribe<T>() {
    @Override
    public void subscribe(FlowableEmitter<T> e) throws Exception {
      try (Realm realm = Realm.getInstance(configuration)) {
        emitter.accept(new Pair<FlowableEmitter, Realm>(e, realm));
      }
    }
  }, BackpressureStrategy.BUFFER);
}
 

private void initializeRealm(){
    Realm.init(this);
    RealmConfiguration config =
            new RealmConfiguration.Builder()
                    .deleteRealmIfMigrationNeeded()
                    .build();
    Realm.setDefaultConfiguration(config);
}
 

@Before
public void setUp() {
  RealmConfiguration realmConfiguration = new RealmConfiguration
      .Builder(InstrumentationRegistry.getTargetContext())
      .name("es.npatarino.android.gotchallenge.realm.test")
      .schemaVersion(1)
      .deleteRealmIfMigrationNeeded()
      .build();
  Realm.setDefaultConfiguration(realmConfiguration);

  dataSource =
      new CharacterLocalDataSource(ttlCachingStrategy, timeProvider, mapper);
}
 

public static void initializeRealmConfig() {
    if(realmConfiguration == null) {
        Log.d(RealmManager.class.getName(), "Initializing Realm configuration.");
        setRealmConfiguration(new RealmConfiguration.Builder()
                .initialData(new RealmInitialData())
                .deleteRealmIfMigrationNeeded()
                .build());
    }
}
 

private RealmHelper() {
    try {
        mRealm = Realm.getDefaultInstance();
    } catch (Exception e) {
        RealmConfiguration config = new RealmConfiguration.Builder()
                .deleteRealmIfMigrationNeeded()
                .build();
        mRealm = Realm.getInstance(config);
    }


}
 

private void initRealm() {
    RealmConfiguration realmConfiguration = new RealmConfiguration.Builder(getApplicationContext())
            .name(getString(R.string.db_name))
            .schemaVersion(getResources().getInteger(R.integer.db_version))
            .build();
    Realm.setDefaultConfiguration(realmConfiguration);

    Realm realm = Realm.getDefaultInstance();
    GroupRepository
            .createDefaultGroups(realm);
    realm.close();
}
 

/**
 * Allows to manually use Realm instance and will automatically close it when done.
 *
 * @param realmBlock the Realm execution block in which Realm should remain open
 */
public final void doWithRealm(final RealmBlock realmBlock) {
    RealmConfiguration configuration = getRealmConfiguration();
    Realm realm = null;
    try {
        realm = Realm.getInstance(configuration);
        realmBlock.doWithRealm(realm);
    } finally {
        if(realm != null) {
            realm.close();
        }
    }
}
 

@Provides
@Singleton
RealmConfiguration realmConfiguration() {
    return new RealmConfiguration.Builder() //
            .deleteRealmIfMigrationNeeded() //
            .initialData(realm -> { //
                RealmDog dog = realm.createObject(RealmDog.class);
                dog.setName("Corgi");
            }).build();
}
 

protected void createRealm() {
    Realm.init(getTargetContext());
    RealmConfiguration.Builder configBuilder = new RealmConfiguration.Builder();
    if (inMemory) {
        configBuilder.name("inmemory.realm").inMemory();
    } else {
        configBuilder.name("ondisk.realm");
    }
    realm = Realm.getInstance(configBuilder.build());
}
 

@Before
public void setUp() throws Exception {
    RealmConfiguration configuration = new RealmConfiguration
        .Builder(InstrumentationRegistry.getContext())
        .setModules(new TestModule())
        .schemaVersion(0)
        .build();
    RealmDatabase.init(configuration);
    RealmDatabase.deleteDatabase();
}
 

public RealmConfiguration getRealmConfiguration() {
    if (realmConfiguration != null) {
        return realmConfiguration;
    }
    // Create config
    realmConfiguration = new RealmConfiguration.Builder()
            .name(DATABASE_NAME)
            .schemaVersion(DATABASE_VERSION)
            .migration(new GoBeesDbMigration())
            .build();
    return realmConfiguration;
}
 

@Override
public void onCreate() {
    super.onCreate();
    sInstance = this;

    Picasso picasso = new Picasso.Builder(this)
            .downloader(new OkHttp3Downloader(this))
            .build();
    Picasso.setSingletonInstance(picasso);

    RealmConfiguration configuration = new RealmConfiguration.Builder(this)
            .rxFactory(new RealmObservableFactory())
            .build();
    Realm.setDefaultConfiguration(configuration);
}
 

@Inject
    public DatabaseManager(App app) {
        this.app = app;
        this.context = app.getApplicationContext();
        this.configuration = new RealmConfiguration.Builder(context)
//                .name(DB_NAME)
                .deleteRealmIfMigrationNeeded()
                .setModules(this)
                .build();
        Realm.setDefaultConfiguration(configuration);
        initCurrentAccessToken();
    }
 

/**
 * Init realm configuration and instance
 * @return
 * @throws Exception
 */
@Provides
@Singleton
RealmConfiguration provideRealmConfiguration(){
    mockStatic(RealmCore.class);
    mockStatic(RealmLog.class);
    mockStatic(Realm.class);
    mockStatic(RealmConfiguration.class);
    Realm.init(RuntimeEnvironment.application);

    // TODO: Better solution would be just mock the RealmConfiguration.Builder class. But it seems there is some
    // problems for powermock to mock it (static inner class). We just mock the RealmCore.loadLibrary(Context) which
    // will be called by RealmConfiguration.Builder's constructor.
    doNothing().when(RealmCore.class);
    RealmCore.loadLibrary(any(Context.class));

    final RealmConfiguration mockRealmConfig = PowerMockito.mock(RealmConfiguration.class);

    try {
        whenNew(RealmConfiguration.class).withAnyArguments().thenReturn(mockRealmConfig);
    } catch (Exception e) {
        e.printStackTrace();
    }

    when(Realm.getDefaultConfiguration()).thenReturn(mockRealmConfig);

    // init mock realm
    Realm mockRealm = PowerMockito.mock(Realm.class);;
    // Anytime getInstance is called with any configuration, then return the mockRealm
    when(Realm.getDefaultInstance()).thenReturn(mockRealm);

    when(Realm.getInstance(mockRealmConfig)).thenReturn(mockRealm);

    return mockRealmConfig;
}