Java Realm.createObject方法代码示例

import io.realm.Realm; //导入方法依赖的package包/类
@Override
protected void run() {
    user = UserFactory.getInstance().loginWithDefaultUser(Constants.AUTH_URL);
    String realmUrl = Constants.SYNC_SERVER_URL;

    final SyncConfiguration syncConfig = new SyncConfiguration.Builder(user, realmUrl)
            .directory(getService().getRoot())
            .build();
    getService().setRealm(Realm.getInstance(syncConfig));
    Realm realm = getService().getRealm();

    realm.beginTransaction();
    ProcessInfo processInfo = realm.createObject(ProcessInfo.class);
    processInfo.setName("Background_Process1");
    processInfo.setPid(android.os.Process.myPid());
    processInfo.setThreadId(Thread.currentThread().getId());
    realm.commitTransaction();
    // FIXME: If we close the Realm here, the data won't be able to synced to the main process. Is it a bug
    // in sync client which stops too early?
    // Realm is currently configured with stop_immediately. This means the sync session is closed as soon as
    // the last realm instance is closed. Not doing this would make the Realm lifecycle really
    // unpredictable. We should have an easy way to wait for all changes to be uploaded though.
    // Perhaps SyncSession.uploadAllLocalChanges() or something similar to
    // SyncSesson.downloadAllServerChanges()
}
 

import io.realm.Realm; //导入方法依赖的package包/类
private MovieItem addMovieItemInUserList(Realm realm, GenericMovieDataWrapper wrapper) {

        MovieItem movieItem = findInRealmMovieItem(realm, wrapper.getMovieId());

        if (movieItem == null) {
            movieItem = realm.createObject(MovieItem.class, wrapper.getMovieId());
            movieItem.setTitle(wrapper.getTitle());
            movieItem.setPosterPath(wrapper.getPosterPath());
            movieItem.setOverview(wrapper.getOverview());
            movieItem.setVoteCount(wrapper.getVoteCount());
            movieItem.setVoteAverage(wrapper.getVoteAverage());
            movieItem.setReleaseDate(wrapper.getReleaseDate());
            movieItem.setBackdropPath(wrapper.getBackdropPath());
        }

        return movieItem;
    }
 

import io.realm.Realm; //导入方法依赖的package包/类
private void addMovieItemInRealm(Realm realm, GenericMovieDataWrapper wrapper) {

        MovieItem movieItemRealm = findInRealmMovieItem(realm, wrapper.getMovieId());

        if (movieItemRealm == null) {

            movieItemRealm = realm.createObject(MovieItem.class, wrapper.getMovieId());

            movieItemRealm.setTitle(wrapper.getTitle());
            movieItemRealm.setPosterPath(wrapper.getPosterPath());
            movieItemRealm.setOverview(wrapper.getOverview());
            movieItemRealm.setVoteCount(wrapper.getVoteCount());
            movieItemRealm.setVoteAverage(wrapper.getVoteAverage());
            movieItemRealm.setReleaseDate(wrapper.getReleaseDate());
            movieItemRealm.setBackdropPath(wrapper.getBackdropPath());
        } else {
            Timber.i(wrapper.getTitle() + "Already present in MovieItem");
        }
    }
 

import io.realm.Realm; //导入方法依赖的package包/类
private void logoutRealmUser() {
    //注册成功写数据库
    RealmConfiguration config = new RealmConfiguration.Builder().name("yyox.realm").build();
    Realm objRealm = Realm.getInstance(config);

    //查找
    RealmUser realmUser = objRealm.where(RealmUser.class).findFirst();
    if (realmUser != null) {
        //先删除
        objRealm.beginTransaction();
        RealmResults results = objRealm.where(RealmUser.class).findAll();
        results.deleteAllFromRealm();
        objRealm.commitTransaction();
        //再添加
        objRealm.beginTransaction();
        RealmUser realmUserNew = objRealm.createObject(RealmUser.class);
        realmUserNew.setName("");
        objRealm.commitTransaction();

        mRealmUser = null;
    }
}
 

import io.realm.Realm; //导入方法依赖的package包/类
@Override
public void updateDAB(Object object) {
    JSONObject jsonObject = (JSONObject) object;

    String username = "", password = "";
    try {
        username = jsonObject.getString("username");
        password = jsonObject.getString("password");
    } catch (Exception e) {
        e.printStackTrace();
    }

    Realm realm = Realm.getDefaultInstance();
    realm.beginTransaction();
    realm.delete(User.class);

    User user = realm.createObject(User.class);
    user.setUsername(username);
    user.setPassword(password);
    realm.commitTransaction();

    mainController.updateResponse(user);
}
 

import io.realm.Realm; //导入方法依赖的package包/类
public void writeBookToDataBase(String bookId, Book.BookData book) {
    Realm realm = Realm.getDefaultInstance();
    realm.beginTransaction();
    BookDB data = realm.createObject(BookDB.class, bookId);
    data.setIdServerBook(book.getIdServerBook());
    data.setBookName(book.getBookName());
    data.setIdAuthor(book.getIdAuthor());
    data.setIdCategory(book.getIdCategory());
    data.setDescription(book.getDescription());
    data.setLanguage(book.getLanguage());
    data.setPhoto(book.getPhoto());
    data.setWhoAdded(book.getWhoAdded());
    data.setUploadDate(book.getUploadDate());
    data.setOfflineBook(false);
    realm.commitTransaction();
}
 

