I want when user want to go back without completing the test, they will see an modal box and when they pressed yes they can go back but why when they yes nothing happen?

This is my screen code

import React, { useState, useEffect, useRef, useCallback } from 'react';
import { View, Text, TouchableOpacity, Modal, BackHandler, StyleSheet } from 'react-native';
import Icon from 'react-native-vector-icons/Ionicons';
import AudioRecorderPlayer from 'react-native-audio-recorder-player';
import RNFS from 'react-native-fs';
import axios from 'axios';
import { useFocusEffect, CommonActions } from '@react-navigation/native';

const IeltsSpeakingTestScreen = ({ navigation }) => {
  const [part1Completed, setPart1Completed] = useState(false);
  const [part2Completed, setPart2Completed] = useState(false);
  const [part3Completed, setPart3Completed] = useState(false);
  const [recording, setRecording] = useState(false);
  const [viewCueCard, setViewCueCard] = useState(false);
  const [cueCardViewing, setCueCardViewing] = useState(false);
  const [timeRemaining, setTimeRemaining] = useState(120);
  const [showWarningModal, setShowWarningModal] = useState(false);
  const [showCompletionModal, setShowCompletionModal] = useState(false);
  const audioRecorderPlayer = useRef(new AudioRecorderPlayer()).current;
  const intervalRef = useRef(null);

  const handleBackButtonPress = useCallback(() => {
    if (!part3Completed) {
      setShowWarningModal(true);
      return true;
    }
    return false;
  }, [part3Completed]);

  useFocusEffect(
    useCallback(() => {
      BackHandler.addEventListener('hardwareBackPress', handleBackButtonPress);

      const beforeRemoveListener = navigation.addListener('beforeRemove', (e) => {
        if (!part3Completed) {
          e.preventDefault();
          setShowWarningModal(true);
        }
      });

      return () => {
        BackHandler.removeEventListener('hardwareBackPress', handleBackButtonPress);
        beforeRemoveListener();
      };
    }, [handleBackButtonPress, navigation])
  );

  useEffect(() => {
    if ((recording || cueCardViewing) && timeRemaining > 0) {
      intervalRef.current = setInterval(() => {
        setTimeRemaining((prevTime) => prevTime - 1);
      }, 1000);
    } else if (timeRemaining === 0) {
      if (cueCardViewing) {
        console.log("Cue card viewing time is up");
        setCueCardViewing(false);
        setTimeRemaining(120); // Prepare for part 2 response time
      } else {
        console.log("Timer is up, stopping recording automatically");
        stopRecording();
      }
    }
    return () => clearInterval(intervalRef.current);
  }, [recording, cueCardViewing, timeRemaining]);

  const startRecording = async (part) => {
    console.log(`Starting recording for Part ${part}`);
    setRecording(true);
    const path = `${RNFS.DocumentDirectoryPath}/part${part}.mp4`;
    await audioRecorderPlayer.startRecorder(path);
  };

  const stopRecording = async () => {
    console.log("Stopping recording");
    setRecording(false);
    if (!part1Completed) {
      setPart1Completed(true);
      setTimeRemaining(60); // Prepare for cue card viewing time
    } else if (!part2Completed) {
      setPart2Completed(true);
      setTimeRemaining(120); // Prepare for part 3 response time
    } else if (!part3Completed) {
      setPart3Completed(true);
    }
    clearInterval(intervalRef.current);
    await audioRecorderPlayer.stopRecorder();
  };

  const handleRecordingPress = (part) => {
    if (recording) {
      stopRecording();
    } else {
      startRecording(part);
    }
  };

  const handleViewCueCardPress = () => {
    console.log("Viewing cue card");
    setViewCueCard(true);
    setCueCardViewing(true);
    setTimeRemaining(60); // Set timer for viewing cue card
  };

  const handleCompletedTest = async () => {
    const parts = [1, 2, 3];
    const files = parts.map((part) => `${RNFS.DocumentDirectoryPath}/part${part}.mp4`);
    
    const formData = new FormData();
    files.forEach((file, index) => {
      formData.append(`audio${index + 1}`, {
        uri: `file://${file}`,
        name: `part${index + 1}.mp4`,
        type: 'audio/mp4',
      });
    });

    try {
      await axios.post('YOUR_SERVER_URL', formData, {
        headers: {
          'Content-Type': 'multipart/form-data',
        },
      });
      setShowCompletionModal(true);
    } catch (error) {
      console.error('Error uploading files:', error);
      alert('Failed to upload files');
    }
  };

  const handleYesPress = () => {
    setShowWarningModal(false);
    navigation.dispatch(CommonActions.goBack());
  };

  const handleOkPress = () => {
    setShowCompletionModal(false);
    navigation.navigate('Dashboard'); // Adjust 'Dashboard' to your actual dashboard screen name
  };

  return (
    <View style={styles.container}>
      <View style={styles.instructionBox}>
        <Text style={styles.instructionText}>
          Please follow the instructions carefully before starting the test.
        </Text>
      </View>

      {part1Completed && !part2Completed && (
        <View style={styles.completedBox}>
          <Text style={styles.completedText}>Part 1 completed.</Text>
        </View>
      )}

      {part1Completed && part2Completed && !part3Completed && (
        <>
          <View style={styles.completedBox}>
            <Text style={styles.completedText}>Part 1 completed.</Text>
          </View>
          <View style={styles.completedBox}>
            <Text style={styles.completedText}>Part 2 completed.</Text>
          </View>
        </>
      )}

      {part1Completed && part2Completed && part3Completed && (
        <>
          <View style={styles.completedBox}>
            <Text style={styles.completedText}>Part 1 completed.</Text>
          </View>
          <View style={styles.completedBox}>
            <Text style={styles.completedText}>Part 2 completed.</Text>
          </View>
          <View style={styles.completedBox}>
            <Text style={styles.completedText}>Part 3 completed.</Text>
          </View>
          <TouchableOpacity
            style={styles.completedButton}
            onPress={handleCompletedTest}
          >
            <Text style={styles.completedButtonText}>Completed Test</Text>
          </TouchableOpacity>
        </>
      )}

      {!part1Completed ? (
        <View style={styles.questionBox}>
          <View style={styles.header}>
            <Text style={styles.partText}>Part 1</Text>
            <Text style={styles.timeRemainingText}>
              Time Remaining: {`${Math.floor(timeRemaining / 60)
                .toString()
                .padStart(2, '0')}:${(timeRemaining % 60)
                .toString()
                .padStart(2, '0')}`}
            </Text>
          </View>
          <View style={styles.questionContent}>
            <Text style={styles.questionText}>What is your full name?</Text>
          </View>
          <TouchableOpacity
            style={styles.recordButton}
            onPress={() => handleRecordingPress(1)}
          >
            <Icon name="mic" size={20} color={recording ? 'red' : '#fff'} />
            <Text
              style={[
                styles.recordButtonText,
                { color: recording ? 'red' : '#fff' },
              ]}
            >
              {recording ? 'Stop Recording' : 'Start Recording'}
            </Text>
          </TouchableOpacity>
        </View>
      ) : !part2Completed ? (
        <View style={styles.questionBox}>
          <View style={styles.header}>
            <Text style={styles.partText}>Part 2 (Cue Card)</Text>
            <Text style={styles.timeRemainingText}>
              Time Remaining: {`${Math.floor(timeRemaining / 60)
                .toString()
                .padStart(2, '0')}:${(timeRemaining % 60)
                .toString()
                .padStart(2, '0')}`}
            </Text>
          </View>
          {!viewCueCard ? (
            <>
              <View style={styles.questionContent}>
                <Text style={styles.questionText}>
                  Keep a notebook and pencil to take notes, because you won't be able to see the cue card again when the timer is up.
                </Text>
              </View>
              <TouchableOpacity
                style={styles.recordButton}
                onPress={handleViewCueCardPress}
              >
                <Text style={styles.recordButtonText}>View Cue Card</Text>
              </TouchableOpacity>
            </>
          ) : cueCardViewing ? (
            <View style={styles.questionContent}>
              <Text style={styles.questionText}>
                Describe a time when you received good news.
              </Text>
            </View>
          ) : (
            <>
              <View style={styles.questionContent}>
                <Text style={styles.questionText}>
                  Now you should talk about the cue card topic for 1-2 minutes.
                </Text>
              </View>
              <TouchableOpacity
                style={styles.recordButton}
                onPress={() => handleRecordingPress(2)}
              >
                <Icon name="mic" size={20} color={recording ? 'red' : '#fff'} />
                <Text
                  style={[
                    styles.recordButtonText,
                    { color: recording ? 'red' : '#fff' },
                  ]}
                >
                  {recording ? 'Stop Recording' : 'Start Recording'}
                </Text>
              </TouchableOpacity>
            </>
          )}
        </View>
      ) : !part3Completed ? (
        <View style={styles.questionBox}>
          <View style={styles.header}>
            <Text style={styles.partText}>Part 3</Text>
            <Text style={styles.timeRemainingText}>
              Time Remaining: {`${Math.floor(timeRemaining / 60)
                .toString()
                .padStart(2, '0')}:${(timeRemaining % 60)
                .toString()
                .padStart(2, '0')}`}
            </Text>
          </View>
          <View style={styles.questionContent}>
            <Text style={styles.questionText}>What are your hobbies and interests?</Text>
          </View>
          <TouchableOpacity
            style={styles.recordButton}
            onPress={() => handleRecordingPress(3)}
          >
            <Icon name="mic" size={20} color={recording ? 'red' : '#fff'} />
            <Text
              style={[
                styles.recordButtonText,
                { color: recording ? 'red' : '#fff' },
              ]}
            >
              {recording ? 'Stop Recording' : 'Start Recording'}
            </Text>
          </TouchableOpacity>
        </View>
      ) : null}

      <Modal
        visible={showWarningModal}
        transparent={true}
        animationType="slide"
        onRequestClose={() => setShowWarningModal(false)}
      >
        <View style={styles.modalContainer}>
          <View style={styles.modalContent}>
            <Text style={styles.modalText}>
              You did not complete the test, if you go back now, you cannot take this test again. Are you sure you want to go back?
            </Text>
            <View style={styles.modalButtonContainer}>
              <TouchableOpacity
                style={styles.modalButton}
                onPress={handleYesPress}
              >
                <Text style={styles.modalButtonText}>Yes</Text>
              </TouchableOpacity>
              <TouchableOpacity
                style={styles.modalButton}
                onPress={() => setShowWarningModal(false)}
              >
                <Text style={styles.modalButtonText}>Cancel</Text>
              </TouchableOpacity>
            </View>
          </View>
        </View>
      </Modal>

      <Modal
        visible={showCompletionModal}
        transparent={true}
        animationType="slide"
        onRequestClose={() => setShowCompletionModal(false)}
      >
        <View style={styles.modalContainer}>
          <View style={styles.modalContent}>
            <Text style={styles.modalText}>
              Thank you for completing the test, you will get the result within 24 hours.
            </Text>
            <TouchableOpacity
              style={styles.modalButton}
              onPress={handleOkPress}
            >
              <Text style={styles.modalButtonText}>Ok</Text>
            </TouchableOpacity>
          </View>
        </View>
      </Modal>
    </View>
  );
};

