Запрос LiveData не выполняется во второй раз, когда я его инициализирую

Question

У меня есть список разных мин.У каждой шахты есть список блоков.

У меня есть шахты в счетчике и блоки в окне рециркуляции.

Я хочу отображать различные списки блоков всякий раз, когда пользователь меняет шахту в счетчике шахты

Я использую Firebase в качестве базы данных в качестве своей базы данных.

Когда я меняю шахту в счетчике, я обновляю список блокировки, создавая новую MutableLiveData, которую я расширил в классе под названием FirebaseQueryLiveData

В первый раз, когда я инициализирую FirebaseQueryLiveData запросом, содержащим имя шахты, все события внутри него запускаются.Однако после этого я это называю и ничего не срабатываетОн ломается в конструкторе, если у меня там есть точка останова, но он никогда не достигает метода run (), метода onActive () или onDataChanged в ValueEventListener.

Я провел некоторые исследования и видел предложениязаменить LiveData на MutableLiveData.Я сделал это, и это, кажется, не имеет значения.

Может ли кто-нибудь увидеть в коде что-то, чего мне не хватает?Я не очень хорошо знаком с компонентами архитектуры Android, и я получил класс FirebaseQueryLiveData с другого полезного веб-сайта с учебным пособием, поэтому я пытаюсь понять, где я ошибся.

Я провел некоторое исследование,и я видел предложения заменить LiveData на MutableLiveData.Я сделал это, и это, кажется, не имеет значения.

    public class BlockListActivityViewModel extends ViewModel {

        private static DatabaseReference blockOutlineRef; // = FirebaseDatabase.getInstance().getReference(FireBasePaths.BLOCKOUTLINE.getPath("Therisa"));
        private static DatabaseReference mineListRef;

        private FirebaseQueryLiveData blockOutlineLiveDataQuery = null;
        private LiveData<BlockOutlineList> blockOutlineLiveData = null;

        private MediatorLiveData<String> selectedBlockNameMutableLiveData;

        private MediatorLiveData<ArrayList<String>> mineListMutableLiveData;

        public BlockListActivityViewModel() {

            User loggedInUser = UserSingleton.getInstance();

            setUpFirebasePersistance();
            setupMineLiveData(loggedInUser);
    //        setupBlockOutlineListLiveData();
        }

        private void setupBlockOutlineListLiveData(String mineName) {
            if (mineName != "") {
                blockOutlineRef = FirebaseDatabase.getInstance().getReference(FireBasePaths.BLOCKOUTLINE.getPath(mineName));

                blockOutlineLiveDataQuery = new FirebaseQueryLiveData(blockOutlineRef);
                blockOutlineLiveData = Transformations.map(blockOutlineLiveDataQuery, new BlockOutlineHashMapDeserialiser());
            }
        }

        private void setupMineLiveData(User user) {
            ArrayList<String> mineNames = new ArrayList<>();
            if (user != null) {
                if (user.getWriteMines() != null) {
                    for (String mineName : user.getWriteMines().values()) {
                        mineNames.add(mineName);
                    }
                }
            }

            setMineListMutableLiveData(mineNames);
            if (mineNames.size() > 0) {
                updateMineLiveData(mineNames.get(0));
            }
        }

        public void updateMineLiveData(String mineName) {
            SelectedMineSingleton.setMineName(mineName);
            setupBlockOutlineListLiveData(SelectedMineSingleton.getInstance());
        }

        public void setUpFirebasePersistance() {
            int i = 0;
    //        FirebaseDatabase.getInstance().setPersistenceEnabled(true);
        }

        private MutableLiveData<NamedBlockOutline> selectedBlockOutlineMutableLiveData;

        public MutableLiveData<NamedBlockOutline> getSelectedBlockOutlineMutableLiveData() {

            if (selectedBlockOutlineMutableLiveData == null) {
                selectedBlockOutlineMutableLiveData = new MutableLiveData<>();

            }
            return selectedBlockOutlineMutableLiveData;
        }

        public void setSelectedBlockOutlineMutableLiveData(NamedBlockOutline namedBlockOutline) {
            getSelectedBlockOutlineMutableLiveData().postValue(namedBlockOutline);
        }

        public MediatorLiveData<String> getSelectedBlockNameMutableLiveData() {
            if (selectedBlockNameMutableLiveData == null)
                selectedBlockNameMutableLiveData = new MediatorLiveData<>();

            return selectedBlockNameMutableLiveData;
        }

        public void setSelectedBlockNameMutableLiveData(String blockName) {
            selectedBlockNameMutableLiveData.postValue(blockName);
        }

        public MediatorLiveData<ArrayList<String>> getMineListMutableLiveData() {
            if (mineListMutableLiveData == null)
                mineListMutableLiveData = new MediatorLiveData<>();

            return mineListMutableLiveData;
        }

        public void setMineListMutableLiveData(ArrayList<String> mineListString) {
            getMineListMutableLiveData().postValue(mineListString);
        }
    private class BlockOutlineHashMapDeserialiser implements Function<DataSnapshot, BlockOutlineList>, android.arch.core.util.Function<DataSnapshot, BlockOutlineList> {
        @Override
        public BlockOutlineList apply(DataSnapshot dataSnapshot) {

            BlockOutlineList blockOutlineList = new BlockOutlineList();
            HashMap<String, NamedBlockOutline> blockOutlineStringHashMap = new HashMap<>();

            for (DataSnapshot childData : dataSnapshot.getChildren()) {

                NamedBlockOutline thisNamedOutline = new NamedBlockOutline();
                HashMap<String, Object> blockOutlinePointHeader = (HashMap<String, Object>) childData.getValue();
                HashMap<String, BlockPoint> blockOutlinePoints = (HashMap<String, BlockPoint>) blockOutlinePointHeader.get("blockOutlinePoints");

                thisNamedOutline.setBlockName(childData.getKey());
                thisNamedOutline.setBlockOutlinePoints(blockOutlinePoints);

                blockOutlineStringHashMap.put(childData.getKey(), thisNamedOutline);
            }

            blockOutlineList.setBlockOutlineHashMap(blockOutlineStringHashMap);
            return blockOutlineList;
        }
    }

    @NonNull
    public LiveData<BlockOutlineList> getBlockOutlineLiveData() {
        return blockOutlineLiveData;
    }

}

