androidx.lifecycle.LiveData Java Examples

@Test
public void on_default_values() {
  MutableLiveData<Integer> liveDataA = new DefaultValueLiveData<>(10);
  MutableLiveData<Integer> liveDataB = new DefaultValueLiveData<>(30);

  LiveData<Integer> combined = LiveDataUtil.combineLatest(liveDataA, liveDataB, (a, b) -> a * b);

  assertEquals(Integer.valueOf(300), getValue(combined));
}
 

public DisplayManager(@NonNull Activity activity, @Nullable LiveData<RendererItem> selectedRender, boolean textureView, boolean cloneMode, boolean benchmark) {
    mActivity = activity;
    mSelectedRenderer = selectedRender;
    mMediaRouter = (MediaRouter) activity.getApplicationContext().getSystemService(Context.MEDIA_ROUTER_SERVICE);
    mTextureView = textureView;
    mPresentation = !cloneMode && !benchmark && selectedRender != null && selectedRender.getValue() == null ? createPresentation() : null;
    if (mSelectedRenderer != null) {
        mRendererItem = mSelectedRenderer.getValue();
        mSelectedRenderer.observeForever(mRendererObs);
    }
    mDisplayType = benchmark ? DisplayType.PRIMARY : getCurrentType();
}
 

@NonNull
LiveData searchTrackedEntities(@Nullable Program selectedProgram,
                                                          @NonNull String trackedEntityType,
                                                          @NonNull List<String> orgUnits,
                                                          @Nonnull List<State> states,
                                                          @NonNull List<EventStatus> statuses,
                                                          @Nullable HashMap<String, String> queryData,
                                                          boolean assignedToMe,
                                                          boolean isOnline);
 

/**
 * View Model talks to repository through this method to fetch the live data.
 *
 * @param category category
 * @return The list of categories which is wrapped in a live data.
 */
public LiveData<List<VideoEntity>> getVideosInSameCategoryLiveData(String category) {

    // always try to retrive from local cache firstly
    if (mVideoEntitiesCache.containsKey(category)) {
        return mVideoEntitiesCache.get(category);
    }
    LiveData<List<VideoEntity>> videoEntities = mVideoDao.loadVideoInSameCateogry(category);
    mVideoEntitiesCache.put(category, videoEntities);
    return videoEntities;
}
 

public LiveData<PFResult<Boolean>> delete() {
    final PFLiveData<PFResult<Boolean>> liveData = new PFLiveData<>();
    PFSecurityManager.getInstance().getPinCodeHelper().delete(
            new PFPinCodeHelperCallback<Boolean>() {
                @Override
                public void onResult(PFResult<Boolean> result) {
                    liveData.setData(result);
                }
            }
    );
    return liveData;
}
 

@MainThread
protected NetworkBoundResource() {
    result.setValue(RemoteResource.loading(null));
    LiveData<ResultType> dbSource = loadFromDb();
    result.addSource(dbSource, data -> {
        result.removeSource(dbSource);
        if (shouldFetch(data)) {
            fetchFromNetwork(dbSource);
        } else {
            result.addSource(dbSource,
                    newData -> result.setValue(RemoteResource.success(newData)));
        }
    });
}
 

@Test
public void on_update_a() {
  MutableLiveData<String> liveDataA = new MutableLiveData<>();
  MutableLiveData<String> liveDataB = new MutableLiveData<>();

  LiveData<String> combined = LiveDataUtil.combineLatest(liveDataA, liveDataB, (a, b) -> a + b);

  liveDataA.setValue("Hello, ");
  liveDataB.setValue("World!");

  assertEquals("Hello, World!", getValue(combined));

  liveDataA.setValue("Welcome, ");
  assertEquals("Welcome, World!", getValue(combined));
}
 

LiveData<PagedList<HttpTransactionUIHelper>> getTransactions(String key) {
    if (key == null || key.trim().length() == 0) {
        return mTransactions;
    } else {
        DataSource.Factory<Integer, HttpTransactionUIHelper> factory = mTransactionDao.getAllTransactionsWith(key, TransactionDao.SearchType.DEFAULT).map(HttpTransactionUIHelper.HTTP_TRANSACTION_UI_HELPER_FUNCTION);
        return new LivePagedListBuilder<>(factory, config).build();
    }
}
 

