Get Notification Tray Seen

Unseen Status Detection

Determine whether there are unseen notifications in the tray

Cross-device Sync

Manage seen status across multiple client devices

Overview

The getNotificationTraySeen() method allows your app to determine whether there are unseen notifications by retrieving the current isSeen status of the notification tray. This is particularly useful for reflecting read/unread indicators in the UI—such as toggling a bell icon badge—based on whether new notifications have arrived since the tray was last viewed.

The seen status is managed on the server and may be affected by actions from other devices. However, the state is not updated via real-time events, and thus requires manual refresh to stay current.

Refresh Strategies

🔁 On-demand Refresh (Recommended)

The preferred approach for maintaining accurate seen status across clients:

UI-Triggered Updates

Invoke getNotificationTraySeen() whenever the Notification Tray UI is refreshed

Pull-to-Refresh

Implement pull-to-refresh gestures or dedicated refresh buttons for user-initiated updates

Implementation Pattern

class NotificationTrayViewController: UIViewController {
    private let repository = AmityNotificationTrayRepository()
    
    override func viewWillAppear(_ animated: Bool) {
        super.viewWillAppear(animated)
        refreshTraySeenStatus()
    }
    
    private func refreshTraySeenStatus() {
        repository.getNotificationTraySeen { [weak self] result in
            DispatchQueue.main.async {
                switch result {
                case .success(let trayData):
                    self?.updateBadgeIndicator(hasUnseen: !trayData.isSeen)
                case .failure(let error):
                    self?.handleError(error)
                }
            }
        }
    }
}

⏱️ Polling Strategy (Use Sparingly)

Polling should be avoided unless absolutely necessary due to server rate limiting risks and battery drain concerns.

If polling is required:

Minimum interval: 120 seconds or more
Use case: Critical real-time applications only
Implementation: Include proper error handling and exponential backoff

class NotificationPollingManager {
    private let repository = AmityNotificationTrayRepository()
    private var timer: Timer?
    private let pollingInterval: TimeInterval = 120.0 // 2 minutes minimum
    
    func startPolling() {
        stopPolling() // Ensure no duplicate timers
        
        timer = Timer.scheduledTimer(withTimeInterval: pollingInterval, repeats: true) { [weak self] _ in
            self?.pollTrayStatus()
        }
    }
    
    func stopPolling() {
        timer?.invalidate()
        timer = nil
    }
    
    private func pollTrayStatus() {
        repository.getNotificationTraySeen { [weak self] result in
            switch result {
            case .success(let trayData):
                DispatchQueue.main.async {
                    self?.updateBadgeIndicator(!trayData.isSeen)
                }
            case .failure(let error):
                // Consider exponential backoff on errors
                print("Polling error: \(error)")
            }
        }
    }
    
    deinit {
        stopPolling()
    }
}

Cross-device Update Behavior

🔄 Local vs Cross-device Updates

🔗 Synchronization Patterns

📱 Multi-device Implementation

class CrossDeviceSyncManager {
    private let repository = AmityNotificationTrayRepository()
    
    // Call this when app becomes active
    func handleAppDidBecomeActive() {
        refreshFromServer()
    }
    
    // Call this when returning from background
    func handleAppWillEnterForeground() {
        refreshFromServer()
    }
    
    private func refreshFromServer() {
        repository.getNotificationTraySeen { [weak self] result in
            DispatchQueue.main.async {
                switch result {
                case .success(let trayData):
                    self?.syncLocalState(with: trayData)
                case .failure(let error):
                    self?.handleSyncError(error)
                }
            }
        }
    }
    
    private func syncLocalState(with trayData: AmityNotificationTraySeen) {
        // Update UI badges, counters, etc.
        NotificationCenter.default.post(
            name: .notificationTrayStateChanged,
            object: nil,
            userInfo: ["hasUnseen": !trayData.isSeen]
        )
    }
}

Error Handling

Common Error Scenarios

Error Handling Implementation

class NotificationTrayErrorHandler {
    private let repository = AmityNotificationTrayRepository()
    private var retryCount = 0
    private let maxRetries = 3
    
    func getNotificationTraySeenWithRetry(completion: @escaping (Result<AmityNotificationTraySeen, Error>) -> Void) {
        repository.getNotificationTraySeen { [weak self] result in
            switch result {
            case .success(let trayData):
                self?.retryCount = 0
                completion(.success(trayData))
                
            case .failure(let error):
                self?.handleError(error, completion: completion)
            }
        }
    }
    
    private func handleError(_ error: Error, completion: @escaping (Result<AmityNotificationTraySeen, Error>) -> Void) {
        guard retryCount < maxRetries else {
            completion(.failure(error))
            return
        }
        
        let delay = pow(2.0, Double(retryCount)) // Exponential backoff
        retryCount += 1
        
        DispatchQueue.main.asyncAfter(deadline: .now() + delay) { [weak self] in
            self?.getNotificationTraySeenWithRetry(completion: completion)
        }
    }
}

Best Practices

🎯 Implementation Guidelines

🔧 Performance Optimization

🎨 UI/UX Considerations

🔒 Security & Privacy

Mark Tray as Seen

Update the global tray seen timestamp

Mark Individual Items

Track seen status for specific notification items

Query Tray Items

Retrieve and filter notification tray items

Powered by

Getting Started

Fundamentals

Social

Chat

Video

Support

Get notification tray seen

Get Notification Tray Seen

Unseen Status Detection

Cross-device Sync

Overview

Refresh Strategies

UI-Triggered Updates

Pull-to-Refresh

Implementation Pattern

Cross-device Update Behavior

Same Client Updates

Cross-device Updates

Scenario 1: Same Device Update

Scenario 2: Cross-device Update

Error Handling

Network Connectivity

Rate Limiting

Authentication

Server Errors

Best Practices

Timing

Frequency

Mark Tray as Seen

Mark Individual Items

Query Tray Items

Powered by

Getting Started

Fundamentals

Social

Chat

Video

Support

​Get Notification Tray Seen

Unseen Status Detection

Cross-device Sync

​Overview

​Refresh Strategies

​Cross-device Update Behavior

​Error Handling

​Best Practices

​Related Documentation

Mark Tray as Seen

Mark Individual Items

Query Tray Items

Get Notification Tray Seen

Overview

Refresh Strategies

Cross-device Update Behavior

Error Handling

Best Practices

Related Documentation