onnectableObservable<Wrapper<List<Object[]>>> connectable = NetworkManager.getOpenHABService().getFloorPlan1()
                .subscribeOn(Schedulers.io())
                .flatMap(plan -> Observable.fromArray(plan))
                .flatMap(planItem -> NetworkManager.getOpenHABService().getFloor(planItem.getId()).subscribeOn(Schedulers.computation()))
                .flatMap(floor -> {
                    List<Observable<?>> list = new ArrayList<>();
                    list.add(Observable.just(floor));
                    if (floor.getHotspots() != null) {
                        for (Hotspot hotspot : floor.getHotspots()) {
                            list.add(NetworkManager.getOpenHABService().getItem(hotspot.getItemId()).subscribeOn(Schedulers.computation()));
                        }
                    }
                    return Observable.zip(list, (sensors) -> sensors);
                })
                .toList()
                .toObservable()
                .map(sensors -> Wrapper.response(sensors))
                .observeOn(mainThread())
                .retry(2)
                .onErrorResumeNext(throwable -> {
                    LogManager.LogEA(throwable);
                    // If the server is unreachable, let the subscriber know.
                    // The user may be able to do something about his connection.
                    if (throwable instanceof UnknownHostException || throwable instanceof Throwable) {
                        // Recoverable error - transmit error without breaking.
                        return Observable.just(Wrapper.error(throwable));
                    }
                    // In case of an unrecoverable error, let it end.
                    return Observable.error(throwable);
                })
                .repeatWhen(observable ->
                        Observable.interval(10, TimeUnit.SECONDS)
                                .mergeWith(hook).takeWhile(e -> longPooling)
                )
                .replay(1);

        connectable.connect();
        connectable.subscribe(e ->{
            Map<Integer, Pair<OpenHABFloor, List<OpenHABItem>>> data = new HashMap<>();
            int floorId = -1;
            for(Object floor: e.response) {
                for (Object item : (Object[])floor) {
                    if (item instanceof OpenHABFloor) {
                        data.put(((OpenHABFloor) item).getId(), new Pair((OpenHABFloor) item, new ArrayList<OpenHABItem>()));
                        floorId = ((OpenHABFloor) item).getId();
                    } else if (item instanceof OpenHABItem) {
                        Pair<OpenHABFloor, List<OpenHABItem>> pair = data.get(floorId);
                        OpenHABItem currentItem = (OpenHABItem) item;
                        if (currentItem.getName().contains("binary")) {
                            currentItem.setItemType(OpenHABItem.ItemType.SENSOR);
                        } else if (currentItem.getName().contains("temperature")) {
                            currentItem.setItemType(OpenHABItem.ItemType.TEMPERATURE);
                        } else if (currentItem.getName().contains("thermostat")) {
                            currentItem.setItemType(OpenHABItem.ItemType.TERMOSTAT);
                        }
                        pair.second.add(currentItem);
                    } else {
                        LogManager.LogEA("invalid type", item);
                    }
                }
            }
            LogManager.LogEA(data);
        });