Let's assume a fragment has this ActivityResultLauncher:
class MyFragment : Fragment(R.layout.my_fragment_layout) {
companion object {
private const val EXTRA_ID = "ExtraId"
fun newInstance(id: String) = MyFragment().apply {
arguments = putString(EXTRA_ID, id)
}
}
private val launcher = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
if (it.resultCode == Activity.RESULT_OK) {
Timber.i("Callback successful")
}
}
...
This Fragment a wrapped in an Activity for temporary architectural reasons, it will eventually be moved into an existing coordinator pattern.
class FragmentWrapperActivity : AppCompatActivity() {
private lateinit var fragment: MyFragment
private lateinit var binding: ActivityFragmentWrapperBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityFragmentWrapperBinding.inflate(this)
setContentView(binding.root)
fragment = MyFragment.newInstance("blah")
supportFragmentManager.transact {
replace(R.id.fragment_container, fragment)
}
}
}
And we use that launcher to start an Activity, expecting a result:
fun launchMe() {
val intent = Intent(requireContext(), MyResultActivity::class.java)
launcher.launch(intent)
}
On a normal device with plenty of available memory, this works fine. MyResultActivity finishes with RESULT_OK, the callback is called and I see the log line.
However, where memory is an issue and the calling fragment is destroyed, the launcher (and its callback) is destroyed along with it. Therefore when MyResultActivity finishes, a new instance of my fragment is created which is completely unaware of what's just happened. This can be reproduced by destroying activities as soon as they no longer have focus (System -> Developer options -> Don't keep activities).
My question is, if my fragment is reliant on the status of a launched activity in order to process some information, if that fragment is destroyed then how will the new instance of this fragment know where to pick up where the old fragment left off?
Your minimal fragment is unconditionally replacing the existing fragment with a brand new fragment everytime it is created, thus causing the previous fragment, which has had its state restored, to be removed.
As per the Create a Fragment guide, you always need to wrap your code to create a fragment in onCreate in a check for if (savedInstanceState == null):
In the previous example, note that the fragment transaction is only created when savedInstanceState is null. This is to ensure that the fragment is added only once, when the activity is first created. When a configuration change occurs and the activity is recreated, savedInstanceState is no longer null, and the fragment does not need to be added a second time, as the fragment is automatically restored from the savedInstanceState.
So your code should actually look like:
fragment = if (savedInstanceState == null) {
// Create a new Fragment and add it to
// the FragmentManager
MyFragment.newInstance("blah").also { newFragment ->
supportFragmentManager.transact {
replace(R.id.fragment_container, newFragment)
}
}
} else {
// The fragment already exists, so
// get it from the FragmentManager
supportFragmentManager.findFragmentById(R.id.fragment_container) as MyFragment
}
I'm going to MenuFragment from MainActivty and calling RecyclerViewAdapter inside in MenuFragment class to set my data to show . then I want to set the callback in my Adapter using higher order function (Kotlin language) to send the data to MainActivity to change something in BottomNavigationView UI.
MainActivty class:
val callbackFromAdapter=RecyclerAdapterInside(null,null,this,::callbackAdapterInside)
private fun callbackAdapterInside(OrderList:MutableList<OrderLive>)
{
var totalSum=0
for(elements in OrderList)
{
totalSum+=elements.getcount()
}
Log.d("oncell", "$totalSum")
if(totalSum>0)
{
CoroutineScope(Dispatchers.Main).launch {
badge_current_order.visibility=View.VISIBLE
badge_current_order.setText(totalSum)
}
}
else
CoroutineScope(Dispatchers.Main).launch {
badge_current_order.setText(0)
badge_current_order.visibility=View.GONE
}
}
RecyclerAdapterInside class:
class RecyclerAdapterInside(
PlaceId:String?=null, var myReceivedData: List<ItemClass>?=null, val context:Context,
val CurrentCartUpdateCallback: ((OrderList: MutableList<OrderLive>) -> Unit?)? = null):RecyclerView.Adapter<RecyclerView.ViewHolder>() {
...
CoroutineScope(Dispatchers.IO).launch {
if(CurrentCartUpdateCallback!=null) { //never pass this condition
CurrentCartUpdateCallback!!(myOrderLive)
Log.d("tagtest", "Callback is called ")
}
}
}
I said I'm using RecyclerAdapterInside in my MenuFragment class to set data.
recyclerview.adapter=RecyclerAdapterInside(
id,
result,
this#MenuFragment.requireContext(),
null
)
for this reason I should create the type of null for CurrentCartUpdateCallback variable. Because I never use this callback in MenuFragmentClass and I always pass null when I don't need callback in this class. so I just use it in MainActivity class.
The problem is callbackAdapterInside is never called and CurrentCartUpdateCallback is always null in:
if(CurrentCartUpdateCallback!=null)
I don't use higher order function much. Do I have to use this callback in order of class numbers
Adapter->3->2->1 or can I use callback directly from the adapter class to the Main activity class ?
I want to test DialogFragment using androidx.fragment:fragment-testing lib.
I call launchFragmentInContainer and moveToState(Lifecycle.State.RESUMED), but onCreateDialog is not called in this fragment.
#Test
fun `submit search - presenter state is changed`() {
val p: PinCatsPresenter = F.presenter(PinCatsPresenter.COMPONENT_ID)!!
launchFragmentInContainer<PinCatsDialog>().let { scenario ->
scenario
.moveToState(Lifecycle.State.RESUMED)
.onFragment { fragment ->
assertFalse(p.state.isFiltered)
fragment.dialog!!.findViewById<SearchView>(R.id.search_field).let {
it.isIconified = false
it.setQuery("ea", true)
}
awaitUi()
assertTrue(p.state.isFiltered)
assertEquals(3, p.state.count)
}
}
}
I debug the app, and ensured that onCreateDialog is called earlier than onResume, but in this test scenario onCreateDialog is not called, so fragment.dialog is null.
What should I call onFragmentScenario so my dialog would be created?
This is described in the official documentation. We need to call launchFragment instead of launchFragmentInContainer:
launchFragment<PinCatsDialog>().let { scenario ->
scenario
.moveToState(Lifecycle.State.RESUMED)
.onFragment { fragment ->
// Code here
}
}
I am working with Android architecture components.
What i want is when user type "0" in Edittext and click on Button to replace Fragment with new one , and if type anything else post Toast error message. In Problem is when i back from new Fragment(BlankFragment) and click on button again and type "0" again and click, onchange() is called multiple times so Fragment is get created multiple times
FragmentExample.class:
#Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
manager = getActivity().getSupportFragmentManager();
viewmModel = ViewModelProviders.of(getActivity(), viewModelFactory)
.get(VModel.class);
View v = inflater.inflate(R.layout.fragment_list, container, false);
b = (Button) v.findViewById(R.id.b);
et = (EditText) v.findViewById(R.id.et);
viewmModel.observeData().observe(getActivity(), new Observer<String>() {
#Override
public void onChanged(#Nullable String s) {
if(s.equals("0")) {
BlankFragment fragment = (BlankFragment) manager.findFragmentByTag(DETAIL_FRAG);
if (fragment == null) {
fragment = BlankFragment.newInstance();
}
addFragmentToActivity(manager,
fragment,
R.id.root_activity_detail,
DETAIL_FRAG
);
} else {
Toast.makeText(getContext(), "Wrong text", Toast.LENGTH_SHORT).show();
}
}
});
b.setOnClickListener(new View.OnClickListener() {
#Override
public void onClick(View v) {
viewmModel.setData(et.getText().toString());
}
});
return v;
}
private void addFragmentToActivity(FragmentManager fragmentManager, BlankFragment fragment, int root_activity_detail, String detailFrag) {
android.support.v4.app.FragmentTransaction transaction = fragmentManager.beginTransaction();
transaction.replace(root_activity_detail, fragment, detailFrag).addToBackStack(detailFrag);
transaction.commit();
}
Repository class:
public class Repository {
MutableLiveData<String> dataLive = new MutableLiveData<>();
public Repository() {
}
public void setListData(String data) {
dataLive.setValue(data);
}
public MutableLiveData<String> getData() {
return dataLive;
}
}
BlankFragment.class:
#Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
listItemViewModel = ViewModelProviders.of(this, viewModelFactory)
.get(VModel.class);
listItemViewModel.setData("");
return inflater.inflate(R.layout.fragment_blank, container, false);
}
Here is an example how i solve this problem .[TESTED AND WORKING]
viewModel.getLoginResponse().observe(getViewLifecycleOwner(), new Observer<String>() {
#Override
public void onChanged(String response) {
if(getViewLifecycleOwner().getLifecycle().getCurrentState()== Lifecycle.State.RESUMED){
// your code here ...
}
}
});
The problem here is that when you dettach the fragment from the acitivity, both fragment and its viewmodel are not destroyed. When you come back, you add a new observer to the livedata when the old observer is still there in the same fragment （If you add the observer in onCreateView()）.
There is an article (Even a SO thread in fact) talking about it (with solution).
The easy way to fix it (also in the article) is that remove any observer from the livedata before you add observer to it.
Update:
In the support lib v28, a new LifeCycleOwner called ViewLifeCycleOwner should fix that more info in here
here is what you are doing wrong...
viewmModel.observeData().observe(getActivity(), new Observer<String>() {
#Override
public void onChanged(#Nullable String s) {
if(s.equals("0")) {
BlankFragment fragment = (BlankFragment) manager.findFragmentByTag(DETAIL_FRAG);
if (fragment == null) {
fragment = BlankFragment.newInstance();
}
addFragmentToActivity(manager,
fragment,
R.id.root_activity_detail,
DETAIL_FRAG
);
} else {
Toast.makeText(getContext(), "Wrong text", Toast.LENGTH_SHORT).show();
}
}
});
in above code instead of "getActivity()" either you can use "this" or "viewLifecycleOwner".
Because as you are passing the getActivity() in observe method, whenever you open your fragment you are attaching the new instance of the observer with the Activity not with the fragment. So observer will keep alive even if you kill your fragment.
So when livedata postvalue, it will send data to all the observers,
as there are too many observers observing livedata, then all will get notified.
Because of this, your observer gets called too many times.
so you have to observe live data in fragment something like this.
viewmModel.observeData().observe(this, new Observer<String>() {
#Override
public void onChanged(#Nullable String s) {
if(s.equals("0")) {
BlankFragment fragment = (BlankFragment) manager.findFragmentByTag(DETAIL_FRAG);
if (fragment == null) {
fragment = BlankFragment.newInstance();
}
addFragmentToActivity(manager,
fragment,
R.id.root_activity_detail,
DETAIL_FRAG
);
} else {
Toast.makeText(getContext(), "Wrong text", Toast.LENGTH_SHORT).show();
}
}
});
But still your onchanged method will get called two times.
You can stop this by checking one condition inside your onchanged method..
dash_viewModel.getDashLiveData().observe(viewLifecycleOwner, object : Observer<AsyncResponse> {
override fun onChanged(t: AsyncResponse?) {
if(viewLifecycleOwner.lifecycle.currentState==Lifecycle.State.RESUMED){
setData(t)
}
}
})
from my research, I have found out that, if fragment using the ViewModel of its corresponding activity,
So when even you start observing the livedata, it will first send you the most recently emitted item. even if you didn't call it from your fragment.
so onChange method got called two times
When the fragment is on start state - to receive the most recently emitted item
When the fragment is on Resumed state - to receive the call made by fragment either for api.
so on changed I always check the state of the fragment with the help of viewLifecycleOwner like this
if(viewLifecycleOwner.lifecycle.currentState==Lifecycle.State.RESUMED){
// if the fragment in resumed state then only start observing data
}
viewlifecycleowner is provided by both Fragments and Activity as Google implemented this solution directly in support library 28.0.0 and androidx with getViewLifecycleOwner() method. viewlifecycleowner contains info about the lifecycle of the component.
in java you can use getViewLifecycleOwner() intead of viewlifecycleowner .
Instead of using getActivity as LifecycleOwner, you should use fragment.
Change
viewModel.observeData().observe(getActivity(), new Observer<String>() {
to
viewModel.observeData().removeObservers(this);
viewModel.observeData().observe(this, new Observer<String>() {
You shouldn't create your viewmModel in onCreateView but rather in onCreate so you don't add a listener to your data each time view is created.
Solution for similar issue with Flow
If you`re using Flow instead of LiveData then don't forget to use viewLifecycleOwner.lifecycleScope.launch instead of lifecycleScope.launch:
viewLifecycleOwner.lifecycleScope.launch {
flow.flowOn(Default).collect {
requireContext()
}
}
Or with extension:
extension:
fun <T> Flow<T>.launchWhenStarted(lifecycleOwner: LifecycleOwner) {
lifecycleOwner.lifecycleScope.launchWhenStarted {
this#launchWhenStarted.collect()
}
}
in fragment`s onViewCreated:
availableLanguagesFlow
.onEach {
//update view
}.launchWhenStarted(viewLifecycleOwner)
to add an observer to a LiveData, you should initialize your observer in onViewCreated (as you did) and attach the viewLifecycleOwner. So, it should look like this:
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
viewModel.yourVariable.observe(viewLifecycleOwner, Observer{ newValue ->
// todo your function
})
See Kotlin Android Training Livedata for more information!
Just declare your Observer as a field variable so you don't create a new observer every time the lifecycle calls that part of your code. ;)
i.e. with kotlin:
YourFragment: Fragment() {
private val dataObserver = Observer<Data> { data ->
manageData(data)
}
...
//now you should subscribe your data after you instantiate your viewModel either in onCreate, onCreateView, onViewCreated, depends on your case..
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
viewModel.liveData.observe(this, dataObserver)
}
...
}
To be clear, to instantiate a ViewModel we pass either the context of the Fragment itself, in which this viewmodel will be scoped to, or we pass the activity that holds this fragment as the context.
Is not the same and they have different purposes, if we do this
listItemViewModel = ViewModelProvider(requireActivity(), viewModelFactory)
.get(VModel.class);
We attach this instance of the viewmodel to the parent activity of the fragment, after this fragment dies , the instance of that viewmodel will be kept in memory holding the reference to the parent activity.
If we do this
// requireContext() or this
listItemViewModel = ViewModelProvider(requireContext(), viewModelFactory)
.get(VModel.class);
We scope the instance of the viewmodel in the parent itself, so whenever the fragment dies, this viewmodel instance also gets removed.
Now, the observers are the same, we need to specify that we only want to observer to the lifetime span of the Fragment, for example, we want to observer untill this fragment is destroyed and then detach any observer if we are not in this fragment, for this, here it comes viewLyfeCycleOwner which will observe until this fragment dies or pauses to go to antoher fragment, it's important to use it in each fragment:
viewmModel.observeData().observe(viewLyfeCycleOwner, new Observer<String>() { ... }
if we attach this observer to the activity with
viewmModel.observeData().observe(getActivity(), new Observer<String>() { ... }
It will keep observing until the parent activity holding the fragment dies, and is not a good idea since it will subscribe multiple observers to the same livedata.
viewmModel = ViewModelProviders.of(getActivity(), viewModelFactory)
.get(VModel.class);
As your viewmModel's LifecycleOwner is activity, so the observer will only be automatically removed when the state of lifecycle is Lifecycle.State.DESTROYED.
In your situation, the observer will not be automatically removed.So you have to remove the previous observer manually or pass the same instance of observer every time.
I had the same problem, when I created a fragment and declared an observer into onCreate() or onCreateView(), after a rotation of screen, my livedata runned twice times.
In order to solve this problem, I tried kotlin extension in order to remove observer just before to create an other one, I tried to remove into onDestroyView(), I tried to change the lifecyclcleOwner when the viewmodel declaration (requiredActivity - this - viewLifecycleOwner) but all tests failed.
But finally I found a solution with coroutines. I don't know if it's a good practice but it work :
override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
// ......
// observer
CoroutineScope(Dispatchers.Main).launch {
delay(100)
mMainViewModel.getMailings().observe(viewLifecycleOwner, Observer { showViewModelMailingsList(it) })
}
// call
mMainViewModel.responseMailingList(preferences.userEmailAccount, preferences.deviceToken)
// ....
}
Adding some useful information after #Samuel-Eminet,
it's true that onCreate(Bundle?) is called only once on the Fragment creation and when you press back, the view is recreated but not the fragment (hence why the ViewModel is the same. If you subscribe in any method of the lifecycle that affects the view, it will resubscribe again and again.
Observers would have been gone and you won't be able to tell even if you ask for liveData.hasObservers().
The best thing to do is subscribing when onCreate(Bundle?) but many of us are using the binding, and the view isn't created at this time, so this is the best way to do it:
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
lifecycleScope.launchWhenStarted {
subscribeUI()
}
}
now you're telling the Fragment's lifecycle to do something when it starts the Fragment and it will call it only once.
Observe the livedata only once in a fragment. For that call the observe method in onCreate() rather than onCreateView(). When we press back button the onCreateView() method is called which makes the viewmodel to observe data again.
#Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mPatientViewModel.getGetCaseDetailLiveData().observe(this, jsonObjectResponse -> parseViewSentResponse(jsonObjectResponse));
}
#Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
// TODO: inflate a fragment view
View rootView = super.onCreateView(inflater, container, savedInstanceState);
return rootView;
}