const styles = StyleSheet.create({
  container: {
    flex: 1,
    backgroundColor: '#F4F7FC',
    padding: 20,
  },
  instructionBox: {
    backgroundColor: '#fff',
    borderRadius: 10,
    padding: 20,
    marginBottom: 20,
  },
  instructionText: {
    color: '#000',
    fontFamily: 'Poppins-Regular',
    textAlign: 'center',
  },
  questionBox: {
    backgroundColor: '#fff',
    borderRadius: 10,
    marginBottom: 20,
  },
  header: {
    flexDirection: 'row',
    justifyContent: 'space-between',
    alignItems: 'center',
    backgroundColor: '#30CEA8',
    padding: 10,
    borderTopLeftRadius: 10,
    borderTopRightRadius: 10,
  },
  partText: {
    color: '#fff',
  },
  timeRemainingText: {
    color: '#7209B7',
  },
  questionContent: {
    paddingVertical: 20,
  },
  questionText: {
    color: '#000',
    fontFamily: 'Poppins-Regular',
    textAlign: 'center',
  },
  recordButton: {
    flexDirection: 'row',
    justifyContent: 'center',
    alignItems: 'center',
    backgroundColor: '#30CEA8',
    borderRadius: 10,
    padding: 10,
  },
  recordButtonText: {
    marginLeft: 10,
    fontFamily: 'Poppins-Regular',
  },
  completedBox: {
    backgroundColor: '#fff',
    borderRadius: 10,
    padding: 20,
    marginBottom: 20,
  },
  completedText: {
    fontFamily: 'Poppins-Regular',
    fontSize: 16,
    fontWeight: 'bold',
    color: '#30CEA8',
    textAlign: 'center',
  },
  completedButton: {
    backgroundColor: '#30CEA8',
    borderRadius: 10,
    padding: 15,
    alignItems: 'center',
    marginTop: 20,
  },
  completedButtonText: {
    color: '#fff',
    fontFamily: 'Poppins-Regular',
    fontSize: 16,
  },
  modalContainer: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
    backgroundColor: 'rgba(0, 0, 0, 0.5)',
  },
  modalContent: {
    width: '80%',
    backgroundColor: '#fff',
    borderRadius: 10,
    padding: 20,
    alignItems: 'center',
  },
  modalText: {
    fontFamily: 'Poppins-Regular',
    fontSize: 16,
    color: '#000',
    textAlign: 'center',
    marginBottom: 20,
  },
  modalButtonContainer: {
    flexDirection: 'row',
    justifyContent: 'space-between',
    width: '100%',
  },
  modalButton: {
    flex: 1,
    backgroundColor: '#30CEA8',
    padding: 10,
    borderRadius: 10,
    alignItems: 'center',
    marginHorizontal: 5,
  },
  modalButtonText: {
    color: '#fff',
    fontFamily: 'Poppins-Regular',
  },
});