private String getObserverInfo(LiveData liveData) {
    try {
        Field field = LiveData.class.getDeclaredField("mObservers");
        field.setAccessible(true);
        Object mObservers = field.get(liveData);
        return mObservers.toString();
    } catch (Exception e) {
        return "";
    }
}
 

public LiveData<BondingState> getBondState() {
    return mBondStateLiveData;
}
 

public LiveData<PagedList<Movie>> getPagedList() {
    return pagedList;
}
 

LiveData<Integer> getTimeDifference() {
    if (!timeAligned) {
        alignTime();
    }
    return timeDifference;
}
 

public LiveData<List<MailboxWithRoleAndName>> getMailboxes(String threadId) {
    return Transformations.switchMap(databaseLiveData, database ->database.mailboxDao().getMailboxesForThreadLiveData(threadId));
}
 

public LiveData<MailboxOverviewItem> getMailbox() {
    return mailbox;
}
 

@Override
public LiveData<List<Movie>> getAllFavoriteMovies() {
    return mLocalDataSource.getAllFavoriteMovies();
}
 

public LiveData<Boolean> observeFilters() {
    return filtersShowing;
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
            WindowManager.LayoutParams.FLAG_FULLSCREEN);
    setContentView(R.layout.activity_main);
    AudienceNetworkAds.initialize(this);
    dataObjectRepositry = DataObjectRepositry.dataObjectRepositry;
    ButterKnife.bind(this);
    getSafeIntent();
    initUI();
    onClick();
    addToFirebase();


    interstitialAd = new InterstitialAd(this);
    interstitialAd.setAdUnitId(getString(R.string.interstitial_full_screen));
    AdRequest adRequest = new AdRequest.Builder().build();
    interstitialAd.loadAd(adRequest);

    allLoginUserList.clear();
    LiveData<List<Logins>> loggedInUsers = DataObjectRepositry.dataObjectRepositry.getAllUsers();
    loggedInUsers.observe(MainActivity.this, new Observer<List<Logins>>() {
        @Override
        public void onChanged(List<Logins> logins) {
            if (logins.size() > 0) {
                allLoginUserList.clear();
                for (Logins logins1 : logins) {

                    DrawerMenuPojo drawerMenuPojo1 = new DrawerMenuPojo();
                    drawerMenuPojo1.setMenuName(logins1.getUserName());
                    drawerMenuPojo1.setImage(R.drawable.ic_account);
                    allLoginUserList.add(drawerMenuPojo1);

                }
            }
        }
    });


    if (!TextUtils.isEmpty(user_id)) {

        showLoading();
        new GetUserInfo(user_id).execute();
    } else {

        changeFragment(new StoriesFragment());
        toolbar.setTitle("Stories");
    }
    toolbar.setTitle("Stories");
}
 

public LiveData<PagedList<Message>> getMessages() {
    return messages;
}
 

void onActive(LiveData liveData) {
    mLiveDataSet.add(liveData);
}
 

LiveData<State> getState() {
  return state;
}
 

public LiveData<RecipientInfo> getRecipientInfo() {
  return recipientInfo;
}
 

public LiveData<RecognizerResults> scanItems() {
    return scanItems;
}
 

LiveData<List<Note>> getAllNotes(){
    return mAllNotes;
}
 

LiveData<String> getStatus() {
    return statusText;
}
 

@NonNull
public LiveData<String> getResponse() {
    return mResponseLiveData;
}
 

public LiveData<String> getDataLeft() {
    return left;
}
 

public LiveData<Long> getElapsedTime() {
    return mElapsedTime;
}
 

@NonNull
public LiveData<Boolean> getBusyState() {
    return mBusyStateLiveData;
}
 

LiveData<List<Word>> getAllWords() {
    return mAllWords;
}
 

@Query("SELECT identity.*, account.name AS accountName FROM identity" +
        " JOIN account ON account.id = identity.account")
LiveData<List<TupleIdentityEx>> liveIdentities();