android.arch.lifecycle.Transformations Java Examples

@MainThread
static LiveData<LogcatContent> grepData(LiveData<LogcatContent> rawData, String grep) {
    return Transformations.map(rawData, logcatData -> {
        String content = logcatData.getContent();
        if (GREP_SIGNAL.equals(content)) {
            return logcatData;
        }


        if (content != null) {
            logcatData.setContent(parseHtml2(content,grep));
        }

        return logcatData;

    });
}
 

public WalletViewModel() {
    retryData.setValue(0);

    resultData.addSource(statusChangeLiveData, statusChange -> {
        LiveData<Resource<List<BitsharesBalanceAsset>>> balanceData = Transformations.switchMap(
                Transformations.switchMap(currencyData, input -> {
                    retryData.setValue(retryData.getValue());
                    return retryData;
                }),
                retryCount -> {
                    return new BalanceRepository().getBalances(currencyData.getValue());
                });

        resultData.addSource(balanceData, result -> resultData.setValue(result));
    });

}
 

public SoldiersViewModel(ActionControls actionControls, DrawControls drawControls, IInGamePlayer player) {
	this.actionControls = actionControls;
	this.player = player;

	DrawEvents drawEvents = new DrawEvents(drawControls);

	strengthText = Transformations.map(drawEvents, x -> strengthText());
	promotionText = Transformations.map(drawEvents, x -> promotionText());
	swordsmenPromotionEnabled = Transformations.map(drawEvents, x -> isPromotionPossible(ESoldierType.SWORDSMAN));
	bowmenPromotionEnabled = Transformations.map(drawEvents, x -> isPromotionPossible(ESoldierType.BOWMAN));
	pikemenPromotionEnabled = Transformations.map(drawEvents, x -> isPromotionPossible(ESoldierType.PIKEMAN));
	swordsmenImageLink = Transformations.map(swordsmenPromotionEnabled,
			isPromotionPossible -> getPromotionImageLink(isPromotionPossible, swordsmenPromotionPossibleImages, swordsmenPromotionNotPossibleImages, ESoldierType.SWORDSMAN));
	bowmenImageLink = Transformations.map(bowmenPromotionEnabled,
			isPromotionPossible -> getPromotionImageLink(isPromotionPossible, bowmenPromotionPossibleImages, bowmenPromotionNotPossibleImages, ESoldierType.BOWMAN));
	pikemenImageLink = Transformations.map(pikemenPromotionEnabled,
			isPromotionPossible -> getPromotionImageLink(isPromotionPossible, pikemenPromotionPossibleImages, pikemenPromotionNotPossibleImages, ESoldierType.PIKEMAN));
}
 

private void subscribeToDbChanges() {
    LiveData<List<LoanWithUserAndBook>> loans
            = mDb.loanModel().findLoansByNameAfter("Mike", getYesterdayDate());

    // Instead of exposing the list of Loans, we can apply a transformation and expose Strings.
    mLoansResult = Transformations.map(loans,
            new Function<List<LoanWithUserAndBook>, String>() {
        @Override
        public String apply(List<LoanWithUserAndBook> loansWithUserAndBook) {
            StringBuilder sb = new StringBuilder();
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm",
                    Locale.US);

            for (LoanWithUserAndBook loan : loansWithUserAndBook) {
                sb.append(String.format("%s\n  (Returned: %s)\n",
                        loan.bookTitle,
                        simpleDateFormat.format(loan.endTime)));
            }
            return sb.toString();
        }
    });
}
 

private void subscribeToDbChanges() {
    // TODO: Modify this query to show only recent loans from specific user
    LiveData<List<LoanWithUserAndBook>> loans
            = mDb.loanModel().findAllWithUserAndBook();

    // Instead of exposing the list of Loans, we can apply a transformation and expose Strings.
    mLoansResult = Transformations.map(loans,
            new Function<List<LoanWithUserAndBook>, String>() {
        @Override
        public String apply(List<LoanWithUserAndBook> loansWithUserAndBook) {
            StringBuilder sb = new StringBuilder();
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm",
                    Locale.US);

            for (LoanWithUserAndBook loan : loansWithUserAndBook) {
                sb.append(String.format("%s\n  (Returned: %s)\n",
                        loan.bookTitle,
                        simpleDateFormat.format(loan.endTime)));
            }
            return sb.toString();
        }
    });
}
 

@Inject
public UserViewModel(UserRepository userRepository) {
    this.repository = userRepository;
    if (user == null) {
        Timber.d("Init UserViewModel");
        userIdentifier = new MutableLiveData<>();
        user = Transformations.switchMap(userIdentifier, input -> {
            if (input == null) {
                return AbsentLiveData.create();
            }
            return repository.login(new LoginRequest(input.username, input.password));
        });
    }
}
 

