private int timeDelay;
private int counter;
private boolean isUpdaterRunning;

private void resetUpdater(){
    isUpdaterRunning = false;
}

private void startCheckHomeAlarms() {
    if (isUpdaterRunning){
        log("Updater is running");
        return;
    }
    isUpdaterRunning = true;
    resetDelayAndCounter();
    getHomes().doOnSubscribe(compositeDisposable::add)
            .subscribeOn(Schedulers.io())
            .flatMapIterable(homes -> {
                log("Home found: " + homes.size());
                return homes;
            })
            .flatMap(this::checkHome)
            .toList()
            .toObservable()
            .repeatWhen(objectObservable -> objectObservable.flatMap(o -> {
                        log("Time delay: " + timeDelay);
                        timeDelay = timeDelay == 13 ? 13 : fibonacciRecursion(counter);
                        counter++;
                        return Observable.just(o).delay(timeDelay, TimeUnit.SECONDS);
                    }))
            .takeUntil(homes -> numberOfHomeAlarmRunning(homes) == 0)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(this::showResult, this::logError);
}

private Observable<List<Home>> getHomes(){
    return thingDataBase.findHomes()
            .flatMapIterable(homes -> homes)
            .filter(this::filterHome)
            .toList()
            .toObservable()
            .filter(homes -> homes.size() > 0)
            .singleOrError()
            .onErrorResumeNext(throwable -> Single.error(new Exception("Items not found")))
            .toObservable();
}

private boolean filterHome(Home home){
    return isHomeRunning(home) || home.getStatus().equals(HomeAlarmStatus.ERROR.status());
}

private int numberOfHomeAlarmRunning(List<Home> homes){
    int running = 0;
    for (Home home: homes){
        if (isHomeRunning(home))
            running++;
    }
    return running;
}

private Observable<Home> checkHome(Home home){
    log("checkHome : " + home.getStatus());
    return isHomeRunning(home) ? checkHomeAlarmStatus(home) : Observable.fromCallable(() -> home);
}

private boolean isHomeRunning(Home home){
    return home.getStatus().equals(HomeAlarmStatus.RUNNING.status());
}

private Observable<Home> checkHomeAlarmStatus(Home home){
    return thingManager.getAlarmState(home.getId(), home.getExecutionId())
            .subscribeOn(Schedulers.io())
            .doOnSubscribe(compositeDisposable::add)
            .map(homeAlarm -> updateHome(home, homeAlarm))
            .flatMap(home1 -> updateHomeInLocalDatabase(home1));
}

private Home updateHome(Home home, HomeAlarm homeAlarm){
    log("updateHome: " + homeAlarm.getState());
    home.setStatus(homeAlarm.getState());
    home.setHomeAlarm(homeAlarm);
    return home;
}

private Observable<Home> updateHomeInLocalDatabase(Home home){
    log("updateHomeInLocalDatabase " + home.getStatus());
    return isHomeRunning(home) ? Observable.fromCallable(() -> home) :
            thingDataBase.updateHome(home).toObservable().map(o -> home);
}

private void showResult(List<Home> homes){
    log("Results finished: " + homes.size());
    if (numberOfHomeAlarmRunning(homes) == 0){
        thingDataBase.notifyChangesOfHomesToObservers();
        resetUpdater();
    }
    for (Home home: homes){
        HomeAlarmStatus status = HomeAlarmStatus.detectHomeStatus(home.getStatus());
        log("Home finished " + home.getStatus() + " \n ---------------------------------------------------");
        showHomeAlertDialog(home, status);
    }
}

private void showHomeAlertDialog(Home home, HomeAlarmStatus status){
    if (status != HomeAlarmStatus.ERROR)
        return;
    HomeAlarmDialog dialog = new HomeAlarmDialog(app.getContext(), home.getHomeAlarm());
    dialog.show();
}

private int fibonacciRecursion(int number) {
    if (number == 1 || number == 2)
        return 1;
    return fibonacciRecursion(number - 1) + fibonacciRecursion(number - 2);
}