LiveData

public class FirebaseQueryLiveData extends MutableLiveData<DataSnapshot> {
    private static final String LOG_TAG = "FirebaseQueryLiveData";

    private final Query query;
    private final MyValueEventListener listener = new MyValueEventListener();

    private boolean listenerRemovePending = false;
    private final Handler handler = new Handler();

    public FirebaseQueryLiveData(Query query) {
        this.query = query;
    }

    public FirebaseQueryLiveData(DatabaseReference ref) {
        this.query = ref;

    }

    private final Runnable removeListener = new Runnable() {
        @Override
        public void run() {
            query.removeEventListener(listener);
            listenerRemovePending = false;
            Log.d(LOG_TAG, "run");
        }
    };

    @Override
    protected void onActive() {
        super.onActive();
        if (listenerRemovePending) {
            handler.removeCallbacks(removeListener);
            Log.d(LOG_TAG, "listenerRemovePending");

        }
        else {
            query.addValueEventListener(listener);
            Log.d(LOG_TAG, "addValueEventListener");

        }
        listenerRemovePending = false;
        Log.d(LOG_TAG, "listenerRemovePending");

    }

    @Override
    protected void onInactive() {
        super.onInactive();
        // Listener removal is schedule on a two second delay
        handler.postDelayed(removeListener, 4000);
        listenerRemovePending = true;
        Log.d(LOG_TAG, "listenerRemovePending");

    }

    private class MyValueEventListener implements ValueEventListener {
        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
            setValue(dataSnapshot);
        }

        @Override
        public void onCancelled(DatabaseError databaseError) {
            Log.e(LOG_TAG, "Can't listen to query " + query, databaseError.toException());
        }
    }
}