Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

// src/screens/ChatScreen.tsx import React, { useState, useEffect, useRef, useCallback,…

  1. User

    // src/screens/ChatScreen.tsx

    import React, { useState, useEffect, useRef, useCallback, useContext } from 'react'; import { View, FlatList, Image, TouchableOpacity, TextInput, StyleSheet, KeyboardAvoidingView, Platform, Dimensions, ScrollView, Alert, ActivityIndicator, } from 'react-native'; import { useNavigation, useRoute } from '@react-navigation/native'; import LottieView from 'lottie-react-native'; import Markdown from 'react-native-markdown-display'; import { HistoricalFigure, Message } from '../types/types'; import { fetchAIResponse } from '../services/openaiService'; import uuid from 'react-native-uuid'; import MessageItem from '../components/MessageItem'; import { Ionicons } from '@expo/vector-icons'; import CustomText from '../components/CustomText'; import * as Clipboard from 'expo-clipboard'; import { ChatContext } from '../context/ChatContext'; import AsyncStorage from '@react-native-async-storage/async-storage';

    interface RouteParams { chatId: string; figure: HistoricalFigure; }

    interface APIMessage { role: 'system' | 'user' | 'assistant'; content: string; }

    const { width, height } = Dimensions.get('window');

    const ChatScreen = () => { const navigation = useNavigation(); const route = useRoute(); const { chatId, figure } = route.params as RouteParams; const { updateChat, addChat, chats } = useContext(ChatContext); const [messages, setMessages] = useState<Message[]>([]); const [inputText, setInputText] = useState(''); const [isTyping, setIsTyping] = useState(false); const [followUpQuestions, setFollowUpQuestions] = useState<string[]>([]); const [isLoading, setIsLoading] = useState(false); const flatListRef = useRef(null); const isInitialLoad = useRef(false); // Added ref to track initial load

    // Fallback follow-up questions const sampleFollowUpQuestions = [ 'Bu konuda daha fazla detay öğrenmek ister misiniz?', 'Başka ne hakkında konuşmak istersiniz?', 'Farklı bir perspektif mi istiyorsunuz?', ];

    useEffect(() => { if (isInitialLoad.current) return; // Prevent re-running on updates

    const loadMessages = async () => {
      try {
        setIsLoading(true);
        setMessages([]);
        setFollowUpQuestions([]);
        setIsTyping(false);
    
        const messagesData = await AsyncStorage.getItem(`chat_${chatId}_messages`);
        let msgs: Message[] = messagesData ? JSON.parse(messagesData) : [];
    
        if (msgs.length === 0) {
          const conversationStarters = [
            'Merhaba! Bugün nasıl yardımcı olabilirim?',
            `${figure.name} hakkında ne öğrenmek istersiniz?`,
            `${figure.name} ile ilgili herhangi bir sorunuz var mı?`,
          ];
    
          const starterMessages: Message[] = conversationStarters.map((starter) => ({
            id: uuid.v4().toString(),
            text: starter,
            isUser: false,
            timestamp: Date.now(),
          }));
    
          msgs = starterMessages;
    
          // Initialize the chat in context with all starter messages
          const newChat = {
            id: chatId,
            figure: figure, // Assuming `figure` includes necessary details
            createdAt: Date.now(),
          };
          await addChat(newChat, starterMessages); // Add all starter messages
        }
    
        // Ensure all message IDs are unique (optional defensive check)
        const uniqueMsgs = Array.from(new Map(msgs.map(item => [item.id, item])).values());
    
        setMessages(uniqueMsgs);
        setIsLoading(false);
    
        // Scroll to latest message
        setTimeout(() => {
          flatListRef.current?.scrollToOffset({ animated: true, offset: 0 });
        }, 100);
      } catch (error) {
        console.error('Error loading messages:', error);
        setIsLoading(false);
      }
    };
    
    loadMessages();
    isInitialLoad.current = true; // Mark as loaded
    

    }, [chatId, figure.name, addChat, figure]);

    const saveMessages = useCallback(async (updatedMessages: Message[]) => { try { await AsyncStorage.setItem(chat_${chatId}_messages, JSON.stringify(updatedMessages)); } catch (error) { console.error('Error saving messages:', error); } }, [chatId]);

    const generateFollowUpQuestions = useCallback(async (aiResponse: string) => { try { const prompt = Yapay zekanın aşağıdaki yanıtına dayanarak sadece üç tane takip sorusu oluştur. Sadece sorular olmalı, açıklayıcı metin veya ek bilgiler eklemeyin.\n\nYanıt: "${aiResponse}"\n\nTakip Soruları:; const aiMessages: APIMessage[] = [ { role: 'system', content: 'Sen, yardımsever ve bilgilendirici bir yapay zeka asistanısın.', }, { role: 'user', content: prompt, }, ];

      const followUpResponse = await fetchAIResponse(aiMessages);
      const rawQuestions = followUpResponse
        .split('\n')
        .map((q) => q.trim())
        .filter((q) => q.length > 0)
        .slice(0, 3);
    
      const cleanQuestion = (question: string) => {
        return question.replace(/^\d+\.\s*/, '');
      };
    
      const cleanedQuestions = rawQuestions.map(cleanQuestion);
    
      if (cleanedQuestions.length < 3) {
        setFollowUpQuestions([
          ...cleanedQuestions,
          ...sampleFollowUpQuestions.slice(0, 3 - cleanedQuestions.length),
        ]);
      } else {
        setFollowUpQuestions(cleanedQuestions);
      }
    } catch (error) {
      console.error('Error generating follow-up questions:', error);
      setFollowUpQuestions(sampleFollowUpQuestions);
    }
    

    }, []);

    const sendMessage = useCallback( async (text?: string) => { const messageText = text !== undefined ? text : inputText; if (messageText.trim() === '') return;

      const userMessage: Message = {
        id: uuid.v4().toString(),
        text: messageText,
        isUser: true,
        timestamp: Date.now(),
      };
    
      const updatedMessages = [userMessage, ...messages];
      setMessages(updatedMessages);
      setInputText('');
      setIsTyping(true);
      setFollowUpQuestions([]); // Clear follow-up questions
    
      await saveMessages(updatedMessages);
    
      // Update the chat's last message and timestamp via context
      await updateChat(chatId, userMessage);
    
      const apiMessages: APIMessage[] = [
        {
          role: 'system',
          content: figure.systemPrompt,
        },
        ...updatedMessages
          .slice()
          .reverse()
          .map((msg) => ({
            role: msg.isUser ? 'user' : 'assistant',
            content: msg.text,
          })),
      ];
    
      console.log('==== Sending Messages to AI ====');
      apiMessages.forEach((msg, index) => {
        console.log(`Message ${index + 1}: [${msg.role}] ${msg.content}`);
      });
      console.log('===============================');
    
      try {
        const aiResponse = await fetchAIResponse(apiMessages);
    
        const aiMessage: Message = {
          id: uuid.v4().toString(),
          text: aiResponse,
          isUser: false,
          timestamp: Date.now(),
        };
    
        const newMessages = [aiMessage, ...updatedMessages];
        setMessages(newMessages);
        await saveMessages(newMessages);
    
        // Update chat's last message and timestamp via context
        await updateChat(chatId, aiMessage);
    
        await generateFollowUpQuestions(aiResponse);
      } catch (error) {
        console.error('Error fetching AI response:', error);
        Alert.alert('Hata', 'Yapay zeka yanıtı alınırken bir hata oluştu. Lütfen daha sonra tekrar deneyin.');
      } finally {
        setIsTyping(false);
        // Scroll to the latest message
        flatListRef.current?.scrollToOffset({ animated: true, offset: 0 });
      }
    },
    [
      inputText,
      messages,
      figure.systemPrompt,
      saveMessages,
      generateFollowUpQuestions,
      updateChat,
      chatId,
    ]
    

    );

    const handleFollowUpPress = (question: string) => { sendMessage(question); };

    const renderMessageItem = useCallback( ({ item }: { item: Message }) => ( <MessageItem message={item} onLongPress={() => { Clipboard.setString(item.text); Alert.alert('Kopyalandı', 'Mesaj panoya kopyalandı!'); }} /> ), [] );

    const keyExtractor = useCallback((item: Message) => item.id, []);

    useEffect(() => { if (messages.length > 0) { flatListRef.current?.scrollToOffset({ animated: true, offset: 0 }); } }, [messages]);

    return ( <KeyboardAvoidingView style={styles.container} behavior={Platform.OS === 'ios' ? 'padding' : undefined} keyboardVerticalOffset={Platform.OS === 'ios' ? 60 : 0} > <TouchableOpacity onPress={() => navigation.goBack()} style={styles.backButton}> <Image source={{ uri: figure.image }} style={styles.headerAvatar} /> {figure.name} {figure.description}

      {isLoading ? (
        <View style={styles.loadingContainer}>
          <ActivityIndicator size="large" color="#007AFF" />
        </View>
      ) : (
        <FlatList
          ref={flatListRef}
          data={messages}
          renderItem={renderMessageItem}
          keyExtractor={keyExtractor}
          style={styles.messageList}
          contentContainerStyle={styles.messageListContent}
          inverted
        />
      )}
    
      {isTyping && (
        <View style={styles.typingIndicator}>
          <LottieView
            source={require('../../assets/typing-animation.json')}
            autoPlay
            loop
            style={styles.typingAnimation}
          />
        </View>
      )}
    
      {followUpQuestions.length > 0 && (
        <View style={styles.followUpContainer}>
          <CustomText bold style={styles.followUpTitle}>
            Takip Soruları:
          </CustomText>
          <ScrollView horizontal showsHorizontalScrollIndicator={false}>
            {followUpQuestions.map((question, index) => (
              <TouchableOpacity
                key={index}
                style={styles.followUpButton}
                onPress={() => handleFollowUpPress(question)}
              >
                <CustomText style={styles.followUpText}>{question}</CustomText>
              </TouchableOpacity>
            ))}
          </ScrollView>
        </View>
      )}
    
      <View style={styles.inputContainer}>
        <TextInput
          style={styles.input}
          value={inputText}
          onChangeText={setInputText}
          placeholder="Mesajınızı yazın..."
          onSubmitEditing={() => sendMessage()}
          returnKeyType="send"
        />
        <TouchableOpacity onPress={() => sendMessage()} style={styles.sendButton}>
          <Ionicons name="send" size={24} color="#fff" />
        </TouchableOpacity>
      </View>
    </KeyboardAvoidingView>
    

    ); };

    const styles = StyleSheet.create({ backButton: { marginRight: 10, }, container: { backgroundColor: '#F5F5F5', flex: 1, }, followUpButton: { backgroundColor: '#E0E0E0', borderRadius: 15, marginRight: 10, paddingHorizontal: 12, paddingVertical: 8, }, followUpContainer: { backgroundColor: '#FFFFFF', borderTopColor: '#E0E0E0', borderTopWidth: 1, padding: 10, }, followUpText: { color: '#000', fontFamily: 'Poppins_400Regular', }, followUpTitle: { color: '#000', fontFamily: 'Poppins_700Bold', fontSize: 16, marginBottom: 5, }, header: { alignItems: 'center', backgroundColor: '#FFFFFF', borderBottomColor: '#E0E0E0', borderBottomWidth: 1, flexDirection: 'row', padding: 15, paddingTop: Platform.OS === 'ios' ? 50 : 30, }, headerAvatar: { borderRadius: 20, height: 40, marginRight: 10, width: 40, }, headerDescription: { color: '#666666', fontFamily: 'Poppins_400Regular', fontSize: 14, marginTop: 2, }, headerInfo: { flex: 1, }, headerName: { color: '#000000', fontFamily: 'Poppins_700Bold', fontSize: 18, }, input: { backgroundColor: '#F0F0F0', borderRadius: 20, flex: 1, fontFamily: 'Poppins_400Regular', height: 40, marginRight: 10, paddingHorizontal: 15, }, inputContainer: { alignItems: 'center', backgroundColor: '#FFFFFF', borderTopColor: '#E0E0E0', borderTopWidth: 1, flexDirection: 'row', padding: 10, }, loadingContainer: { alignItems: 'center', flex: 1, justifyContent: 'center', }, messageList: { backgroundColor: '#F5F5F5', flex: 1, }, messageListContent: { paddingVertical: 10, // Reduced vertical padding paddingHorizontal: 15, }, sendButton: { backgroundColor: '#007AFF', borderRadius: 20, padding: 10, }, typingAnimation: { height: 40, width: 80, }, typingIndicator: { bottom: 70, left: 20, position: 'absolute', }, });

    export default ChatScreen; burada bir chat başlattığımda burada anında gözükmesi lazım: import React, { useContext, useEffect, useState, useCallback } from 'react'; import { View, FlatList, Image, TouchableOpacity, StyleSheet, Alert, SafeAreaView, Platform, StatusBar as RNStatusBar } from 'react-native'; import { StatusBar } from 'expo-status-bar'; import { useNavigation, useIsFocused } from '@react-navigation/native'; import { Ionicons } from '@expo/vector-icons'; import { ChatContext, ChatWithLastMessage } from '../context/ChatContext'; import CustomText from '../components/CustomText';

    const COLORS = { primary: '#007AFF', white: '#FFFFFF', grey1: '#999999', grey2: '#666666', grey3: '#333333', lightGrey: '#F5F5F5', borderGrey: '#E0E0E0', delete: '#FF3B30', };

    const ChatListScreen = () => { const navigation = useNavigation(); const { chats, deleteChat, deleteAllChats } = useContext(ChatContext); const [sortedChats, setSortedChats] = useState<ChatWithLastMessage[]>([]); const [loading, setLoading] = useState(true); const isFocused = useIsFocused();

    useEffect(() => { const sortChats = () => { const sorted = [...chats].sort( (a, b) => (b.lastMessageTimestamp || 0) - (a.lastMessageTimestamp || 0) ); setSortedChats(sorted); setLoading(false); };

    sortChats();
    

    }, [chats, isFocused]);

    const handleDeleteChat = useCallback( (chatId: string) => { Alert.alert( "Sohbeti Sil", "Bu sohbeti silmek istediğinizden emin misiniz?", [ { text: "İptal", style: "cancel" }, { text: "Sil", style: "destructive", onPress: () => deleteChat(chatId) } ] ); }, [deleteChat] );

    const handleDeleteAllChats = useCallback(() => { Alert.alert( "Tüm Sohbetleri Sil", "Tüm sohbetleri silmek istediğinizden emin misiniz? Bu işlem geri alınamaz.", [ { text: "İptal", style: "cancel" }, { text: "Sil", style: "destructive", onPress: deleteAllChats } ] ); }, [deleteAllChats]);

    const renderChatItem = useCallback( ({ item }: { item: ChatWithLastMessage }) => ( <TouchableOpacity style={styles.chatItem} onPress={() => navigation.navigate('Chat', { chatId: item.id, figure: item.figure }) } > <Image source={{ uri: item.figure.image }} style={styles.avatar} /> {item.figure.name} {item.lastMessage || "Henüz mesaj yok"} {timeAgo(item.lastMessageTimestamp)} <TouchableOpacity onPress={() => handleDeleteChat(item.id)} style={styles.deleteButton}> ), [navigation, handleDeleteChat] );

    const keyExtractor = useCallback((item: ChatWithLastMessage) => item.id, []);

    const timeAgo = (timestamp: number | undefined) => { if (!timestamp) return ''; const now = Date.now(); const diff = Math.floor((now - timestamp) / 60000); if (diff < 1) return Şimdi; if (diff < 60) return ${diff} dk önce; const hours = Math.floor(diff / 60); if (hours < 24) return ${hours} saat önce; const days = Math.floor(hours / 24); return ${days} gün önce; };

    return ( Sohbetlerim {chats.length > 0 && ( )} {sortedChats.length === 0 ? ( Hiç sohbetiniz yok! Yeni bir sohbet başlatın. ) : ( )} <TouchableOpacity style={styles.fab} onPress={() => navigation.navigate('Home')} > ); };

    const styles = StyleSheet.create({ avatar: { borderRadius: 30, height: 60, width: 60, }, chatDate: { color: COLORS.grey1, fontFamily: 'Poppins_400Regular', fontSize: 12, marginBottom: 8, }, chatInfo: { flex: 1, marginLeft: 15, }, chatItem: { alignItems: 'center', backgroundColor: COLORS.white, borderRadius: 12, elevation: 5, flexDirection: 'row', marginBottom: 15, marginHorizontal: 3, padding: 20, shadowColor: "#000", shadowOffset: { width: 0, height: 2, }, shadowOpacity: 0.1, shadowRadius: 3.84, }, chatLastMessage: { color: COLORS.grey2, fontFamily: 'Poppins_400Regular', fontSize: 14, marginTop: 4, }, chatList: { paddingTop: 10, paddingBottom: 20, }, chatMeta: { alignItems: 'flex-end', justifyContent: 'space-between', height: '100%', }, chatName: { color: COLORS.grey3, fontFamily: 'Poppins_700Bold', fontSize: 18, }, container: { backgroundColor: COLORS.lightGrey, flex: 1, paddingHorizontal: 15, }, deleteAllButton: { padding: 5, }, deleteButton: { padding: 5, }, emptyContainer: { alignItems: 'center', flex: 1, justifyContent: 'center', paddingHorizontal: 32, }, emptyText: { color: COLORS.grey2, fontFamily: 'Poppins_400Regular', fontSize: 16, textAlign: 'center', }, fab: { alignItems: 'center', backgroundColor: COLORS.primary, borderRadius: 28, bottom: 20, elevation: 5, height: 56, justifyContent: 'center', position: 'absolute', right: 20, shadowColor: "#000", shadowOffset: { width: 0, height: 2, }, shadowOpacity: 0.25, shadowRadius: 3.84, width: 56, }, header: { alignItems: 'center', borderBottomColor: COLORS.borderGrey, borderBottomWidth: 1, flexDirection: 'row', justifyContent: 'space-between', paddingVertical: 20, }, safeArea: { backgroundColor: COLORS.lightGrey, flex: 1, paddingTop: Platform.OS === 'android' ? RNStatusBar.currentHeight : 0, }, title: { color: COLORS.grey3, fontFamily: 'Poppins_700Bold', fontSize: 28, }, });

    export default ChatListScreen; // src/context/ChatContext.tsx

    import React, { createContext, useState, useEffect, useCallback, ReactNode } from 'react'; import AsyncStorage from '@react-native-async-storage/async-storage'; import { Chat, Message } from '../types/types';

    interface ChatWithLastMessage extends Chat { lastMessage?: string; lastMessageTimestamp?: number; }

    interface ChatContextProps { chats: ChatWithLastMessage[]; addChat: (chat: Chat, messages?: Message[]) => Promise; updateChat: (chatId: string, message: Message) => Promise; deleteChat: (chatId: string) => Promise; deleteAllChats: () => Promise; }

    export const ChatContext = createContext({ chats: [], addChat: async () => {}, updateChat: async () => {}, deleteChat: async () => {}, deleteAllChats: async () => {}, });

    interface ChatProviderProps { children: ReactNode; }

    export const ChatProvider: React.FC = ({ children }) => { const [chats, setChats] = useState<ChatWithLastMessage[]>([]);

    // Load chats from AsyncStorage on mount useEffect(() => { const loadChats = async () => { try { const chatsData = await AsyncStorage.getItem('chats'); const chatsList: Chat[] = chatsData ? JSON.parse(chatsData) : [];

        const chatsWithMessages: ChatWithLastMessage[] = await Promise.all(
          chatsList.map(async (chat) => {
            const messagesData = await AsyncStorage.getItem(`chat_${chat.id}_messages`);
            const messages: Message[] = messagesData ? JSON.parse(messagesData) : [];
            const lastMessage = messages[messages.length - 1]?.text || '';
            const lastTimestamp = messages[messages.length - 1]?.timestamp || chat.createdAt;
            return {
              ...chat,
              lastMessage,
              lastMessageTimestamp: lastTimestamp,
            };
          })
        );
    
        const sortedChats = chatsWithMessages.sort(
          (a, b) => (b.lastMessageTimestamp || 0) - (a.lastMessageTimestamp || 0)
        );
    
        setChats(sortedChats);
      } catch (error) {
        console.error('Error loading chats:', error);
      }
    };
    loadChats();
    

    }, []);

    // Add a new chat const addChat = useCallback(async (chat: Chat, messages: Message[] = []) => { try { const newChat: ChatWithLastMessage = { ...chat, lastMessage: messages.length > 0 ? messages[messages.length - 1].text : '', lastMessageTimestamp: messages.length > 0 ? messages[messages.length - 1].timestamp : chat.createdAt, }; setChats((prevChats) => { const updatedChats = [...prevChats, newChat]; AsyncStorage.setItem('chats', JSON.stringify(updatedChats)).catch((err) => console.error('Error updating chats in AsyncStorage:', err) ); return updatedChats; }); await AsyncStorage.setItem(chat_${chat.id}_messages, JSON.stringify(messages)); } catch (error) { console.error('Error adding chat:', error); } }, []); // Removed 'chats' from dependency array

    // Update an existing chat with a new message const updateChat = useCallback(async (chatId: string, message: Message) => { try { // Retrieve existing messages const messagesData = await AsyncStorage.getItem(chat_${chatId}_messages); const messages: Message[] = messagesData ? JSON.parse(messagesData) : []; const updatedMessages = [...messages, message]; await AsyncStorage.setItem(chat_${chatId}_messages, JSON.stringify(updatedMessages));

      // Update chat's last message and timestamp
      setChats((prevChats) => {
        const updatedChats = prevChats
          .map((chat) => {
            if (chat.id === chatId) {
              return {
                ...chat,
                lastMessage: message.text,
                lastMessageTimestamp: message.timestamp,
              };
            }
            return chat;
          })
          .sort((a, b) => (b.lastMessageTimestamp || 0) - (a.lastMessageTimestamp || 0));
    
        // Persist updated chats
        AsyncStorage.setItem('chats', JSON.stringify(updatedChats)).catch((err) =>
          console.error('Error updating chats in AsyncStorage:', err)
        );
    
        return updatedChats;
      });
    } catch (error) {
      console.error('Error updating chat:', error);
    }
    

    }, []);

    // Delete a specific chat const deleteChat = useCallback(async (chatId: string) => { try { const updatedChats = chats.filter((chat) => chat.id !== chatId); setChats(updatedChats); await AsyncStorage.setItem('chats', JSON.stringify(updatedChats)); await AsyncStorage.removeItem(chat_${chatId}_messages); } catch (error) { console.error('Error deleting chat:', error); } }, [chats]);

    // Delete all chats const deleteAllChats = useCallback(async () => { try { setChats([]); await AsyncStorage.removeItem('chats'); const keys = await AsyncStorage.getAllKeys(); const chatMessageKeys = keys.filter( (key) => key.startsWith('chat_') && key.endsWith('_messages') ); await AsyncStorage.multiRemove(chatMessageKeys); } catch (error) { console.error('Error deleting all chats:', error); } }, []);

    return ( <ChatContext.Provider value={{ chats, addChat, updateChat, deleteChat, deleteAllChats }}> {children} </ChatContext.Provider> ); }; ancak gözükmüyor. daha doğrusu hiç sohbetiniz yok derken bir sohbet açıyorum konuşuyorum ve bu list sayfası hala aynı hiç. sohjbet yok diyor bunu düzelt

  2. Assistant

    Görünüşe göre, sohbet başlatıldığında ve mesaj gönderildiğinde ChatListScreen'de sohbetlerin listelenmemesi, mesajların sıralanmasından kaynaklanan bir sorun olabilir. Mevcut kodunuzda mesajlar en yeni önce olacak şekilde ekleniyor ([userMessage, ...messages]), ancak ChatContext'te lastMessage olarak son mesaj (messages[messages.length - 1]) alınmaya çalışılıyor. Bu durum, lastMessage'ın aslında en eski mesaj olmasına neden olarak, ChatListScreen'in yeni sohbetleri tespit edememesine yol açabilir.

    Bu sorunu çözmek için mesajların en eski önce sıralanmasını sağlayarak ve FlatList'in inverted prop'unu kullanmaya devam ederek düzgün bir sıralama elde edebiliriz. Aşağıda gerekli değişiklikleri ve adımları bulabilirsiniz:

    1. ChatScreen.tsx Dosyasını Düzenleyin

    a. Mesajların Sıralamasını Değiştirin

    Mevcut kodunuzda mesajlar en yeni önce ekleniyor. Bunu en eski önce ekleyecek şekilde değiştirmeniz gerekiyor.

    // Mevcut kod:
    const updatedMessages = [userMessage, ...messages];
    
    // Yeni kod:
    const updatedMessages = [...messages, userMessage];
    

    b. AI Yanıtını da En Son Ekleyin

    AI yanıtını da en sona eklemek için aşağıdaki değişikliği yapın:

    // Mevcut kod:
    const newMessages = [aiMessage, ...updatedMessages];
    
    // Yeni kod:
    const newMessages = [...updatedMessages, aiMessage];
    

    c. Mesajları Yüklerken Sıralamayı Doğru Yapın

    Mesajları AsyncStorage'dan yüklerken doğru sıralamaya sahip olduklarından emin olun:

    useEffect(() => {
      if (isInitialLoad.current) return;
    
      const loadMessages = async () => {
        try {
          setIsLoading(true);
          setMessages([]);
          setFollowUpQuestions([]);
          setIsTyping(false);
    
          const messagesData = await AsyncStorage.getItem(`chat_${chatId}_messages`);
    -     let msgs: Message[] = messagesData ? JSON.parse(messagesData) : [];
    +     let msgs: Message[] = messagesData ? JSON.parse(messagesData) : [];
    +     // Mesajları en eski önce olacak şekilde sıralayın
    +     msgs.sort((a, b) => a.timestamp - b.timestamp);
    
          if (msgs.length === 0) {
            // ... (aynı kalabilir)
          }
    
          // No need to ensure unique messages here if chat IDs are unique
    
          setMessages(msgs);
          setIsLoading(false);
    
          // Scroll to the latest message
          setTimeout(() => {
            flatListRef.current?.scrollToEnd({ animated: true });
          }, 100);
        } catch (error) {
          console.error('Error loading messages:', error);
          setIsLoading(false);
        }
      };
    
      loadMessages();
      isInitialLoad.current = true;
    }, [chatId, figure.name, addChat, figure]);
    

    d. FlatList'in inverted Prop'unu Kullanmaya Devam Edin

    FlatList'in inverted prop'u mesajları en son eklenenin altta görüntülenmesini sağlar. Bu yüzden bunu değiştirmeyin:

    <FlatList
      ref={flatListRef}
      data={messages}
      renderItem={renderMessageItem}
      keyExtractor={keyExtractor}
      style={styles.messageList}
      contentContainerStyle={styles.messageListContent}
      inverted
    />
    

    2. ChatContext.tsx Dosyasını Doğrulayın

    ChatContext içinde addChat fonksiyonunun lastMessage ve lastMessageTimestamp değerlerini doğru şekilde güncellediğinden emin olun. Artık mesajlar en eski önce olduğundan, lastMessage ve lastMessageTimestamp en son mesajı temsil edecektir.

    const addChat = useCallback(async (chat: Chat, messages: Message[] = []) => {
      try {
        const newChat: ChatWithLastMessage = {
          ...chat,
          lastMessage: messages.length > 0 ? messages[messages.length - 1].text : '',
          lastMessageTimestamp: messages.length > 0 ? messages[messages.length - 1].timestamp : chat.createdAt,
        };
        setChats((prevChats) => {
          const updatedChats = [...prevChats, newChat];
          AsyncStorage.setItem('chats', JSON.stringify(updatedChats)).catch((err) =>
            console.error('Error updating chats in AsyncStorage:', err)
          );
          return updatedChats;
        });
        await AsyncStorage.setItem(`chat_${chat.id}_messages`, JSON.stringify(messages));
      } catch (error) {
        console.error('Error adding chat:', error);
      }
    }, []);
    

    3. ChatListScreen.tsx Dosyasını Doğrulayın

    Artık ChatContext doğru şekilde chats state'ini güncelliyor olmalı. Ancak, ek olarak ChatListScreen'de useEffect'in düzgün çalıştığından ve sortedChats state'inin doğru şekilde güncellendiğinden emin olun.

    useEffect(() => {
      const sortChats = () => {
        const sorted = [...chats].sort(
          (a, b) => (b.lastMessageTimestamp || 0) - (a.lastMessageTimestamp || 0)
        );
        setSortedChats(sorted);
        setLoading(false);
      };
    
      sortChats();
    }, [chats, isFocused]);
    

    4. Yeni Sohbet Oluşturma Akışını İnceleyin

    Yeni bir sohbet başlatıldığında, ChatScreen'in doğru şekilde addChat fonksiyonunu çağırdığından emin olun. Başlatma sırasında tek bir addChat çağrıldığından emin olun.

    if (msgs.length === 0) {
      const conversationStarters = [
        'Merhaba! Bugün nasıl yardımcı olabilirim?',
        `${figure.name} hakkında ne öğrenmek istersiniz?`,
        `${figure.name} ile ilgili herhangi bir sorunuz var mı?`,
      ];
    
      const starterMessages: Message[] = conversationStarters.map((starter) => ({
        id: uuid.v4().toString(),
        text: starter,
        isUser: false,
        timestamp: Date.now(),
      }));
    
      msgs = starterMessages;
    
      // Initialize the chat in context with all starter messages
      const newChat = {
        id: chatId,
        figure: figure,
        createdAt: Date.now(),
      };
      await addChat(newChat, starterMessages);
    }
    

    5. Sağlama Adımları ve Ek Kontroller

    • ChatProvider'ın Uygulamanızı Sarmaladığından Emin Olun: ChatProvider bileşeninin tüm uygulamanızın etrafını sarmaladığından emin olun ki, ChatContext tüm bileşenler tarafından erişilebilir olsun.

      // App.tsx veya root bileşeniniz
      import React from 'react';
      import { ChatProvider } from './src/context/ChatContext';
      import ChatListScreen from './src/screens/ChatListScreen';
      // Diğer importlar...
      
      const App = () => {
        return (
          <ChatProvider>
            {/* Diğer navigasyon ve ekran bileşenleriniz */}
            <ChatListScreen />
          </ChatProvider>
        );
      };
      
      export default App;
      
    • AsyncStorage İşlemlerini Kontrol Edin: AsyncStorage işlemlerinin başarılı bir şekilde tamamlandığından ve verilerin doğru şekilde saklandığından emin olun. Hataları konsolda izlemek için console.error kullanmanız faydalı olabilir.

    • Debugging için Log Ekleyin: Hem ChatContext hem de ChatListScreen içinde console.log kullanarak chats state'inin doğru güncellenip güncellenmediğini kontrol edin.

      // ChatContext.tsx içinde addChat fonksiyonuna ekleyin
      console.log('Yeni sohbet eklendi:', newChat);
      console.log('Güncel sohbet listesi:', [...prevChats, newChat]);
      
      // ChatListScreen.tsx içinde sortedChats'u kontrol edin
      useEffect(() => {
        console.log('Sohbetler güncellendi:', chats);
        const sortChats = () => {
          const sorted = [...chats].sort(
            (a, b) => (b.lastMessageTimestamp || 0) - (a.lastMessageTimestamp || 0)
          );
          setSortedChats(sorted);
          setLoading(false);
        };
      
        sortChats();
      }, [chats, isFocused]);
      

    6. Sonuç

    Bu değişiklikler, mesajların doğru sıralanmasını ve ChatListScreen'in yeni sohbetleri doğru şekilde tespit etmesini sağlayacaktır. Mesajları en eski önce eklemek, lastMessage ve lastMessageTimestamp gibi özelliklerin doğru şekilde güncellenmesine olanak tanır, böylece sohbet listesindeki güncellemeler hemen görünür hale gelir.

    Eğer bu adımları uyguladıktan sonra hala sorun yaşıyorsanız, aşağıdaki ek kontrolleri yapabilirsiniz:

    • Chat ID'nin Benzersiz Olduğundan Emin Olun: Her sohbetin benzersiz bir chatId'ye sahip olduğundan emin olun.

    • Navigasyon Parametrelerini Kontrol Edin: ChatScreen'e doğru chatId ve figure parametrelerinin geçtiğinden emin olun.

    • FlatList Performansını İzleyin: FlatList'in performansını etkileyebilecek başka bir sorun olup olmadığını kontrol edin.

    Bu adımlar, sorununuzu çözmek için kapsamlı bir yaklaşım sunmaktadır. Umarım bu bilgiler yardımcı olur!