export default IeltsSpeakingTestScreen;

And this is my App.tsx code

import React, { useEffect, useState } from 'react';
import { NavigationContainer } from '@react-navigation/native';
import { createNativeStackNavigator } from '@react-navigation/native-stack';
import { createBottomTabNavigator } from '@react-navigation/bottom-tabs';
import AsyncStorage from '@react-native-async-storage/async-storage';
import messaging from '@react-native-firebase/messaging';
import { PermissionsAndroid, Platform } from 'react-native';
import Icon from 'react-native-vector-icons/Ionicons';
import WelcomeScreen from './src/screens/WelcomeScreen';
import LoginScreen from './src/screens/LoginScreen';
import SignupScreen from './src/screens/SignupScreen';
import DashboardScreen from './src/screens/DashboardScreen';
import GrammarTopicsScreen from './src/screens/GrammarTopicsScreen';
import GrammarPracticeScreen from './src/screens/GrammarPracticeScreen';
import LeaderboardScreen from './src/screens/LeaderboardScreen';
import ProfileScreen from './src/screens/ProfileScreen';
import VocabularyScreen from './src/screens/VocabularyScreen';
import PracticePronunciationScreen from './src/screens/PracticePronunciationScreen';
import ListeningLabsScreen from './src/screens/ListeningLabsScreen';
import ListeningLabsTestsScreen from './src/screens/ListeningLabsTestsScreen';
import ListeningLabsPracticeScreen from './src/screens/ListeningLabsPracticeScreen';
import ReadingComprehensionScreen from './src/screens/ReadingComprehension/ReadingComprehensionScreen';
import ReadingPassagesScreen from './src/screens/ReadingComprehension/ReadingPassagesScreen';
import ReadingPracticeScreen from './src/screens/ReadingComprehension/ReadingPracticeScreen';
import SpeakingTestsScreen from './src/screens/SpeakingTest/SpeakingTestsScreen';
import SpeakingQuestionScreen from './src/screens/SpeakingTest/SpeakingQuestionScreen';
import WritingTestsScreen from './src/screens/WritingTest/WritingTestsScreen';
import WritingTestPracticeScreen from './src/screens/WritingTest/WritingTestPracticeScreen';
import ListeningPracticeScreen from './src/screens/ListeningTest/ListeningPracticeScreen';
import ListeningTestsScreen from './src/screens/ListeningTest/ListeningTestsScreen';
import ReadingTestsScreen from './src/screens/ReadingTest/ReadingTestsScreen';
import ReadingTestPracticeScreen from './src/screens/ReadingTest/ReadingTestPracticeScreen';
import ResultsScreen from './src/screens/Results/ResultsScreen';
import SpeakingTestResult from './src/screens/Results/SpeakingTestResult';
import ReadingTestResult from './src/screens/Results/ReadingTestResult';
import WritingTestResult from './src/screens/Results/WritingTestResult';
import ListeningTestResult from './src/screens/Results/ListeningTestResult';
import CommunityScreen from './src/screens/CommunityScreen';
import NotificationScreen from './src/screens/NotificationScreen';
import ForgotPasswordScreen from './src/screens/Login/ForgotPasswordScreen';
import VerifyOTPScreen from './src/screens/Login/VerifyOTPScreen';
import ResetPasswordScreen from './src/screens/Login/ResetPasswordScreen';
import { registerBackgroundHandler } from './src/NotificationService';
import { getFocusedRouteNameFromRoute } from '@react-navigation/native';