@Inject
public VideosViewModel(Application application, VideosRepository repository) {
    super(application);

    mRepository = repository;

    mAllCategories = mRepository.getAllCategories();

    mSearchResults = Transformations.switchMap(
            mQuery, new Function<String, LiveData<List<VideoEntity>>>() {
                @Override
                public LiveData<List<VideoEntity>> apply(final String queryMessage) {
                    return mRepository.getSearchResult(queryMessage);
                }
            });


    mVideoById = Transformations.switchMap(
            mVideoId, new Function<Long, LiveData<VideoEntity>>() {
                @Override
                public LiveData<VideoEntity> apply(final Long videoId) {
                    return mRepository.getVideoById(videoId);
                }
            });

    /**
     * Using switch map function to react to the change of observed variable, the benefits of
     * this mapping method is we don't have to re-create the live data every time.
     */
    mAllVideosByCategory = Transformations.switchMap(mVideoCategory, new Function<String, LiveData<List<VideoEntity>>>() {
        @Override
        public LiveData<List<VideoEntity>> apply(String category) {
            return mRepository.getVideosInSameCategoryLiveData(category);
        }
    });
}
 

public LiveData<Resource<BitsharesAsset>> getAvaliableBalance() {
    LiveData<Resource<BitsharesAsset>> balanceData = Transformations.switchMap(
            Transformations.switchMap(currencyData, input -> {
                return statusChangeLiveData;
            }),
            statusChange -> {
                return new AvailableBalanceRepository().getTargetAvaliableBlance(currencyData.getValue());
            });


    return balanceData;
}
 

public LiveData<Lcee<User>> getUser() {
    if (null == ldUser) {
        ldUsername = new MutableLiveData<>();
        ldUser = Transformations.switchMap(ldUsername, new Function<String, LiveData<Lcee<User>>>() {
            @Override
            public LiveData<Lcee<User>> apply(String username) {
                return userRepository.getUser(username);
            }
        });
    }
    return ldUser;
}
 

public LiveData<Lcee<User>> getUser() {
    if (null == ldUser) {
        ldUsername = new MutableLiveData<>();
        ldUser = Transformations.switchMap(ldUsername, new Function<String, LiveData<Lcee<User>>>() {
            @Override
            public LiveData<Lcee<User>> apply(String username) {
                return userRepository.getUser(username);
            }
        });
    }
    return ldUser;
}
 

public LiveData<Lcee<User>> getUser() {
    if (null == ldUser) {
        ldUsername = new MutableLiveData<>();
        ldUser = Transformations.switchMap(ldUsername, new Function<String, LiveData<Lcee<User>>>() {
            @Override
            public LiveData<Lcee<User>> apply(String username) {
                return userRepository.getUser(username);
            }
        });
    }
    return ldUser;
}
 

public LiveData<Lcee<User>> getUser() {
    if (null == ldUser) {
        ldUsername = new MutableLiveData<>();
        ldUser = Transformations.switchMap(ldUsername, new Function<String, LiveData<Lcee<User>>>() {
            @Override
            public LiveData<Lcee<User>> apply(String username) {
                return userRepository.getUser(username);
            }
        });
    }
    return ldUser;
}
 

public LiveData<Lcee<Projects>> getProjects() {
    if (null == ldProjects) {
        ldPage = new MutableLiveData<>();
        ldProjects = Transformations.switchMap(ldPage, new Function<Integer, LiveData<Lcee<Projects>>>() {
            @Override
            public LiveData<Lcee<Projects>> apply(Integer page) {
                return projectsRepository.getProjects(page);
            }
        });
    }
    return ldProjects;
}
 

public LiveData<Lcee<User>> getUser() {
    if (null == ldUser) {
        ldUsername = new MutableLiveData<>();
        ldUser = Transformations.switchMap(ldUsername, new Function<String, LiveData<Lcee<User>>>() {
            @Override
            public LiveData<Lcee<User>> apply(String username) {
                return userRepository.getUser(username);
            }
        });
    }
    return ldUser;
}
 

public GameMenuViewModel(
		@NonNull Application application,
		@NonNull GameMenu gameMenu) {
	this.application = application;
	this.gameMenu = gameMenu;

	quitTextLiveData = Transformations.map(gameMenu.getGameState(), this::mapQuitText);
	pauseTextLiveData = Transformations.map(gameMenu.isPausedState(), this::mapPausedText);
	gameSpeedTextLiveData = Transformations.map(gameMenu.getGameSpeed(), this::mapGameSpeedText);
	gameSpeedLiveData = Transformations.map(gameMenu.getGameSpeed(), this::mapGameSpeed);
}
 

