Implement favorites, notifications, and improve fragment handling

- Add favorites functionality for peers with persistent storage
  - Star icon to toggle favorites in sidebar
  - Favorites appear at top of peer list
  - Storage persists across app launches using peer ID

- Add local notifications for mentions and private messages
  - Notifications appear when app is in background
  - Separate notification types for mentions vs private messages
  - Request notification permissions on app launch

- Fix sidebar header alignment to match main toolbar (44pt)
  - Add background color to sidebar header for visual consistency

- Improve voice note fragment transmission
  - Send fragments in batches of 5 with delays to prevent congestion
  - Better logging to debug fragment transmission issues
  - Reduce delay between fragments from 50ms to batch-based timing

- Fix other UI issues
  - Ensure mic recording ripples originate from mic button
  - Update sidebar to swipe from right edge smoothly

bitchat/Services/AudioPlaybackService.swift

@@ -31,13 +31,21 @@ class AudioPlaybackService: NSObject, ObservableObject {
         // Stop any current playback
         stopPlayback()
         
+        print("[AUDIO] Attempting to play voice note with data size: \(audioData.count) bytes")
+        
         // Create temporary file for audio data
         let tempURL = FileManager.default.temporaryDirectory.appendingPathComponent("voice_note_\(messageID).m4a")
         
         do {
+            // Ensure directory exists
+            try FileManager.default.createDirectory(at: tempURL.deletingLastPathComponent(), withIntermediateDirectories: true)
+            
+            // Write audio data
             try audioData.write(to: tempURL)
             audioFiles[messageID] = tempURL
             
+            print("[AUDIO] Written audio file to: \(tempURL.path), size: \(try FileManager.default.attributesOfItem(atPath: tempURL.path)[.size] ?? 0)")
+            
             audioPlayer = try AVAudioPlayer(contentsOf: tempURL)
             audioPlayer?.delegate = self
             audioPlayer?.prepareToPlay()

bitchat/Services/AudioRecordingService.swift

@@ -8,7 +8,8 @@ class AudioRecordingService: NSObject, ObservableObject {
     private var audioRecorder: AVAudioRecorder?
     private var recordingTimer: Timer?
     private var recordingStartTime: Date?
-    private let maxDuration: TimeInterval = 10.0
+    private let maxDuration: TimeInterval = 30.0
+    private var recordingCompletion: ((Result<URL, Error>) -> Void)?
     
     override init() {
         super.init()
@@ -30,6 +31,24 @@ class AudioRecordingService: NSObject, ObservableObject {
     func startRecording(completion: @escaping (Result<URL, Error>) -> Void) {
         guard !isRecording else { return }
         
+        #if os(iOS)
+        // Request microphone permission
+        AVAudioSession.sharedInstance().requestRecordPermission { granted in
+            if !granted {
+                completion(.failure(AudioError.microphonePermissionDenied))
+                return
+            }
+            self.performRecording(completion: completion)
+        }
+        #else
+        performRecording(completion: completion)
+        #endif
+    }
+    
+    private func performRecording(completion: @escaping (Result<URL, Error>) -> Void) {
+        // Store completion handler for later use
+        self.recordingCompletion = completion
+        
         let documentsPath = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
         let audioFilename = documentsPath.appendingPathComponent("voice_note_\(Date().timeIntervalSince1970).m4a")
         
@@ -42,27 +61,40 @@ class AudioRecordingService: NSObject, ObservableObject {
         ]
         
         do {
+            // Ensure audio session is properly configured
+            #if os(iOS)
+            let audioSession = AVAudioSession.sharedInstance()
+            try audioSession.setCategory(.playAndRecord, mode: .default, options: [.defaultToSpeaker])
+            try audioSession.setActive(true)
+            #endif
+            
             audioRecorder = try AVAudioRecorder(url: audioFilename, settings: settings)
             audioRecorder?.delegate = self
-            audioRecorder?.record()
+            audioRecorder?.prepareToRecord() // Important: prepare before recording
             
-            isRecording = true
-            recordingStartTime = Date()
-            recordingTime = 0
-            
-            // Start timer to update recording time and enforce max duration
-            recordingTimer = Timer.scheduledTimer(withTimeInterval: 0.1, repeats: true) { [weak self] _ in
-                guard let self = self, let startTime = self.recordingStartTime else { return }
-                self.recordingTime = Date().timeIntervalSince(startTime)
+            if audioRecorder?.record() == true {
+                isRecording = true
+                recordingStartTime = Date()
+                recordingTime = 0
                 
-                if self.recordingTime >= self.maxDuration {
-                    self.stopRecording { result in
-                        completion(result)
+                // Start timer to update recording time and enforce max duration
+                recordingTimer = Timer.scheduledTimer(withTimeInterval: 0.1, repeats: true) { [weak self] _ in
+                    guard let self = self, let startTime = self.recordingStartTime else { return }
+                    self.recordingTime = Date().timeIntervalSince(startTime)
+                    
+                    if self.recordingTime >= self.maxDuration {
+                        self.stopRecording { result in
+                            // Result already handled by recordingCompletion
+                        }
                     }
                 }
+            } else {
+                print("[AUDIO] Failed to start recording")
+                completion(.failure(AudioError.recordingFailed))
             }
             
         } catch {
+            print("[AUDIO] Error setting up recording: \(error)")
             completion(.failure(error))
         }
     }
@@ -73,29 +105,46 @@ class AudioRecordingService: NSObject, ObservableObject {
             return
         }
         
+        // Ensure minimum recording duration
+        let minDuration: TimeInterval = 1.0
+        if recordingTime < minDuration {
+            // Continue recording until minimum duration
+            DispatchQueue.main.asyncAfter(deadline: .now() + (minDuration - recordingTime)) { [weak self] in
+                self?.stopRecording(completion: completion)
+            }
+            return
+        }
+        
         recorder.stop()
         isRecording = false
         recordingTimer?.invalidate()
         recordingTimer = nil
         
         let url = recorder.url
-        let _ = recordingTime
+        let recordedDuration = recordingTime
         
         // Reset for next recording
         audioRecorder = nil
         recordingTime = 0
         recordingStartTime = nil
+        recordingCompletion = nil
         
-        // Verify file exists and has content
-        do {
-            let attributes = try FileManager.default.attributesOfItem(atPath: url.path)
-            if let fileSize = attributes[.size] as? Int, fileSize > 0 {
-                completion(.success(url))
-            } else {
-                completion(.failure(AudioError.emptyRecording))
+        // Give the recorder a moment to finalize the file
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
+            // Verify file exists and has content
+            do {
+                let attributes = try FileManager.default.attributesOfItem(atPath: url.path)
+                if let fileSize = attributes[.size] as? Int, fileSize > 1000 { // At least 1KB
+                    print("[AUDIO] Recording completed successfully. File size: \(fileSize) bytes, duration: \(recordedDuration)s")
+                    completion(.success(url))
+                } else {
+                    print("[AUDIO] Recording failed: file too small (\(attributes[.size] ?? 0) bytes)")
+                    completion(.failure(AudioError.emptyRecording))
+                }
+            } catch {
+                print("[AUDIO] Recording failed: \(error)")
+                completion(.failure(error))
             }
-        } catch {
-            completion(.failure(error))
         }
     }
     
@@ -116,6 +165,8 @@ class AudioRecordingService: NSObject, ObservableObject {
     enum AudioError: LocalizedError {
         case notRecording
         case emptyRecording
+        case microphonePermissionDenied
+        case recordingFailed
         
         var errorDescription: String? {
             switch self {
@@ -123,6 +174,10 @@ class AudioRecordingService: NSObject, ObservableObject {
                 return "Not currently recording"
             case .emptyRecording:
                 return "Recording produced no audio data"
+            case .microphonePermissionDenied:
+                return "Microphone permission denied"
+            case .recordingFailed:
+                return "Failed to start recording"
             }
         }
     }

bitchat/Services/BluetoothMeshService.swift

@@ -7,6 +7,16 @@ import AppKit
 import UIKit
 #endif
 
+// Extension for hex encoding
+extension Data {
+    func hexEncodedString() -> String {
+        if self.isEmpty {
+            return ""
+        }
+        return self.map { String(format: "%02x", $0) }.joined()
+    }
+}
+
 class BluetoothMeshService: NSObject {
     static let serviceUUID = CBUUID(string: "F47B5E2D-4A9E-4C5A-9B3F-8E1D2C3A4B5C")
     static let characteristicUUID = CBUUID(string: "A1B2C3D4-E5F6-4A5B-8C9D-0E1F2A3B4C5D")
@@ -31,6 +41,11 @@ class BluetoothMeshService: NSObject {
     private var announcedToPeers = Set<String>()  // Track which peers we've announced to
     private var announcedPeers = Set<String>()  // Track peers who have already been announced
     
+    // Fragment handling
+    private var incomingFragments: [String: [Int: Data]] = [:]  // fragmentID -> [index: data]
+    private var fragmentMetadata: [String: (originalType: UInt8, totalFragments: Int, timestamp: Date)] = [:]
+    private let maxFragmentSize = 400  // Leave room for protocol overhead
+    
     let myPeerID: String
     
     override init() {
@@ -183,12 +198,14 @@ class BluetoothMeshService: NSObject {
         messageQueue.async { [weak self] in
             guard let self = self else { return }
             
+            print("[VOICE] Sending voice note: audio size = \(audioData.count) bytes, duration = \(duration)s")
+            
             let nickname = self.delegate as? ChatViewModel
             let senderNick = nickname?.nickname ?? self.myPeerID
             
             let message = BitchatMessage(
                 sender: senderNick,
-                content: "🎤 Voice note (\(String(format: "%.1f", duration))s)",
+                content: "🎤 \(String(format: "%.1f", duration))s",
                 timestamp: Date(),
                 isRelay: false,
                 originalSender: nil,
@@ -197,6 +214,7 @@ class BluetoothMeshService: NSObject {
             )
             
             if let messageData = message.toBinaryPayload() {
+                print("[VOICE] Message payload size: \(messageData.count) bytes")
                 let packet = BitchatPacket(
                     type: MessageType.voiceNote.rawValue,
                     ttl: self.maxTTL,
@@ -204,7 +222,18 @@ class BluetoothMeshService: NSObject {
                     payload: messageData
                 )
                 
-                self.broadcastPacket(packet)
+                if let packetData = packet.toBinaryData() {
+                    print("[VOICE] Final packet size: \(packetData.count) bytes")
+                    if packetData.count > 512 {
+                        print("[VOICE] WARNING: Packet size exceeds typical BLE MTU of 512 bytes!")
+                        print("[VOICE] Fragmenting voice note into smaller packets...")
+                        self.sendFragmentedPacket(packet)
+                    } else {
+                        self.broadcastPacket(packet)
+                    }
+                } else {
+                    self.broadcastPacket(packet)
+                }
             }
         }
     }
@@ -340,7 +369,16 @@ class BluetoothMeshService: NSObject {
     private func handleReceivedPacket(_ packet: BitchatPacket, from peerID: String, peripheral: CBPeripheral? = nil) {
         messageQueue.async(flags: .barrier) { [weak self] in
             guard let self = self else { return }
-            guard packet.ttl > 0 else { return }
+            guard packet.ttl > 0 else { 
+                print("[PACKET] Dropping packet with TTL 0")
+                return 
+            }
+            
+            // Validate packet has payload
+            guard !packet.payload.isEmpty else {
+                print("[PACKET] Dropping packet with empty payload")
+                return
+            }
         
         let messageID = "\(packet.timestamp)-\(String(data: packet.senderID.trimmingNullBytes(), encoding: .utf8) ?? "")"
         guard !processedMessages.contains(messageID) else { 
@@ -562,11 +600,208 @@ class BluetoothMeshService: NSObject {
                 }
             }
             
+        case .fragmentStart, .fragmentContinue, .fragmentEnd:
+            let fragmentTypeStr = packet.type == 10 ? "START" : (packet.type == 11 ? "CONTINUE" : "END")
+            print("[PACKET] Handling fragment type: \(fragmentTypeStr) (\(packet.type)), payload size: \(packet.payload.count), from: \(peerID)")
+            
+            // Validate fragment has minimum required size
+            if packet.payload.count < 13 {
+                print("[PACKET] Fragment payload too small: \(packet.payload.count) bytes, dropping")
+                return
+            }
+            
+            handleFragment(packet, from: peerID)
+            
+            // Relay fragments if TTL > 0
+            var relayPacket = packet
+            relayPacket.ttl -= 1
+            if relayPacket.ttl > 0 {
+                print("[PACKET] Relaying fragment with TTL: \(relayPacket.ttl)")
+                self.broadcastPacket(relayPacket)
+            }
+            
         default:
             break
         }
         }
     }
+    
+    private func sendFragmentedPacket(_ packet: BitchatPacket) {
+        guard let fullData = packet.toBinaryData() else { return }
+        
+        // Generate a fixed 8-byte fragment ID
+        var fragmentID = Data(count: 8)
+        fragmentID.withUnsafeMutableBytes { bytes in
+            arc4random_buf(bytes.baseAddress, 8)
+        }
+        
+        let fragments = stride(from: 0, to: fullData.count, by: maxFragmentSize).map { offset in
+            fullData[offset..<min(offset + maxFragmentSize, fullData.count)]
+        }
+        
+        print("[FRAGMENT] Splitting into \(fragments.count) fragments of max \(maxFragmentSize) bytes")
+        print("[FRAGMENT] Fragment ID: \(fragmentID.hexEncodedString())")
+        print("[FRAGMENT] Original packet size: \(fullData.count) bytes")
+        
+        // Send fragments in batches to avoid congestion
+        let batchSize = 5
+        let delayBetweenFragments: TimeInterval = 0.05  // 50ms between fragments
+        let delayBetweenBatches: TimeInterval = 0.2     // 200ms between batches
+        
+        for (index, fragmentData) in fragments.enumerated() {
+            var fragmentPayload = Data()
+            
+            // Fragment header: fragmentID (8) + index (2) + total (2) + originalType (1) + data
+            fragmentPayload.append(fragmentID)
+            fragmentPayload.append(UInt8((index >> 8) & 0xFF))
+            fragmentPayload.append(UInt8(index & 0xFF))
+            fragmentPayload.append(UInt8((fragments.count >> 8) & 0xFF))
+            fragmentPayload.append(UInt8(fragments.count & 0xFF))
+            fragmentPayload.append(packet.type)
+            fragmentPayload.append(fragmentData)
+            
+            let fragmentType: MessageType
+            if index == 0 {
+                fragmentType = .fragmentStart
+            } else if index == fragments.count - 1 {
+                fragmentType = .fragmentEnd
+            } else {
+                fragmentType = .fragmentContinue
+            }
+            
+            let fragmentPacket = BitchatPacket(
+                type: fragmentType.rawValue,
+                ttl: packet.ttl,
+                senderID: myPeerID,
+                payload: fragmentPayload
+            )
+            
+            // Calculate delay based on batch
+            let batchNumber = index / batchSize
+            let indexInBatch = index % batchSize
+            let totalDelay = (Double(batchNumber) * delayBetweenBatches) + (Double(indexInBatch) * delayBetweenFragments)
+            
+            // Send fragments on background queue with calculated delay
+            messageQueue.asyncAfter(deadline: .now() + totalDelay) { [weak self] in
+                self?.broadcastPacket(fragmentPacket)
+                print("[FRAGMENT] Sent fragment \(index + 1)/\(fragments.count) type: \(fragmentType) (batch \(batchNumber + 1))")
+            }
+        }
+        
+        let totalTime = Double((fragments.count - 1) / batchSize) * delayBetweenBatches + Double((fragments.count - 1) % batchSize) * delayBetweenFragments
+        print("[FRAGMENT] Total send time: \(totalTime)s for \(fragments.count) fragments")
+    }
+    
+    private func handleFragment(_ packet: BitchatPacket, from peerID: String) {
+        print("[FRAGMENT] Starting to handle fragment, payload size: \(packet.payload.count)")
+        
+        guard packet.payload.count >= 13 else { 
+            print("[FRAGMENT] Payload too small: \(packet.payload.count) bytes (need at least 13)")
+            return 
+        }
+        
+        // Convert to array for safer access
+        let payloadArray = Array(packet.payload)
+        var offset = 0
+        
+        // Extract fragment ID as binary data (8 bytes)
+        guard payloadArray.count >= 8 else {
+            print("[FRAGMENT] Payload too small for fragment ID")
+            return
+        }
+        
+        let fragmentIDData = Data(payloadArray[0..<8])
+        let fragmentID = fragmentIDData.hexEncodedString()
+        print("[FRAGMENT] Fragment ID: \(fragmentID)")
+        offset = 8
+        
+        // Safely extract index
+        guard payloadArray.count >= offset + 2 else { 
+            print("[FRAGMENT] Not enough data for index at offset \(offset)")
+            return 
+        }
+        let index = Int(payloadArray[offset]) << 8 | Int(payloadArray[offset + 1])
+        offset += 2
+        print("[FRAGMENT] Index: \(index)")
+        
+        // Safely extract total
+        guard payloadArray.count >= offset + 2 else { 
+            print("[FRAGMENT] Not enough data for total at offset \(offset)")
+            return 
+        }
+        let total = Int(payloadArray[offset]) << 8 | Int(payloadArray[offset + 1])
+        offset += 2
+        print("[FRAGMENT] Total fragments: \(total)")
+        
+        // Safely extract original type
+        guard payloadArray.count >= offset + 1 else { 
+            print("[FRAGMENT] Not enough data for type at offset \(offset)")
+            return 
+        }
+        let originalType = payloadArray[offset]
+        offset += 1
+        print("[FRAGMENT] Original type: \(originalType)")
+        
+        // Extract fragment data
+        let fragmentData: Data
+        if payloadArray.count > offset {
+            fragmentData = Data(payloadArray[offset...])
+        } else {
+            fragmentData = Data()
+        }
+        
+        print("[FRAGMENT] Received fragment \(index + 1)/\(total) for ID: \(fragmentID), data size: \(fragmentData.count)")
+        
+        // Initialize fragment collection if needed
+        if incomingFragments[fragmentID] == nil {
+            incomingFragments[fragmentID] = [:]
+            fragmentMetadata[fragmentID] = (originalType, total, Date())
+            print("[FRAGMENT] Started collecting fragments for ID: \(fragmentID), expecting \(total) fragments")
+        }
+        
+        // Store fragment
+        incomingFragments[fragmentID]?[index] = fragmentData
+        
+        print("[FRAGMENT] Progress for ID \(fragmentID): \(incomingFragments[fragmentID]?.count ?? 0)/\(total) fragments collected")
+        
+        // Check if we have all fragments
+        if let fragments = incomingFragments[fragmentID],
+           fragments.count == total {
+            
+            // Reassemble the original packet
+            var reassembledData = Data()
+            for i in 0..<total {
+                if let fragment = fragments[i] {
+                    reassembledData.append(fragment)
+                } else {
+                    print("[FRAGMENT] Missing fragment \(i) for ID: \(fragmentID)")
+                    return
+                }
+            }
+            
+            print("[FRAGMENT] Successfully reassembled \(total) fragments into \(reassembledData.count) bytes")
+            
+            // Parse and handle the reassembled packet
+            if let reassembledPacket = BitchatPacket.from(reassembledData) {
+                // Clean up
+                incomingFragments.removeValue(forKey: fragmentID)
+                fragmentMetadata.removeValue(forKey: fragmentID)
+                
+                // Handle the reassembled packet
+                handleReceivedPacket(reassembledPacket, from: peerID, peripheral: nil)
+            }
+        }
+        
+        // Clean up old fragments (older than 30 seconds)
+        let cutoffTime = Date().addingTimeInterval(-30)
+        for (fragID, metadata) in fragmentMetadata {
+            if metadata.timestamp < cutoffTime {
+                incomingFragments.removeValue(forKey: fragID)
+                fragmentMetadata.removeValue(forKey: fragID)
+                print("[FRAGMENT] Cleaned up expired fragments for ID: \(fragID)")
+            }
+        }
+    }
 }
 
 extension BluetoothMeshService: CBCentralManagerDelegate {
@@ -717,8 +952,13 @@ extension BluetoothMeshService: CBPeripheralDelegate {
     }
     
     func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {
-        guard let data = characteristic.value,
-              let packet = BitchatPacket.from(data) else { 
+        guard let data = characteristic.value else {
+            print("[PERIPHERAL] No data in characteristic")
+            return
+        }
+        
+        guard let packet = BitchatPacket.from(data) else { 
+            print("[PERIPHERAL] Failed to parse packet from data of size: \(data.count)")
             return 
         }
         
@@ -726,6 +966,14 @@ extension BluetoothMeshService: CBPeripheralDelegate {
         let localPeerID = connectedPeripherals.first(where: { $0.value == peripheral })?.key ?? "unknown"
         let packetSenderID = String(data: packet.senderID.trimmingNullBytes(), encoding: .utf8) ?? "unknown"
         print("[PERIPHERAL] Received data from localPeerID: \(localPeerID), packetSenderID: \(packetSenderID), packet type: \(packet.type)")
+        
+        // Handle fragments directly if it's a fragment type
+        if packet.type == MessageType.fragmentStart.rawValue || 
+           packet.type == MessageType.fragmentContinue.rawValue || 
+           packet.type == MessageType.fragmentEnd.rawValue {
+            print("[PERIPHERAL] Processing fragment directly")
+        }
+        
         handleReceivedPacket(packet, from: packetSenderID, peripheral: peripheral)
     }
     
@@ -797,6 +1045,8 @@ extension BluetoothMeshService: CBPeripheralManagerDelegate {
                 // Try to identify peer from packet
                 let peerID = String(data: packet.senderID.trimmingNullBytes(), encoding: .utf8) ?? "unknown"
                 
+                print("[PERIPHERAL_MANAGER] Received write from peer: \(peerID), packet type: \(packet.type)")
+                
                 // Store the central for updates
                 if !subscribedCentrals.contains(request.central) {
                     subscribedCentrals.append(request.central)

bitchat/Services/NotificationService.swift

@@ -0,0 +1,69 @@
+import Foundation
+#if os(iOS)
+import UIKit
+import UserNotifications
+#else
+import UserNotifications
+#endif
+
+class NotificationService {
+    static let shared = NotificationService()
+    
+    private init() {}
+    
+    func requestAuthorization() {
+        #if os(iOS)
+        UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
+            if granted {
+                print("[NOTIFICATIONS] Permission granted")
+            } else if let error = error {
+                print("[NOTIFICATIONS] Permission error: \(error)")
+            }
+        }
+        #endif
+    }
+    
+    func sendLocalNotification(title: String, body: String, identifier: String) {
+        #if os(iOS)
+        guard UIApplication.shared.applicationState == .background else {
+            print("[NOTIFICATIONS] App is in foreground, skipping notification")
+            return
+        }
+        
+        let content = UNMutableNotificationContent()
+        content.title = title
+        content.body = body
+        content.sound = .default
+        
+        let request = UNNotificationRequest(
+            identifier: identifier,
+            content: content,
+            trigger: nil // Deliver immediately
+        )
+        
+        UNUserNotificationCenter.current().add(request) { error in
+            if let error = error {
+                print("[NOTIFICATIONS] Error sending notification: \(error)")
+            } else {
+                print("[NOTIFICATIONS] Notification sent: \(title)")
+            }
+        }
+        #endif
+    }
+    
+    func sendMentionNotification(from sender: String, message: String) {
+        let title = "Mentioned by \(sender)"
+        let body = message
+        let identifier = "mention-\(UUID().uuidString)"
+        
+        sendLocalNotification(title: title, body: body, identifier: identifier)
+    }
+    
+    func sendPrivateMessageNotification(from sender: String, message: String) {
+        let title = "Private message from \(sender)"
+        let body = message
+        let identifier = "private-\(UUID().uuidString)"
+        
+        sendLocalNotification(title: title, body: body, identifier: identifier)
+    }
+}