基于Swift与Firebase实现好友列表及分组消息功能的技术咨询

Hey there! Let’s walk through how to build these friend management features with Swift and Firebase—this is totally manageable once you nail down the data structure first. I’ll break it into clear, actionable steps for each feature you need:

This is the foundation—getting this right will make all the rest easier. Here’s a suggested structure:

• users Collection: Each document (keyed by user UID) stores basic user info, plus a friendUids array (or a friends sub-collection) that lists the UIDs of all their approved friends.
• friendGroups Collection: Each document represents a group, with these fields:
  • groupName: String (custom name the user sets)
  • memberIds: Array (max 5 UIDs of friends in the group)
  • ownerUid: String (UID of the user who created the group)
  • createdAt: Timestamp (for sorting groups)
• messages Collection: Each document is a single message, with fields to distinguish between group and direct messages:
  • content: String (the message text)
  • senderUid: String (UID of the person sending the message)
  • timestamp: Timestamp (for sorting messages chronologically)
  • recipientType: String (either "user" or "group")
  • recipientUid: String (only for direct messages—UID of the target user)
  • groupId: String (only for group messages—ID of the target group)

First, fetch the current user’s friend list from Firestore. Then let them select up to 5 friends and enter a group name. Here’s a Swift code snippet to save the group:

import FirebaseFirestore

func createFriendGroup(named groupName: String, withMemberIds memberIds: [String], ownerUid: String, completion: @escaping (Error?) -> Void) {
    // Validate max 5 members first
    guard memberIds.count <= 5 else {
        let error = NSError(domain: "GroupCreationError", code: 0, userInfo: [NSLocalizedDescriptionKey: "Groups can have a maximum of 5 members"])
        completion(error)
        return
    }
    
    // Optional: Double-check all memberIds are in the user's friend list (to prevent invalid selections)
    // You'd fetch the user's friendUids array here and compare
    
    // Create a new group document with a random ID
    let groupRef = Firestore.firestore().collection("friendGroups").document()
    let groupData: [String: Any] = [
        "groupName": groupName,
        "memberIds": memberIds,
        "ownerUid": ownerUid,
        "createdAt": Timestamp(date: Date())
    ]
    
    groupRef.setData(groupData) { error in
        completion(error)
    }
}

Make sure only the group owner can delete it. Here’s how to handle that:

func deleteFriendGroup(withId groupId: String, currentUserUid: String, completion: @escaping (Error?) -> Void) {
    let groupRef = Firestore.firestore().collection("friendGroups").document(groupId)
    
    // First verify the current user is the owner
    groupRef.getDocument { snapshot, error in
        guard let snapshot = snapshot, snapshot.exists else {
            completion(NSError(domain: "DeleteError", code: 0, userInfo: [NSLocalizedDescriptionKey: "Group not found"]))
            return
        }
        
        guard let ownerUid = snapshot.data()?["ownerUid"] as? String, ownerUid == currentUserUid else {
            completion(NSError(domain: "DeleteError", code: 1, userInfo: [NSLocalizedDescriptionKey: "You can only delete groups you created"]))
            return
        }
        
        // Delete the group document
        groupRef.delete(completion: completion)
    }
}

When the user types in the text box and hits send, save the message to the messages collection with the groupId tag. Then use Firestore’s snapshot listener to update the UI in real-time for all group members:

// Send the message
func sendMessageToGroup(content: String, senderUid: String, groupId: String, completion: @escaping (Error?) -> Void) {
    let messageRef = Firestore.firestore().collection("messages").document()
    let messageData: [String: Any] = [
        "content": content,
        "senderUid": senderUid,
        "groupId": groupId,
        "timestamp": Timestamp(date: Date()),
        "recipientType": "group"
    ]
    
    messageRef.setData(messageData) { error in
        completion(error)
    }
}

// Listen for real-time group messages
func listenToGroupMessages(groupId: String, updateHandler: @escaping ([Message]) -> Void) {
    // Assume you have a Codable `Message` struct to map Firestore data
    Firestore.firestore().collection("messages")
        .whereField("groupId", isEqualTo: groupId)
        .order(by: "timestamp", descending: false)
        .addSnapshotListener { snapshot, error in
            guard let documents = snapshot?.documents else {
                print("Error fetching group messages: \(error?.localizedDescription ?? "Unknown error")")
                return
            }
            
            let messages = documents.compactMap { doc in
                try? doc.data(as: Message.self)
            }
            
            updateHandler(messages)
        }
}

This is almost identical to group messages—just use recipientType: "user" and recipientUid instead of groupId:

// Send direct message
func sendMessageToUser(content: String, senderUid: String, recipientUid: String, completion: @escaping (Error?) -> Void) {
    let messageRef = Firestore.firestore().collection("messages").document()
    let messageData: [String: Any] = [
        "content": content,
        "senderUid": senderUid,
        "recipientUid": recipientUid,
        "timestamp": Timestamp(date: Date()),
        "recipientType": "user"
    ]
    
    messageRef.setData(messageData) { error in
        completion(error)
    }
}

// Listen for direct messages between current user and recipient
func listenToDirectMessages(currentUserUid: String, recipientUid: String, updateHandler: @escaping ([Message]) -> Void) {
    Firestore.firestore().collection("messages")
        .whereField("recipientType", isEqualTo: "user")
        .whereField("senderUid", in: [currentUserUid, recipientUid])
        .whereField("recipientUid", in: [currentUserUid, recipientUid])
        .order(by: "timestamp", descending: false)
        .addSnapshotListener { snapshot, error in
            guard let documents = snapshot?.documents else {
                print("Error fetching direct messages: \(error?.localizedDescription ?? "Unknown error")")
                return
            }
            
            let messages = documents.compactMap { doc in
                try? doc.data(as: Message.self)
            }
            
            updateHandler(messages)
        }
}

• Firebase Security Rules: Don’t forget to lock down your Firestore data so users can only access their own groups, friends, and messages. For example, for friendGroups, you could write a rule like:

  match /friendGroups/{groupId} {
    allow read: if request.auth.uid == resource.data.ownerUid || request.auth.uid in resource.data.memberIds;
    allow write: if request.auth.uid == resource.data.ownerUid;
  }
  

• Codable Models: Use Swift’s Codable protocol to easily convert Firestore documents into Swift structs (like the Message struct I mentioned)—this saves you from manual data parsing.
• Real-Time Updates: The snapshot listeners I included will automatically update your UI when new messages are sent or groups are modified, which gives your app a smooth, responsive feel.

内容的提问来源于stack exchange，提问作者Bonilla