const Stack = createNativeStackNavigator();
const Tab = createBottomTabNavigator();

const HomeStack = () => (
  <Stack.Navigator initialRouteName="Dashboard">
    <Stack.Screen name="Dashboard" component={DashboardScreen} options={{ headerShown: false }} />
    <Stack.Screen name="GrammarTopics" component={GrammarTopicsScreen} options={{ title: 'Grammar Topics' }} />
    <Stack.Screen name="GrammarPractice" component={GrammarPracticeScreen} options={{ title: 'Grammar Practice' }} />
    <Stack.Screen name="Vocabulary" component={VocabularyScreen} options={{ title: 'Vocabulary' }} />
    <Stack.Screen name="PracticePronunciation" component={PracticePronunciationScreen} options={{ title: 'Practice Pronunciation' }} />
    <Stack.Screen name="ListeningLabs" component={ListeningLabsScreen} options={{ title: 'Listening Labs' }} />
    <Stack.Screen name="ListeningLabsTests" component={ListeningLabsTestsScreen} options={{ title: 'Listening Labs Tests' }} />
    <Stack.Screen name="ListeningLabsPractice" component={ListeningLabsPracticeScreen} options={{ title: 'Listening Labs Practice' }} />
    <Stack.Screen name="ReadingComprehension" component={ReadingComprehensionScreen} options={{ title: 'Reading Comprehension' }} />
    <Stack.Screen name="ReadingPassages" component={ReadingPassagesScreen} options={{ title: 'Reading Passages' }} />
    <Stack.Screen name="ReadingPractice" component={ReadingPracticeScreen} options={{ title: 'Reading Practice' }} />
    <Stack.Screen name="SpeakingTests" component={SpeakingTestsScreen} options={{ title: 'Speaking Tests' }} />
    <Stack.Screen name="SpeakingQuestion" component={SpeakingQuestionScreen} options={{ title: 'Speaking Practice' }} />
    <Stack.Screen name="WritingTests" component={WritingTestsScreen} options={{ title: 'Writing Tests' }} />
    <Stack.Screen name="WritingTestPractice" component={WritingTestPracticeScreen} options={{ title: 'Writing Test Practice' }} />
    <Stack.Screen name="ListeningTests" component={ListeningTestsScreen} options={{ title: 'Listening Tests' }} />
    <Stack.Screen name="ListeningPractice" component={ListeningPracticeScreen} options={{ title: 'Listening Practice' }} />
    <Stack.Screen name="ReadingTests" component={ReadingTestsScreen} options={{ title: 'Reading Tests' }} />
    <Stack.Screen name="ReadingTestPractice" component={ReadingTestPracticeScreen} options={{ title: 'Reading Test Practice' }} />
    <Stack.Screen name="SpeakingTestResult" component={SpeakingTestResult} options={{ title: 'Speaking Test Result' }} />
    <Stack.Screen name="ReadingTestResult" component={ReadingTestResult} options={{ title: 'Reading Test Result' }} />
    <Stack.Screen name="WritingTestResult" component={WritingTestResult} options={{ title: 'Writing Test Result' }} />
    <Stack.Screen name="ListeningTestResult" component={ListeningTestResult} options={{ title: 'Listening Test Result' }} />
    <Stack.Screen name="Community" component={CommunityScreen} options={{ title: 'Community' }} />
    <Stack.Screen name="Notification" component={NotificationScreen} options={{ title: 'Notification' }} />
  </Stack.Navigator>
);

