How do I navigate between routes without using navigation prop? - react-native

I'm currently trying to call the DrawerOpen route(Example #1) from a screen(Example #3) that is inside a StackNavigator that is rendered as <ProductStack> inside a component(Example #3).
Inside that Stack, I need that a button that can be able to access the DrawerOpen, but the navigation that I have on that page, can't access that DrawerOpen route.
Is there any way to access (and call) any route from any component of my app without depending on the navigation prop?
Here is my drawer component (Example #1):
import React, { Component } from 'react'
import { DrawerNavigator } from 'react-navigation'
import ProductEntryScreen from './../productEntry/screen'
import InvoiceInScreen from './../invoiceIn/screen'
const InvoiceInEntry = { screen: InvoiceInScreen}
const ProductEntry = {
screen: ProductEntryScreen,
navigationOptions: {
title: 'Entrada de produto'
}
}
const Drawer = DrawerNavigator({
ProductEntry,
InvoiceInEntry
})
export default Drawer
Here is the wrapper component (Example #2, also it is imported on #1 as ProductEntryScreen):
import React, { Component } from 'react'
import {
StackNavigator,
} from 'react-navigation'
import InfoScreen from './info/screen'
/* Other imports omitted due to brevity */
import * as ProductEntryActions from './actions'
import { bindActionCreators } from 'redux'
import { connect } from 'react-redux'
const Info = {
screen: InfoScreen,
navigationOptions: {
title: 'Entrada de produto'
}
}
/* Other routes omitted due to brevity */
const ProductStack = StackNavigator({
Info,
/* Other routes omitted due to brevity */
},{
initialRouteName: 'Info',
})
class ProductEntryScreen extends Component {
componentDidMount() {
this.props.getBlocks()
}
render() {
return (
<ProductStack />
)
}
}
const mapDispatchToProps = dispatch => bindActionCreators(ProductEntryActions, dispatch)
export default connect(null, mapDispatchToProps)(ProductEntryScreen)
Now the screen (Example #3):
import React, { Component } from 'react'
/* Imports ommited */
export default class ProductEntryScreen extends Component {
static navigationOptions = ({navigation, screenProps}) => ({
headerLeft: (
<MenuButton
onClick={() => {
// This used to work without wrapping ProductStack in a component
// but I need it to be a component
navigation.navigate('DrawerOpen')
}
/>
),
})
render() {
return (
<View></View>
)
}
}
If I export default ProductStack on #2 without creating a component (also losing that function on componentDidMount), the navigation to DrawerOpen on #3 works like charm. But I need to call that function, and also know a way to call DrawerOpen without having to depend on the navigation prop.

If you're using redux or something similar then you can create an action to route for you. If not you can use NavigationActions:
import { NavigationActions } from 'react-navigation';
const navigateAction = NavigationActions.navigate({
routeName: 'Profile',
params: {},
});
this.props.navigation.dispatch(navigateAction);

Related

Cannot access redux props inside react-navigation v3 tab navigator (getting error this.props.<function_name> is not a function)

I am having trouble connecting the tab navigator (from React-Navigation v3) to the redux provider.
So this is how my react-navigation and redux is configured:
app/
/react-redux provider
/app-container (this is the AppContainer of the main SwitchNavigator)
/welcome-screen
/login-screen
/register-screen
/home-navigator (this is the TabNavigator that is inside the SwitchNavigator)
Home navigator holds the screens to which user is directed to when he logs-in. In the first 3 screends (welcome, login and register) I can access the functions that are "connected" from redux to the screen through standard mapDispatchToProps.
This is the app component:
/**
* Entry point for the app
*/
import React, { Component } from "react";
// redux
import { Provider } from "react-redux";
import { createStore, applyMiddleware } from "redux";
import reduxThunk from "redux-thunk";
import { composeWithDevTools } from "redux-devtools-extension";
import main_app_reducer from "./modules/core/reducers/main_app_reducer";
// create redux store
const create_store = composeWithDevTools(applyMiddleware(reduxThunk))(createStore);
export const store = create_store(main_app_reducer);
// navigation
import AppContainer from "./modules/core/components/AppNavigator";
import { configure_axios } from "./helpers/axios_config";
configure_axios();
class App extends Component {
render() {
return (
<Provider store={store}>
<AppContainer />
</Provider>
);
}
}
export default App;
And then, from there we go to AppContainer:
/**
* this components ensures app navigation so that user can jump from one screen to another
*/
// navigation
import { createSwitchNavigator, createAppContainer } from "react-navigation";
// screens
import WelcomeScreen from "../screens/WelcomeScreen";
import LoginScreen from "../../auth/screens/LoginScreen";
import RegisterScreen from "../../auth/screens/RegisterScreen";
import HomeNavigator from "./HomeNavigator";
const AppSwitchNavigator = createSwitchNavigator({
// for users that are not logged in yet
Welcome: { screen: WelcomeScreen },
Login: { screen: LoginScreen },
Register: { screen: RegisterScreen },
// for logged in users
HomeNavigator: { screen: HomeNavigator },
});
const AppContainer = createAppContainer(AppSwitchNavigator);
export default AppContainer;
All of the code above works perfectly with no errors, the problem occurs inside the HomeNavigator component that you see below.
This is the HomeNavigator component:
import { createBottomTabNavigator } from "react-navigation";
import { HomeScreen } from "../screens/HomeScreen";
import { DashboardScreen } from "../screens/DashboardScreen";
const HomeNavigator = createBottomTabNavigator(
{
Home: { screen: HomeScreen },
Dashboard: { screen: DashboardScreen },
},
{
navigationOptions: ({ navigation }) => {
const { routeName } = navigation.state.routes[navigation.state.index];
return {
headerTitle: routeName,
};
},
},
);
export default HomeNavigator;
NONE of the screens inside the HomeNavigator are connected to Redux altough they are defined THE SAME WAY as the screens inside AppContainer file. For comparison let's see Login screen from AppContainer and Home screen from HomeNavigator:
LoginScreen:
import React, { Component } from "react";
import { View, Text } from "react-native";
import { connect } from "react-redux";
import { get_user_servers } from "../actions/core_actions";
export class LoginScreen extends Component {
componentDidMount() {
this.props.get_user_servers(); // this function works absolutely fine
}
render() {
return (
<View>
<Text> LoginScreen </Text>
</View>
);
}
}
const mapStateToProps = (state) => ({});
const mapDispatchToProps = { get_user_servers };
export default connect(
mapStateToProps,
mapDispatchToProps,
)(LoginScreen);
HomeScreen:
import React, { Component } from "react";
import { View, Text } from "react-native";
import { connect } from "react-redux";
import { get_user_servers } from "../actions/core_actions";
export class HomeScreen extends Component {
componentDidMount() {
this.props.get_user_servers();
// the same function as in LoginScreen but here the function does not work
// I'm getting an error = TypeError: this.props.get_user_servers is not a function (see picture below)
}
render() {
return (
<View>
<Text> HomeScreen </Text>
</View>
);
}
}
const mapStateToProps = (state) => ({});
const mapDispatchToProps = { get_user_servers };
export default connect(
mapStateToProps,
mapDispatchToProps,
)(HomeScreen);
That function (get_user_servers) is defined properly and it works fine in LoginScreen.
thanks everyone who took their time to help me, in the end it was my mistake that I overlooked. If you check out the third code-block from this question you can see that I import my components like this:
import { HomeScreen } from "../screens/HomeScreen";
import { DashboardScreen } from "../screens/DashboardScreen";
Which is wrong, I changed that to:
import HomeScreen from "../screens/HomeScreen";
import DashboardScreen from "../screens/DashboardScreen";
And now everything works fine, thanks again :)
Assuming it's the same function you're importing, please could you try to check your import of get_user_servers function from both screen : LoginScreen and HomeScreen. According to your code it look like LoginScreen ("../../auth/screens/LoginScreen") and HomeScreen ("../screens/HomeScreen") are not in the same path.
As asked above, could check the path of the files, or post it so we can help. Also could you open the remote debugger, and inside the componentWillMount you can put:
console.log(this.props)
to check if the HomeScreen is geting the function inside props.

React Navigation stack navigator doesn't work

I used stackNavigator 2 in one of my projects as follows.
import { StackNavigator } from "react-navigation";
import {
LoginScreen,
TechStackScreen
} from '../screens';
// Public routes
export const PublicRoutes = StackNavigator({
login: { screen: LoginScreen}
});
// Secured routes
export const SecuredRoutes = StackNavigator({
techStack: { screen: TechStackScreen}
});
But when I tried to use it with version 3+ this doesn't work. Can anyone give me sample code of how to use stacknavigation 3+ like this?
You need to use createAppContainer on your root navigator. This was a breaking change introduced in v3
Also StackNavigator has been replaced by createStackNavigator
Here is a simple example of the usage.
App.js
import React, {Component} from 'react';
import AppContainer from './MainNavigation';
export default class App extends React.Component {
render() {
return (
<AppContainer />
)
}
}
MainNavigation.js
import Screen1 from './Screen1';
import Screen2 from './Screen2';
import { createStackNavigator, createAppContainer } from 'react-navigation';
const screens = {
Screen1: {
screen: Screen1
},
Screen2: {
screen: Screen2
}
}
const config = {
headerMode: 'none',
initialRouteName: 'Screen1'
}
const MainNavigator = createStackNavigator(screens,config);
export default createAppContainer(MainNavigator);
You should import and use createStackNavigator, here is the docs https://reactnavigation.org/docs/en/stack-navigator.html
Just need a small change on your code
// Public routes
export const PublicRoutes = createStackNavigator({
login: { screen: LoginScreen}
});
// Secured routes
export const SecuredRoutes = createStackNavigator({
techStack: { screen: TechStackScreen}
});
Well, if you are using StackNavigator, like this:
// Inside "App.js"
render() {
return (
<NavigationContainer >
<Stack.Navigator >
<Stack.Screen name='Details'
component={ Details } />
</Stack.Navigator >
</NavigationContainer >
)
}
You can use the navigation via accessing properties available with each component:
// Inside "Details" Component
export default class Details extends React.Component {
render() {
const { navigate } = this.props.navigation
return (
<Button title='Goto Component' onPress={ () => navigate( 'SomeOtherComponent' ) }/>
)
}
}

Passing props to a component using StackNavigator in React Native

import React, {Component} from 'react'
import { StackNavigator } from 'react-navigation'
import {connect} from 'react-redux'
import {getAllUsers} from '../actions'
import {List, ListItem} from 'react-native-elements'
import { StyleSheet, Text, View, FlatList } from 'react-native'
const UserDetail = () => {
<View>
<Text>User Detail</Text>
</View>
}
const Home = ({ navigation }) => (
<List>
{typeof users === 'string' &&
<FlatList
data={users}
/>
}
</List>
)
const Stack = StackNavigator({
Home: {
screen: Home
},
UserDetail: {
screen: UserDetail
}
})
class MainScreen extends Component {
componentDidMount(){
this.setState({ users : this.props.getAllUsers() })
}
render() {
const users = typeof this.props.decks === 'string'
? Object.values(JSON.parse(this.props.users)) : ''
return(
<Stack />
)
}
}
function mapStateToProps(users) {
return {
users: users,
}
}
function mapDispatchToProps(dispatch) {
return {
getAllUsers: () => dispatch(getAllUsers()),
}
}
export default connect(
mapStateToProps,
mapDispatchToProps
)(MainScreen)
I have two questions:
1) I want to pass the users props from MainScreen component to Home component and later on also to UserDetail component. But I could not see any example on that on React Navigation documentation except for ScreenProps.
2) If I go to UserDetail and let's say it would be a separate component. And let's say it would call another component. How could it go back to Home for example?
I'm using Redux by the way also here and there are some who suggest to do it in Redux but still I could not make it work also. I am fairly new to React Native or React for that matter, but I could not find a definitive answer so far on this above questions.

undefined is not an object this.props

I try to use navigation between screen in my RN app. This is my code :
INDEX.ANDROID.JS :
import React, { Component } from 'react';
import {
AppRegistry,
Text,
View ,
Button
} from 'react-native';
import {StackNavigator} from 'react-navigation';
import Login from './app/components/Todo';
const SimpleApp = StackNavigator({
Login: { screen: Todo },
});
export default class aap extends Component {
static navigationOptions = { title: 'Welcome', };
render() {
const { navigate } = this.props.navigation;
return (
<Button onPress ={() => navigate('Todo') } title="go"/>
);
}
}
AppRegistry.registerComponent('aap', () => aap);
here is the code of the second screen TODO.JS
import React, { Component } from 'react';
import {
AppRegistry,
Text,
View ,
Button
} from 'react-native';
export default class Todo extends Component {
render() {
return (
<View>
<Text>
Here is my text
</Text>
</View>
);
}
}
When running my code i get an error : undefined is not an object this.props.naviagtion.
Any help is appreciated
You are not using StackNavigator correctly.
Like #xght said, you should be registering SimpleApp instead of aap. Also, you should be using aap as the initial route to your StackNavigator SimpleApp.
This should look something like this:
import React, { Component } from 'react';
import {
AppRegistry,
Text,
View ,
Button
} from 'react-native';
import {StackNavigator} from 'react-navigation';
import Todo from './app/components/Todo';
class aap extends Component {
static navigationOptions = { title: 'Welcome', };
render() {
const { navigate } = this.props.navigation;
return (
<Button onPress ={() => navigate('Todo') } title="go"/>
);
}
}
const SimpleApp = StackNavigator({
Login: { screen: aap },
Todo: { screen: Todo },
});
AppRegistry.registerComponent('aap', () => SimpleApp);
You registered the wrong component, so the navigator SimpleApp doesn't pass the navigation prop to your component.
Replace
AppRegistry.registerComponent('aap', () => aap); by:
AppRegistry.registerComponent('aap', () => SimpleApp);
And also you forgot to add your aap component in SimpleApp routes. And your import Login from './app/components/Todo';is wrong: Login is the name of the route in SimpleApp, and Todo is the name of the component, so you need to replace it by import Todo...

React-Navigation with Login Screen

I am trying to use react-navigation to create an initial LOGIN screen that has no tabbar and header, and once the user has been successfully authenticated will navigate to another screen called LISTRECORD which has a tabbar, header and no back button option. Anyone has experience in this and can share?
In summary, what I'm trying to achieve with react-navigation is described below...
Screen 1: Login Screen (No Header & Tabbar)
Authenticated...
Screen 2: LISTRECORD (Header, Tabbar and No Back Button)
The tabbar contains other tabs too for navigation to Screen 3, Screen 4...
Oct 2017
I found this ridiculously confusing, so here is my solution starting from the top down:
I recommend starting a new project and literally just paste all this in and study it after. I commented the code big-time, so if you are stuck on any specific area, maybe the context can help you get back on track.
This post shows how to:
completely setup React Native to run react-navigation
Properly integrate with Redux
Handle Android Back Button
Nest Stack Navigators
Navigate from child to parent navigators
Reset the Navigation Stack
Reset the Navigation Stack while navigating from child to parent (nested)
index.js
import { AppRegistry } from 'react-native'
import App from './src/App'
AppRegistry.registerComponent('yourappname', () => App)
src/App.js (this is the most important file because it brings all the shreds together)
import React, { Component } from 'react'
// this will be used to make your Android hardware Back Button work
import { Platform, BackHandler } from 'react-native'
import { Provider, connect } from 'react-redux'
import { addNavigationHelpers } from 'react-navigation'
// this is your root-most navigation stack that can nest
// as many stacks as you want inside it
import { NavigationStack } from './navigation/nav_reducer'
// this is a plain ol' store
// same as const store = createStore(combinedReducers)
import store from './store'
// this creates a component, and uses magic to bring the navigation stack
// into all your components, and connects it to Redux
// don't mess with this or you won't get
// this.props.navigation.navigate('somewhere') everywhere you want it
// pro tip: that's what addNavigationHelpers() does
// the second half of the critical logic is coming up next in the nav_reducers.js file
class App extends Component {
// when the app is mounted, fire up an event listener for Back Events
// if the event listener returns false, Back will not occur (note that)
// after some testing, this seems to be the best way to make
// back always work and also never close the app
componentWillMount() {
if (Platform.OS !== 'android') return
BackHandler.addEventListener('hardwareBackPress', () => {
const { dispatch } = this.props
dispatch({ type: 'Navigation/BACK' })
return true
})
}
// when the app is closed, remove the event listener
componentWillUnmount() {
if (Platform.OS === 'android') BackHandler.removeEventListener('hardwareBackPress')
}
render() {
// slap the navigation helpers on (critical step)
const { dispatch, nav } = this.props
const navigation = addNavigationHelpers({
dispatch,
state: nav
})
return <NavigationStack navigation={navigation} />
}
}
// nothing crazy here, just mapping Redux state to props for <App />
// then we create your root-level component ready to get all decorated up
const mapStateToProps = ({ nav }) => ({ nav })
const RootNavigationStack = connect(mapStateToProps)(App)
const Root = () => (
<Provider store={store}>
<RootNavigationStack />
</Provider>
)
export default Root
src/navigation/nav_reducer.js
// NavigationActions is super critical
import { NavigationActions, StackNavigator } from 'react-navigation'
// these are literally whatever you want, standard components
// but, they are sitting in the root of the stack
import Splash from '../components/Auth/Splash'
import SignUp from '../components/Auth/SignupForm'
import SignIn from '../components/Auth/LoginForm'
import ForgottenPassword from '../components/Auth/ForgottenPassword'
// this is an example of a nested view, you might see after logging in
import Dashboard from '../components/Dashboard' // index.js file
const WeLoggedIn = StackNavigator({
LandingPad: { // if you don't specify an initial route,
screen: Dashboard // the first-declared one loads first
}
}, {
headerMode: 'none'
initialRouteName: LandingPad // if you had 5 components in this stack,
}) // this one would load when you do
// this.props.navigation.navigate('WeLoggedIn')
// notice we are exporting this one. this turns into <RootNavigationStack />
// in your src/App.js file.
export const NavigationStack = StackNavigator({
Splash: {
screen: Splash
},
Signup: {
screen: SignUp
},
Login: {
screen: SignIn
},
ForgottenPassword: {
screen: ForgottenPassword
},
WeLoggedIn: {
screen: WeLoggedIn // Notice how the screen is a StackNavigator
} // now you understand how it works!
}, {
headerMode: 'none'
})
// this is super critical for everything playing nice with Redux
// did you read the React-Navigation docs and recall when it said
// most people don't hook it up correctly? well, yours is now correct.
// this is translating your state properly into Redux on initialization
const INITIAL_STATE = NavigationStack.router.getStateForAction(NavigationActions.init())
// this is pretty much a standard reducer, but it looks fancy
// all it cares about is "did the navigation stack change?"
// if yes => update the stack
// if no => pass current stack through
export default (state = INITIAL_STATE, action) => {
const nextState = NavigationStack.router.getStateForAction(action, state)
return nextState || state
}
src/store/index.js
// remember when I said this is just a standard store
// this one is a little more advanced to show you
import { createStore, compose, applyMiddleware } from 'redux'
import thunk from 'redux-thunk'
import { persistStore, autoRehydrate } from 'redux-persist'
import { AsyncStorage } from 'react-native'
// this pulls in your combinedReducers
// nav_reducer is one of them
import reducers from '../reducers'
const store = createStore(
reducers,
{},
compose(
applyMiddleware(thunk),
autoRehydrate()
)
)
persistStore(store, { storage: AsyncStorage, whitelist: [] })
// this exports it for App.js
export default store
src/reducers.js
// here is my reducers file. I don't want any confusion
import { combineReducers } from 'redux'
// this is a standard reducer, same as you've been using since kindergarten
// with action types like LOGIN_SUCCESS, LOGIN_FAIL
import loginReducer from './components/Auth/login_reducer'
import navReducer from './navigation/nav_reducer'
export default combineReducers({
auth: loginReducer,
nav: navReducer
})
src/components/Auth/SignUpForm.js
I will show you a sample here. This isn't mine, I just typed it out for you in this rickety StackOverflow editor. Please give me thumbs up if you appreciate it :)
import React, { Component } from 'react'
import { View, Text, TouchableOpacity } from 'react-native
// notice how this.props.navigation just works, no mapStateToProps
// some wizards made this, not me
class SignUp extends Component {
render() {
return (
<View>
<Text>Signup</Text>
<TouchableOpacity onPress={() => this.props.navigation.navigate('Login')}>
<Text>Go to Login View</Text>
</TouchableOpacity>
</View>
)
}
}
export default SignUp
src/components/Auth/LoginForm.js
I'll show you a dumb style one also, with the super dope back button
import React from 'react'
import { View, Text, TouchableOpacity } from 'react-native
// notice how we pass navigation in
const SignIn = ({ navigation }) => {
return (
<View>
<Text>Log in</Text>
<TouchableOpacity onPress={() => navigation.goBack(null)}>
<Text>Go back to Sign up View</Text>
</TouchableOpacity>
</View>
)
}
export default SignIn
src/components/Auth/Splash.js
Here is a splash screen you can play around with. I am using it like a higher-order component:
import React, { Component } from 'react'
import { StyleSheet, View, Image, Text } from 'react-native'
// https://github.com/oblador/react-native-animatable
// this is a library you REALLY should be using
import * as Animatable from 'react-native-animatable'
import { connect } from 'react-redux'
import { initializeApp } from './login_actions'
class Splash extends Component {
constructor(props) {
super(props)
this.state = {}
}
componentWillMount() {
setTimeout(() => this.props.initializeApp(), 2000)
}
componentWillReceiveProps(nextProps) {
// if (!nextProps.authenticated) this.props.navigation.navigate('Login')
if (nextProps.authenticated) this.props.navigation.navigate('WeLoggedIn')
}
render() {
const { container, image, text } = styles
return (
<View style={container}>
<Image
style={image}
source={require('./logo.png')}
/>
<Animatable.Text
style={text}
duration={1500}
animation="rubberBand"
easing="linear"
iterationCount="infinite"
>
Loading...
</Animatable.Text>
<Text>{(this.props.authenticated) ? 'LOGGED IN' : 'NOT LOGGED IN'}</Text>
</View>
)
}
}
const styles = StyleSheet.create({
container: {
flex: 1,
justifyContent: 'center',
alignItems: 'center',
backgroundColor: '#F0F0F0'
},
image: {
height: 110,
resizeMode: 'contain'
},
text: {
marginTop: 50,
fontSize: 15,
color: '#1A1A1A'
}
})
// my LOGIN_SUCCESS action creator flips state.auth.isAuthenticated to true
// so this splash screen just watches it
const mapStateToProps = ({ auth }) => {
return {
authenticated: auth.isAuthenticated
}
}
export default connect(mapStateToProps, { initializeApp })(Splash)
src/components/Auth/login_actions.js
I'm just going to show you initializeApp() so you get some ideas:
import {
INITIALIZE_APP,
CHECK_REMEMBER_ME,
TOGGLE_REMEMBER_ME,
LOGIN_INITIALIZE,
LOGIN_SUCCESS,
LOGIN_FAIL,
LOGOUT
} from './login_types'
//INITIALIZE APP
// this isn't done, no try/catch and LOGIN_FAIL isn't hooked up
// but you get the idea
// if a valid JWT is detected, they will be navigated to WeLoggedIn
export const initializeApp = () => {
return async (dispatch) => {
dispatch({ type: INITIALIZE_APP })
const user = await AsyncStorage.getItem('token')
.catch((error) => dispatch({ type: LOGIN_FAIL, payload: error }))
if (!user) return dispatch({ type: LOGIN_FAIL, payload: 'No Token' })
return dispatch({
type: LOGIN_SUCCESS,
payload: user
})
// navigation.navigate('WeLoggedIn')
// pass navigation into this function if you want
}
}
In other use cases, you may prefer the higher-order component. They work exactly the same as React for web. Stephen Grider's tutorials on Udemy are the best, period.
src/HOC/require_auth.js
import React, { Component } from 'react'
import { connect } from 'react-redux'
export default function (ComposedComponent) {
class Authentication extends Component {
componentWillMount() {
if (!this.props.authenticated) this.props.navigation.navigate('Login')
}
componentWillUpdate(nextProps) {
if (!nextProps.authenticated) this.props.navigation.navigate('Login')
}
render() {
return (
<ComposedComponent {...this.props} />
)
}
}
const mapStateToProps = ({ auth }) => {
return {
authenticated: auth.isAuthenticated
}
}
return connect(mapStateToProps)(Authentication)
}
You use it just like this:
import requireAuth from '../HOC/require_auth'
class RestrictedArea extends Component {
// ... normal view component
}
//map state to props
export default connect(mapStateToProps, actions)(requireAuth(RestrictedArea))
There, that is everything I wish someone told and showed me.
TLDR The App.js, and nav_reducer.js files are absolutely the most important to get right. The rest is old familiar. My examples should accelerate you into a savage productivity machine.
[Edit] Here is my logout action creator. You will find it very useful if you wish to wipe off your navigation stack so the user cannot press Android Hardware Back Button and go back to a screen that requires authentication:
//LOGOUT
export const onLogout = (navigation) => {
return async (dispatch) => {
try {
await AsyncStorage.removeItem('token')
navigation.dispatch({
type: 'Navigation/RESET',
index: 0,
actions: [{ type: 'Navigate', routeName: 'Login' }]
})
return dispatch({ type: LOGOUT })
} catch (errors) {
// pass the user through with no error
// this restores INITIAL_STATE (see login_reducer.js)
return dispatch({ type: LOGOUT })
}
}
}
// login_reducer.js
case LOGOUT: {
return {
...INITIAL_STATE,
isAuthenticated: false,
}
}
[bonus edit] How do I navigate from a child Stack Navigator to a parent Stack Navigator?
If you want to navigate from one of your child Stack Navigators and reset the stack, do this:
Be inside a component adding code, where you have this.props.navigation available
Make a component like <Something />
Pass navigation into it, like this: <Something navigation={this.props.navigation} />
Go into the code for that component
Notice how you have this.props.navigation available inside this child component
Now you're done, just call this.props.navigation.navigate('OtherStackScreen') and you should watch React Native magically go there without problem
But, I want to RESET the whole stack while navigating to a parent stack.
Call an action creator or something like this (starting off from step 6): this.props.handleSubmit(data, this.props.navigation)
Go into the action creator and observe this code that could be there:
actionCreators.js
// we need this to properly go from child to parent navigator while resetting
// if you do the normal reset method from a child navigator:
this.props.navigation.dispatch({
type: 'Navigation/RESET',
index: 0,
actions: [{ type: 'Navigate', routeName: 'SomeRootScreen' }]
})
// you will see an error about big red error message and
// screen must be in your current stack
// don't worry, I got your back. do this
// (remember, this is in the context of an action creator):
import { NavigationActions } from 'react-navigation'
// notice how we passed in this.props.navigation from the component,
// so we can just call it like Dan Abramov mixed with Gandolf
export const handleSubmit = (token, navigation) => async (dispatch) => {
try {
// lets do some operation with the token
await AsyncStorage.setItem('token#E1', token)
// let's dispatch some action that doesn't itself cause navigation
// if you get into trouble, investigate shouldComponentUpdate()
// and make it return false if it detects this action at this moment
dispatch({ type: SOMETHING_COMPLETE })
// heres where it gets 100% crazy and exhilarating
return navigation.dispatch(NavigationActions.reset({
// this says put it on index 0, aka top of stack
index: 0,
// this key: null is 9001% critical, this is what
// actually wipes the stack
key: null,
// this navigates you to some screen that is in the Root Navigation Stack
actions: [NavigationActions.navigate({ routeName: 'SomeRootScreen' })]
}))
} catch (error) {
dispatch({ type: SOMETHING_COMPLETE })
// User should login manually if token fails to save
return navigation.dispatch(NavigationActions.reset({
index: 0,
key: null,
actions: [NavigationActions.navigate({ routeName: 'Login' })]
}))
}
}
I am using this code inside an enterprise-grade React Native app, and it works beautifully.
react-navigation is like functional programming. It is designed to be handled in small "pure navigation" fragments that compose well together. If you employ the strategy described above, you will find yourself creating re-useable navigation logic that you can just paste around as needed.
Although what Manjeet suggests will work, it is not a good navigational structure.
What you should do is take a step back and handle everything on another level.
Top level navigator should be a stack navigator that renders a login screen. Another screen within this top-most navigator should be your app's Main-Navigator. When your login state is satisfied, you reset the main stack to just the Main-Navigator.
The reason for this structure is:
A- What if you need to add on-boarding information before the Login the future?
B- What if you need to navigate outside of the Main-Navigation environment (eg: your main nav is tabs and you want a non-tab view)?
If your top-most navigator is a Stack-Navigator that presents Login screens and other Navigators, then your app's navigation structure can properly scale.
I do not believe the conditional rendering of a login screen or stack navigator, as suggested above, is a good idea....trust me...I've gone down that road.
this is how I achived this functionality.
File 0)index.android.js
'use strict'
import React, { Component } from 'react';
import {
AppRegistry,
StyleSheet,
Text,
View
} from 'react-native';
import Root from 'src/containers/Root'
AppRegistry.registerComponent('Riduk', () => Root);
File 1)my Root.js
class Root extends Component {
constructor(props) {
super(props);
this.state = {
authenticated:false,
isLoading:true,
store: configureStore(() => this.setState({isLoading: false})),
};
}
componentDidMount() {
//you can do check with authentication with fb, gmail and other right here
/* firebase.auth().onAuthStateChanged((user) => {
if (user) {
api.resetRouteStack(dispatch, "UserProfile");
console.log("authenticated", user);
} else {
api.resetRouteStack(dispatch, "Landing");
console.log("authenticated", false);
}
});*/
}
render() {
if (this.state.isLoading) { //checking if the app fully loaded or not, splash screen can be rendered here
return null;
}
return (
<Provider store={this.state.store}>
<App/>
</Provider>
);
}
}
module.exports = Root;
2)App.js
import AppWithNavigationState,{AppBeforeLogin} from './AppNavigator';
class App extends Component{
constructor(props){
super(props);
}
render(){
let {authenticated} = this.props;
if(authenticated){
return <AppWithNavigationState/>;
}
return <AppBeforeLogin/>
}
}
export default connect(state =>({authenticated: state.user.authenticated}))(App);
3)AppNavigator.js
'use strict';
import React, {Component} from 'react';
import { View, BackAndroid, StatusBar,} from 'react-native';
import {
NavigationActions,
addNavigationHelpers,
StackNavigator,
} from 'react-navigation';
import { connect} from 'react-redux';
import LandingScreen from 'src/screens/landingScreen';
import Login from 'src/screens/login'
import SignUp from 'src/screens/signUp'
import ForgotPassword from 'src/screens/forgotPassword'
import UserProfile from 'src/screens/userProfile'
import Drawer from 'src/screens/drawer'
const routesConfig = {
//Splash:{screen:SplashScreen},
Landing:{screen:LandingScreen},
Login: { screen: Login },
SignUp: { screen: SignUp },
ForgotPassword: { screen: ForgotPassword },
UserProfile:{screen:UserProfile},
};
export const AppNavigator = StackNavigator(routesConfig, {initialRouteName:'UserProfile'}); //navigator that will be used after login
export const AppBeforeLogin = StackNavigator(routesConfig); //naviagtor for before login
class AppWithNavigationState extends Component{
constructor(props) {
super(props);
this.handleBackButton = this.handleBackButton.bind(this);
}
componentDidMount() {
BackAndroid.addEventListener('hardwareBackPress', this.handleBackButton);
}
componentWillUnmount() {
BackAndroid.removeEventListener('hardwareBackPress', this.handleBackButton);
}
//added to handle back button functionality on android
handleBackButton() {
const {nav, dispatch} = this.props;
if (nav && nav.routes && nav.routes.length > 1) {
dispatch(NavigationActions.back());
return true;
}
return false;
}
render() {
let {dispatch, nav} = this.props;
return (
<View style={styles.container}>
{(api.isAndroid()) &&
<StatusBar
backgroundColor="#C2185B"
barStyle="light-content"
/>
}
<AppNavigator navigation={addNavigationHelpers({ dispatch, state: nav })}/>
</View>
);
}
};
export default connect(state =>({nav: state.nav}))(AppWithNavigationState);
//module.exports = AppWithNavigationState;
This is my solution based on #parker recommendation:
Create a top level navigator and it should be a stack navigator that
renders a login screen.
Another screen within this top level
navigator should be your app's Main-Navigator.
When your login
state is satisfied, you reset the main stack to just the
Main-Navigator.
This code does the bare minimum to accomplish the above.
Create a new react-native project, then copy the code below into index.ios.js and/or index.android.js to see it working.
import React, { Component } from 'react';
import {
AppRegistry,
Text,
Button
} from 'react-native';
import { StackNavigator, NavigationActions } from 'react-navigation';
const resetAction = NavigationActions.reset({
index: 0,
actions: [
NavigationActions.navigate({ routeName: 'Main' })
]
});
class LoginScreen extends Component {
login() {
this.props.navigation.dispatch(resetAction);
}
render() {
return <Button title='Login' onPress={() => {this.login()}} />;
}
}
class FeedScreen extends Component {
render() {
return <Text>This is my main app screen after login</Text>;
}
}
//Create the navigation
const MainNav = StackNavigator({
Feed: { screen: FeedScreen },
});
const TopLevelNav = StackNavigator({
Login: { screen: LoginScreen },
Main: { screen: MainNav },
}, {
headerMode: 'none',
});
AppRegistry.registerComponent('ReactNav2', () => TopLevelNav);
There is now good documentation on the react-navigation site about the authentication flow.
react-navigation now has a SwitchNavigator which helps desired behavior and switching between navigators. Currently there is not much documentation about it but there is a really good example snack created by the library which shows a simple authentication flow implementation. You can check it here.
SwitchNavigator reference
SwitchNavigator(RouteConfigs, SwitchNavigatorConfig)
Example from docs
const AppStack = StackNavigator({ Home: HomeScreen, Other: OtherScreen });
const AuthStack = StackNavigator({ SignIn: SignInScreen });
export default SwitchNavigator(
{
AuthLoading: AuthLoadingScreen,
App: AppStack,
Auth: AuthStack,
},
{
initialRouteName: 'AuthLoading',
}
);
Its good that you are using react-navigation which has a good support for most of the features your app requires. Here's my advice
1) On Authentication
React-native has this nice feature state variables which when changed views are re-rendered. You can use state variables to understand the "state" (authenticated/visitor) of the users of your app.
Here is a simple implementation where a user logs in by pressing a login button
Entry page where user logs in
import React from 'react';
import Home from './layouts/users/home/Home';
import Login from './layouts/public/login/Login';
class App extends React.Component {
state = {
isLoggedIn: false
}
componentDidMount() {
//Do something here like hide splash screen
}
render(){
if (this.state.isLoggedIn)
return <Home />;
else
return <Login onLoginPress={() => this.setState({isLoggedIn: true})} />;
}
}
export default App;
2) Login with header
Login View
import React from 'react';
//Non react-native import
import { TabNavigator } from 'react-navigation'
import Icon from 'react-native-vector-icons/MaterialIcons'
import LoginStyles from './Style'
//Do all imports found in react-native here
import {
View,
Text,
TextInput,
StyleSheet,
TouchableOpacity,
} from 'react-native';
class Login extends React.Component {
render(){
return (
<View>
<Text>
Login area
</Text>
<TouchableOpacity style={LoginStyles.touchable} onPress={this.props.onLoginPress}>
<Text style={LoginStyles.button}>
Login
</Text>
</TouchableOpacity>
</View>
);
}
}
export default Login;
Remember to remove the style attributes in the login screen and add yours including import, I am leaving them there as it can help you have and idea how you can arrange you react project
However it still works without the styles so you can take them off, clicking the login button will take you to the Home screen, since the state changed and the view has to be re-rendered according to new state
The login screen is without a header as you required
Home screen with tabs
3) Tabs with header
The general method to achieve this functionality it to add a TabNavigator in a StackNavigator.
import React from 'react';
import {
DrawerNavigator,
StackNavigator,
TabNavigator,
TabBarBottom,
NavigationActions
} from 'react-navigation'
import Icon from 'react-native-vector-icons/MaterialIcons'
//Do all imports found in react-native here
import {
View,
Text,
TextInput,
StyleSheet,
TouchableOpacity,
} from 'react-native';
class PicturesTab extends React.Component {
static navigationOptions = {
tabBarLabel: 'Pictures',
// Note: By default the icon is only shown on iOS. Search the showIcon option below.
tabBarIcon: ({ tintColor }) => (<Icon size={30} color={tintColor} name="photo" />),
};
render() { return <Text>Pictures</Text> }
}
class VideosTab extends React.Component {
static navigationOptions = {
tabBarLabel: 'Videos',
tabBarIcon: ({ tintColor }) => (<Icon size={30} color={tintColor} name="videocam" />),
};
render() { return <Text>Videos</Text> }
}
const HomeTabs = TabNavigator({
Pictures: {
screen: PicturesTab,
},
Videos: {
screen: VideosTab,
},
}, {
tabBarComponent: TabBarBottom,
tabBarPosition: 'bottom',
tabBarOptions: {
//Thick teal #094545
activeTintColor: '#094545',
showLabel: false,
activeBackgroundColor: '#094545',
inactiveTintColor: '#bbb',
activeTintColor: '#fff',
}
});
const HomeScreen = StackNavigator({
HomeTabs : { screen: HomeTabs,
navigationOptions: ({ navigation }) => ({
// title :'title',
// headerRight:'put some component here',
// headerLeft:'put some component here',
headerStyle: {
backgroundColor: '#094545'
}
})
},
});
export default HomeScreen;
Disclaimer : Code may return errors as some files may be missing or some typos may be present you should check for details carefully and change where neccesary if you have to copy this code. Any problems can be pasted as comments. Hope this helps someone.
You may also remove the icons in the tab configurations or install the react-native-vector icons which makes tabs great!
Make tabbar and header separate components and only include them in other components. About disabling "BACK", there is a section about "blocking navigation actions" in the docs: https://reactnavigation.org/docs/routers/
You should be able to use that for screen 2.
I needed this, but none of the other solutions worked for me. So here is my solution for a Login with a drawer (the latter accessible only after proper authentication, and each of the screens inside have there own navigation stack). My code has a DrawerNavigator, but the same could be used for a TabNavigator (createBottomTabNavigator).
wrapScreen = stackNavigator =>
createStackNavigator(stackNavigator, {
defaultNavigationOptions: ({ navigation }) => ({
headerStyle: { backgroundColor: "white" },
headerLeft: MenuButton(navigation)
})
});
const DrawerStack = createDrawerNavigator(
{
// Menu Screens
firstSection: wrapScreen({ FirstScreen: FirstScreen }),
secondSection: wrapScreen({
SecondHomeScreen: SecondHomeScreen,
SecondOptionScreen: SecondOptionScreen
}),
settingSection: wrapScreen({ SettingScreen: SettingScreen }),
aboutSection: wrapScreen({ AboutScreen: AboutScreen })
},
{
initialRouteName: "firstSection",
gesturesEnabled: false,
drawerPosition: "left",
contentComponent: DrawerContainer
}
);
const PrimaryNav = createSwitchNavigator(
{
loginStack: LoginScreen,
appStack: DrawerStack
},
{ initialRouteName: "loginStack" }
);
export default createAppContainer(PrimaryNav);
If you want no back button from your LIST page to LOGIN page, you can do this:
static navigationOptions = {
title: 'YOUR TITLE',
headerLeft : null,
};