public LiveData<DataResource<List<MovieEntity>>> getMovieList(boolean now) {
    return Transformations.switchMap(mCity, input ->
            Transformations.switchMap(getLoadLive(), aBoolean -> {
                        if (now) {
                            return MovieRepository.getInstance().getMovieNowList(input.getId());
                        } else {
                            return MovieRepository.getInstance().getMovieFutureList(input.getId());
                        }
                    }
            )
    );
}
 

public BuildingsCategoryViewModel(ActionControls actionControls, DrawControls drawControls, PositionControls positionControls, MenuNavigator menuNavigator, EBuildingsCategory buildingsCategory) {
	this.actionControls = actionControls;
	this.positionControls = positionControls;
	this.menuNavigator = menuNavigator;
	this.buildingsCategory = buildingsCategory;

	DrawEvents drawEvents = new DrawEvents(drawControls);
	buildingStates = Transformations.map(drawEvents, x -> buildingStates());
}
 

@Inject
MainViewModel(MainRepository repository) {
    this.repository = repository;
    filters.setValue(Filters.getDefault());
    isSignedIn = new LiveData<Boolean>() {
        @Override
        protected void onActive() {
            super.onActive();
            setValue(FirebaseAuth.getInstance().getCurrentUser() != null);
        }
    };

    restaurants = Transformations.switchMap(filters, repository::restaurants);
}
 

public ProductionViewModel(ActionControls actionControls, PositionControls positionControls, DrawControls drawControls) {
	this.actionControls = actionControls;
	this.positionControls = positionControls;

	DrawEvents drawEvents = new DrawEvents(drawControls);
	productionStates = Transformations.map(drawEvents, x -> productionStates());
}
 

@Override
public LiveData<User> searchUser(String userName){
    return Transformations.map(userDao.getUser(userName), new Function<UserLocal, User>() {
        @Override
        public User apply(UserLocal input) {
            if (input != null) {
                return input.toUser();
            } else {
                return null;
            }
        }
    });
}
 

public InventoryViewModel(DrawControls drawControls, PositionControls positionControls) {
	this.positionControls = positionControls;

	DrawEvents drawEvents = new DrawEvents(drawControls);
	inventoryMaterialStatesData = Transformations.map(drawEvents, x -> productionStates());
}
 

public JoinMultiPlayerPickerViewModel(GameStarter gameStarter, ChangingList<IJoinableGame> changingJoinableGames) {
	this.gameStarter = gameStarter;
	this.changingJoinableGames = changingJoinableGames;

	showNoGamesMessage = Transformations.map(joinableGames, joinableGames -> joinableGames.length == 0);
}
 

public LoadSinglePlayerPickerViewModel(GameStarter gameStarter, ChangingList<? extends MapLoader> changingMaps) {
	super(gameStarter, changingMaps);
	this.gameStarter = gameStarter;

	showNoMapsMessage = Transformations.map(getMaps(), maps -> maps.length == 0);
}
 

public LiveData<Resource<List<HistoryPrice>>> getHistoryPrice() {
    return Transformations.switchMap(mutableLiveDataSelected, currencyPair -> {
        return new HistoryPriceRepository(currencyPair).getHistoryPrice();
    });
}
 

public LiveData<Resource<List<BitsharesMarketTicker>>> getMarketTicker() {
    return Transformations.switchMap(marketChangeLiveData, marketChange -> {
        return new MarketTickerRepository().queryMarketTicker();
    });
}
 

public LiveData<DataResource<List<BoxOfficeEntity>>> getBoxOffices() {
    return Transformations.switchMap(getLoadLive(), input -> new BoxOfficeRepository().getBoxOffices());
}
 

public LiveData<DataResource<MovieDetail>> getMovieDetails(String locationId, int movieId) {
    return Transformations.switchMap(getLoadLive(), input ->
            new MovieDetailRepository().getMovieDetails(locationId, movieId)
    );
}
 

@Inject
RatingViewModel(RestaurantRepository repository) {
    this.repository = repository;
    restaurant = Transformations.switchMap(id, repository::restaurant);
    ratings = Transformations.switchMap(id, repository::ratings);
}
 

@Inject
public MainActivityViewModel() {
    App.getComponent().inject(this);
    this.weatherInfoLiveData = Transformations.switchMap(cityNameLiveData, weatherRepository::getWeather);
}
 

public LiveData<String> creat(String grep) {
    return Transformations.switchMap(transData, boo -> {
        return data;
    });
}