const MainTabs = () => (
  <Tab.Navigator
    screenOptions={({ route }) => ({
      tabBarIcon: ({ color, size }) => {
        let iconName;

        if (route.name === 'Home') {
          iconName = 'home-outline';
        } else if (route.name === 'Leaderboard') {
          iconName = 'stats-chart-outline';
        } else if (route.name === 'Profile') {
          iconName = 'person-outline';
        } else if (route.name === 'Results') {
          iconName = 'copy-outline';
        }

        return <Icon name={iconName} size={size} color={color} />;
      },
      tabBarActiveTintColor: '#30CEA8',
      tabBarInactiveTintColor: 'gray',
      tabBarStyle: { display: 'flex' },
    })}
  >
    <Tab.Screen 
      name="Home" 
      component={HomeStack} 
      options={({ route }) => ({
        headerShown: false,
        tabBarStyle: ((route) => {
          const routeName = getFocusedRouteNameFromRoute(route) ?? "";
          if (routeName === "Community") {
            return { display: 'none' };
          }
          return { display: 'flex' };
        })(route),
      })} 
    />
    <Tab.Screen name="Leaderboard" component={LeaderboardScreen} options={{ title: 'Leaderboard' }} />
    <Tab.Screen name="Profile" component={ProfileScreen} options={{ title: 'Edit Profile' }} />
    <Tab.Screen name="Results" component={ResultsScreen} options={{ title: 'Results' }} />
  </Tab.Navigator>
);


