How to refresh a screen when returning from another screen of a different navigator (React Native)?

Question

I have been implementing most of my application with a StackNavigator. Now, I added a DrawerNavigator, from which one of its screens calls another screen of the original StackNavigator. For example, consider the following navigation sequence that a user could make:

ScreenA -> ScreenB -> ScreenC

where ScreenA belongs to the StackNavigator, ScreenB belongs to the DrawerNavigator, and ScreenC belongs to the StackNavigator again. To achieve that, actually ScreenA does not call ScreenB directly, but another screen whose sole purpose is to serve as a root of all the screens that belong to the DrawerNavigator. Also, that root receives the StackNavigator in the ScreenProps in order that its screens can later use the Stack again.

Now, if I am in ScreenC and I go back using "this.props.navigation.goBack()", I return to the DrawerNavigator in the ScreenB, because that is which called ScreenC. The ScreenB should refresh its state, that is, it should reload information from the database, because that information could have changed in ScreenC, so the previous state is no longer valid.

When only using StackNavigator, I always managed to do it using "NavigationEvents". For example:

import {Component} from 'react'
...
import { NavigationEvents } from 'react-navigation'

class ScreenB extends Component{

    // This is the function that loads information from the database (PouchDB)
    loadInformation = async() =>{
        ...
    }

    render(){
        return(
            <View>
                <NavigationEvents onWillFocus = {payload => this.loadInformation()}/>
                <NavigationEvents onDidFocus  = {payload => this.loadInformation()}/>
                ...
            </View>
        )
    }
}

With this implementation, the function "loadInformation" activated both when I entered the screen for first time, and also when I returned to it from a child screen. But this time that I am mixing both navigators, neither "onWillFocus" nor "onDidFocus" are activating when returning from ScreenC to ScreenB, so I cannot enter to the "loadInformation" function again. How could I do it?

Edit:

I also tried keeping a boolean variable in Redux store that determines if the function "loadInformation" of ScreenB must be activated. That variable starts with the true value. Then, once I enter to Screen B and I execute the function, it is changed to false. When I navigate to ScreenC, in that screen the variable is changed to true again, so when I go back to ScreenB it indicates again that the function must be executed.

That required to use in ScreenB the "componentDidUpdate" function, that constantly checks if that variable is true or false in order to call "loadInformation". That solved the problem, but brought a new one. When I try to navigate from ScreenB to another screen of the DrawerNavigator, it takes too much time, because in the transition "componentDidUpdate" is called repeatedly. So this solution does not seem viable.

Answer 1

I am answering my own question.

The solution was to use a boolean variable from Redux's store that indicates if the function "loadInformation" must be activated or not. Let's say the variable is named "loadView", which has the value "false" by default, but the ScreenC sets it in "true" when it is going to be closed and therefore we are going to return to ScreenB.

In other words, the file of ScreenC includes this code:

import {Component} from 'react'
import { connect } from 'react-redux'
// Here we import the action that allows to change the value of "loadView"
import { changeLoadView } from '../../redux/actions/popUpActions'
...

class ScreenC extends Component{
    ...
    // Function that is activated automatically when we leave the screen
    componentWillUnmount(){
        // This is the function that assigns the value "true" to "loadView"
        this.props.dispatchChangeLoadView(true)
    }
    ...
}

const mapStateToProps = (state) => {
    return {
        ...
    }
}

const mapDispatchToProps = (dispatch) => {
    return {
        dispatchChangeLoadView: (bool) => dispatch(changeLoadView(bool)),
        ....
    }
}

export default connect(mapStateToProps, mapDispatchToProps)(ScreenC);

In the file of ScreenB I use a "fake view", which is a React View that is not placed directly in the "render" function but it is called by another function (named "activateLoadInformation" in this case). That function returns an empty view, but the reason to use it is because before its "return" we can activate any other function of ScreenB that we want, that in this case is "loadInformation". I don't know another way to activate functions that don't render anything arbitrarily when we want to.

import {Component} from 'react'
import { connect } from 'react-redux'
...

class ScreenB extends Component{
    ...
    // This is the function that loads information from the database (PouchDB)
    loadInformation = async() =>{
        this.props.dispatchChangeLoadView(false);
        ...
    }

    // Fake view that calls the function "loadInformation"
    activateLoadInformation(){
        this.loadInformation();
        return(<View/>)
    }

    render(){
        return(
            <View>
                {!this.props.loadView && 
                    <NavigationEvents onWillFocus = {payload => this.loadInformation()}/>
                }
                {this.props.loadView &&
                    this.activateLoadInformation()
                }
                ...
            </View>
        )
    }
}

const mapStateToProps = (state) => {
    return {
        loadView: state.popUpReducer.loadView,
    }
}

const mapDispatchToProps = (dispatch) => {
    return {
        dispatchChangeLoadView: (bool) => dispatch(changeLoadView(bool)),
        ....
    }
}

export default connect(mapStateToProps, mapDispatchToProps)(ScreenB);