Partage de données entre fragments à l'aide d'un nouveau modèle D'affichage de composants d'architecture

avant d'utiliser un rappel qui se rattache à une activité considérée comme un conteneur.

Ce rappel est un intermédiaire entre deux Fragments. Les mauvaises choses à propos de cette solution précédente sont les suivantes:

• Activité a faire le rappel, cela signifie beaucoup de travail pour Activité.
• deux Fragments sont couplés étroitement, il est difficile de mettre à jour ou de changer la logique plus tard.

avec le nouveau modèle de vue (avec le soutien de LiveData), vous avez une solution élégante. Il joue maintenant un rôle d'intermédiaire que vous pouvez attacher son cycle de vie à L'activité.

• la logique et les données entre deux Fragments sont maintenant présentées dans ViewModel.
• deux fragments obtiennent des données / états de ViewModel, de sorte qu'ils n'ont pas besoin de se connaître.
• en outre, avec la puissance de LiveData, vous pouvez changer Fragment de détail basé sur des changements de Fragment maître en approche réactive au lieu de rappel précédent façon.

vous vous débarrassez maintenant complètement de callback qui associe étroitement à la fois L'activité et les Fragments connexes.

Je recommande fortement de vous par le biais de Google Code lab. À l'étape 5, vous trouverez un bel exemple à ce sujet.

j'ai implémenté quelque chose de similaire à ce que vous voulez, mon viewmodel contient l'objet LiveData qui contient l'état Enum, et quand vous voulez changer le fragment du maître aux détails (ou à l'inverse) vous appelez les fonctions ViewModel qui changent la valeur livedata, et l'activité savent changer le fragment parce qu'il observe livedata objet.

TestViewModel:

public class TestViewModel extends ViewModel {
    private MutableLiveData<Enums.state> mState;

    public TestViewModel() {
        mState=new MutableLiveData<>();
        mState.setValue(Enums.state.Master);
    }

    public void onDetail() {
        mState.setValue(Enums.state.Detail);
    }

    public void onMaster() {
        mState.setValue(Enums.state.Master);
    }

    public LiveData<Enums.state> getState() {

        return mState;
    }
}

les Énumérations:

public class Enums {
    public enum state {
        Master,
        Detail
    }
}

TestActivity:

public class TestActivity extends LifecycleActivity {
    private ActivityTestBinding mBinding;
    private TestViewModel mViewModel;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mBinding=DataBindingUtil.setContentView(this, R.layout.activity_test);
        mViewModel=ViewModelProviders.of(this).get(TestViewModel.class);
        mViewModel.getState().observe(this, new Observer<Enums.state>() {
            @Override
            public void onChanged(@Nullable Enums.state state) {
                switch(state) {
                    case Master:
                        setMasterFragment();
                        break;
                    case Detail:
                        setDetailFragment();
                        break;
                }
            }
        });
    }

    private void setMasterFragment() {
        MasterFragment masterFragment=MasterFragment.newInstance();
        getSupportFragmentManager().beginTransaction().replace(R.id.frame_layout, masterFragment,"MasterTag").commit();
    }

    private void setDetailFragment() {
        DetailFragment detailFragment=DetailFragment.newInstance();
        getSupportFragmentManager().beginTransaction().replace(R.id.frame_layout, detailFragment,"DetailTag").commit();
    }

    @Override
    public void onBackPressed() {
        switch(mViewModel.getState().getValue()) {
            case Master:
                super.onBackPressed();
                break;
            case Detail:
                mViewModel.onMaster();
                break;
        }
    }
}

MasterFragment:

public class MasterFragment extends Fragment {
    private FragmentMasterBinding mBinding;


    public static MasterFragment newInstance() {
        MasterFragment fragment=new MasterFragment();
        return fragment;
    }

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        mBinding=DataBindingUtil.inflate(inflater,R.layout.fragment_master, container, false);
        mBinding.btnDetail.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                final TestViewModel viewModel=ViewModelProviders.of(getActivity()).get(TestViewModel.class);
                viewModel.onDetail();
            }
        });

        return mBinding.getRoot();
    }
}

DetailFragment:

public class DetailFragment extends Fragment {
    private FragmentDetailBinding mBinding;