const App = () => {
  const [isAuthenticated, setIsAuthenticated] = useState(false);
  const [initializing, setInitializing] = useState(true);
  const [notificationTarget, setNotificationTarget] = useState(null);

  useEffect(() => {
    const checkAuthStatus = async () => {
      const token = await AsyncStorage.getItem('authToken');
      setIsAuthenticated(!!token);
      setInitializing(false);
    };

    const requestUserPermission = async () => {
      const authStatus = await messaging().requestPermission();
      const enabled =
        authStatus === messaging.AuthorizationStatus.AUTHORIZED ||
        authStatus === messaging.AuthorizationStatus.PROVISIONAL;

      if (enabled) {
        console.log('Authorization status:', authStatus);
      }
    };

    const requestAndroidPermissions = async () => {
      if (Platform.OS === 'android' && Platform.Version >= 33) {
        await PermissionsAndroid.request(PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS);
      }
    };

    checkAuthStatus();
    requestUserPermission();
    requestAndroidPermissions();

    messaging().onNotificationOpenedApp(remoteMessage => {
      console.log('Notification caused app to open from background state:', remoteMessage.notification);
      handleNotificationClick();
    });

    messaging()
      .getInitialNotification()
      .then(remoteMessage => {
        if (remoteMessage) {
          console.log('Notification caused app to open from quit state:', remoteMessage.notification);
          handleNotificationClick();
        }
      });

    registerBackgroundHandler();
  }, []);

  const handleNotificationClick = async () => {
    const token = await AsyncStorage.getItem('authToken');
    if (token) {
      setIsAuthenticated(true);
      setNotificationTarget('Notification'); // Set the target screen
    } else {
      setIsAuthenticated(false);
      setNotificationTarget('Notification'); // Set the target screen
    }
  };

  if (initializing) {
    return null; // or a loading spinner
  }

  return (
    <NavigationContainer>
      <Stack.Navigator initialRouteName={isAuthenticated ? "Main" : "Welcome"}>
        <Stack.Screen name="Welcome" component={WelcomeScreen} options={{ headerShown: false }} />
        <Stack.Screen name="Login" options={{ headerShown: false}}>
          {props => <LoginScreen {...props} notificationTarget={notificationTarget} />}
        </Stack.Screen>
        <Stack.Screen name="Signup" component={SignupScreen} options={{ title: 'Signup' }} />
        <Stack.Screen name="ForgotPassword" component={ForgotPasswordScreen} options={{ title: 'Forgot Password', headerShown: false }} />
        <Stack.Screen name="VerifyOTP" component={VerifyOTPScreen} options={{ title: 'Verify OTP', headerShown: false }} />
        <Stack.Screen name="ResetPassword" component={ResetPasswordScreen} options={{ title: 'Reset Password', headerShown: false }} />
        <Stack.Screen name="Main" component={MainTabs} options={{ headerShown: false }} />
      </Stack.Navigator>
    </NavigationContainer>
  );
};

export default App;

I’m very new in react native so I don’t understand what is the issue. Please help me. Thanks in advance

I want user can go back when they pressed yes from the modal