import io.realm.Realm; //导入方法依赖的package包/类
private void writeSampleData(Realm realm) {
    realm.beginTransaction();
    for (int i = 0; i < TEST_SIZE; i++) {
        AllTypes obj = realm.createObject(AllTypes.class);
        obj.setColumnString("Object " + i);
    }
    realm.commitTransaction();
}
 

import io.realm.Realm; //导入方法依赖的package包/类
public static void resetInstance() {
    instance = null;
    Realm realm = Realm.getInstance(configuration);
    UserFactoryStore store = realm.where(UserFactoryStore.class).findFirst();
    realm.beginTransaction();
    if (store == null) {
        store = realm.createObject(UserFactoryStore.class);
    }
    store.setUserName(UUID.randomUUID().toString());
    realm.commitTransaction();
    realm.close();
}
 

import io.realm.Realm; //导入方法依赖的package包/类
/**
 * Stores a {@link SyncableObject} created from some user input, to be stored for
 * synchronization on the next connection to a LDLN Base Station or other LDLN-sync
 * enabled device.
 * 
 * @param callback          The callback that implements {@link SaveSyncableObjectListener} and will handle the result
 * @param schemaKey    		The key for the {@link Schema} of the {@link SyncableObject} to be saved.
 * @param keyValuePairs		The key value pairs of the {@link SyncableObject} to be saved.
 * @return                  void, results are returned via the {@link SaveSyncableObjectListener}
 */
public static void saveSyncableObject(Context context, SaveSyncableObjectListener callback, String schemaKey, String keyValuePairs)
{
	try {
		// Generate one uuid for use in both the plaintext and encrypted objects
		String uuid = UUID.randomUUID().toString();

		// Save the encrypted version of the object
		Realm realm = Realm.getInstance(getRealmConfig(context, RealmLevel.GLOBAL));
		realm.beginTransaction();
		SyncableObject syncableObject = realm.createObject(SyncableObject.class, uuid);
		syncableObject.setSchema(realm.where(Schema.class).equalTo("key", schemaKey).findFirst());
		syncableObject.setKeyValuePairs(keyValuePairs, DEK, encryptionIsEnabled);
		realm.commitTransaction();

		// Save the plaintext "cached" version of the object
		PlaintextObject plaintextObject = new PlaintextObject(syncableObject, DEK, encryptionIsEnabled);
		realm = Realm.getInstance(getRealmConfig(context, RealmLevel.USER));
		realm.beginTransaction();
		realm.insert(plaintextObject);
		realm.commitTransaction();

		// Sync with server
		LDLN.initializeWebSocketSync(context);

		// Call back to the implementor of the interface
		callback.onSaveSyncableObjectResult(true);
		return;
	} catch (UnsupportedEncodingException e) {
		e.printStackTrace();
	}

	callback.onSaveSyncableObjectResult(false);
}
 

import io.realm.Realm; //导入方法依赖的package包/类
public void saveBookOffline(String bookId, String bookName) {
    Realm realm = Realm.getDefaultInstance();
    realm.beginTransaction();
    BookDB data = realm.createObject(BookDB.class, bookId);
    data.setBookName(bookName);
    data.setOfflineBook(true);
    realm.commitTransaction();
}
 

import io.realm.Realm; //导入方法依赖的package包/类
private void sendReport(@Nullable Station correctStation) {
    // build report
    Map<String, Object> map = new HashMap<>();
    if (incorrectStation == null) {
        map.put("incorrectStation", "none");
    } else {
        map.put("incorrectStation", incorrectStation.getId());
    }
    if (correctStation == null) {
        map.put("correctStation", "none");
    } else {
        map.put("correctStation", correctStation.getId());
    }
    map.put("wiFiScanResults", scanResults);

    ObjectMapper mapper = new ObjectMapper();
    try {
        String jsonResult = mapper.writerWithDefaultPrettyPrinter()
                .writeValueAsString(map);
        Realm realm = Realm.getDefaultInstance();
        realm.beginTransaction();
        Feedback feedback = realm.createObject(Feedback.class, UUID.randomUUID().toString());
        feedback.setSynced(false);
        feedback.setTimestamp(new Date());
        feedback.setType("s2ls-incorrect-detection");
        feedback.setContents(jsonResult);
        realm.copyToRealm(feedback);
        realm.commitTransaction();
        realm.close();

        Intent intent = new Intent(ACTION_FEEDBACK_PROVIDED);
        intent.putExtra(EXTRA_FEEDBACK_PROVIDED_DELAYED, !Connectivity.isConnected(context));
        LocalBroadcastManager bm = LocalBroadcastManager.getInstance(context);
        bm.sendBroadcast(intent);
    } catch (JsonProcessingException e) {
        e.printStackTrace();
    }
}
 

import io.realm.Realm; //导入方法依赖的package包/类
@Override
public void execute(Realm realm) {
    Log.d("realm", "now insert [" + date + " ," + num + "]");

    StepModel stepModel =realm.where(StepModel.class).equalTo("date",date).findFirst();

    if (stepModel == null)
        stepModel = realm.createObject(StepModel.class);
    stepModel.setDate(date);
    stepModel.setNumSteps(num);
}
 

import io.realm.Realm; //导入方法依赖的package包/类
@Override public Named create(Realm realm) {
    return realm.createObject(Category.class, UUID.randomUUID().toString());
}
 

import io.realm.Realm; //导入方法依赖的package包/类
@Override public Named create(Realm realm) {
    GameObject object = realm.createObject(GameObject.class, UUID.randomUUID().toString());
    object.setCategory(category);
    return object;
}