    public static DetailFragment newInstance() {
        DetailFragment fragment=new DetailFragment();
        return fragment;
    }

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        mBinding=DataBindingUtil.inflate(inflater,R.layout.fragment_detail, container, false);
        mBinding.btnMaster.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                final TestViewModel viewModel=ViewModelProviders.of(getActivity()).get(TestViewModel.class);
                viewModel.onMaster();
            }
        });
        return mBinding.getRoot();
    }
}

je finis par utiliser le propre modèle de vue pour maintenir l'écouteur qui déclenchera la méthode D'activité. Similaire au ancienne mais comme je l'ai dit, passer L'auditeur à ViewModel au lieu du fragment. Ainsi, mon modèle de vue ressemblait à ceci:

public class SharedViewModel<T> extends ViewModel {

    private final MutableLiveData<T> selected = new MutableLiveData<>();
    private OnSelectListener<T> listener = item -> {};

    public interface OnSelectListener <T> {
        void selected (T item);
    }


    public void setListener(OnSelectListener<T> listener) {
        this.listener = listener;
    }

    public void select(T item) {
        selected.setValue(item);
        listener.selected(item);
    }

    public LiveData<T> getSelected() {
        return selected;
    }

}

dans StepMasterActivity-je obtenir le ViewModel et de le définir comme un port d'écoute:

StepMasterActivity.classe:

SharedViewModel stepViewModel = ViewModelProviders.of(this).get("step", SharedViewModel.class);
stepViewModel.setListener(this);

...

@Override
public void selected(Step item) {
    Log.d(TAG, "selected: "+item);
}

...

dans le fragment j'ai juste récupérez le ViewModel

stepViewModel = ViewModelProviders.of(getActivity()).get("step", SharedViewModel.class);

et l'appel:

stepViewModel.select(step);

je l'ai testé superficiellement et cela a fonctionné. Au fur et à mesure que je mettrai en œuvre les autres fonctionnalités liées à ce problème, je serai au courant de tout problème qui pourrait se produire.

j'ai trouvé une solution similaire à d'autres selon Google codelabs exemple. J'ai deux fragments où l'un d'eux attend un changement d'objet dans l'autre et continue son processus avec un objet mis à jour.

pour cette approche, vous aurez besoin d'un ViewModel classe comme ci-dessous:

import android.arch.lifecycle.MutableLiveData;
import android.arch.lifecycle.ViewModel;
import yourPackage.YourObjectModel;

public class SharedViewModel extends ViewModel {

   public MutableLiveData<YourObjectModel> item = new MutableLiveData<>();

   public YourObjectModel getItem() {
      return item.getValue();
   }

   public void setItem(YourObjectModel item) {
      this.item.setValue(item);
   }

}

et l'auditeur fragment devrait ressembler à ceci:

public class ListenerFragment extends Fragment{
   private SharedViewModel model;
  @Override
  public void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    model = ViewModelProviders.of(getActivity()).get(SharedViewModel.class);

    model.item.observe(getActivity(), new Observer<YourObjectModel>(){

        @Override
        public void onChanged(@Nullable YourObjectModel updatedObject) {
            Log.i(TAG, "onChanged: recieved freshObject");
            if (updatedObject != null) {
                // Do what you want with your updated object here. 
            }
        }
    });
}
}

enfin, le fragment updater peut être comme ceci:

public class UpdaterFragment extends DialogFragment{
    private SharedViewModel model;
    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       model = ViewModelProviders.of(getActivity()).get(SharedViewModel.class);
   }
   // Call this method where it is necessary
   private void updateViewModel(YourObjectModel yourItem){
      model.setItem(yourItem);
   }
}

Il est bon pour mentionner que le fragment updater peut être n'importe quelle forme de fragments(pas DialogFragment seulement) et pour utiliser ces composants d'architecture, vous devriez avoir ces lignes de codes dans votre construction d'application.dossier gradle. source

dependencies {
  def lifecycle_version = "1.1.1"
  implementation "android.arch.lifecycle:extensions:$lifecycle_version"
}

Vous pouvez définir des valeurs de fragment de détail à Fragment maître comme ceci

model.selected.setValue(item)