Manage Blocked Users

​

Product Behavior

• The blocked users list displays:
  • User ID
  • Display Name
  • Avatar
  • Other relevant user information
• Only active users you have blocked are shown
• You cannot see users who have blocked you

​

Get Blocked Users List (Paginated)

​

How It Works

• Live collection — Results are returned as a live collection
• Paginated — Results are loaded in pages. Use the platform’s pagination mechanism to load additional pages on demand.

​

Parameters

​

Usage

// Observe blocked users list
let token = userRepository.getBlockedUsers().observe { liveCollection, _, error in
    // Handle liveCollection (list of blocked users)
    // Handle error if needed
}

​

Get All Blocked Users (Non-Paginated)

​

How It Works

• One-shot result — Returns the full blocked users list as a single async response, not a live collection.
• Built-in caching — The SDK caches the result for 5 minutes. The first call fetches from the server; subsequent calls within the TTL window resolve instantly from the local cache.
• Cache refresh — After 5 minutes, the next call triggers a fresh server fetch.
• Local changes — If you block or unblock a user between calls, the local cache is updated immediately. The next getAllBlockedUsers() call reflects the change even without a server fetch.
• Session-aware — The cache resets on logout. After re-login, the next call fetches fresh data.

​

Usage

import AmitySDK

let userRepository = AmityUserRepository(client: client)

userRepository.getAllBlockedUsers { result in
    switch result {
    case .success(let blockedUsers):
        print("Blocked users: \(blockedUsers.count)")
        for user in blockedUsers {
            print("- \(user.displayName ?? user.userId)")
        }
    case .failure(let error):
        print("Failed to get blocked users: \(error)")
    }
}

import com.amity.socialcloud.sdk.api.core.AmityCoreClient

val userRepository = AmityCoreClient.newUserRepository()

userRepository.getAllBlockedUsers()
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(
        { blockedUsers: List<AmityUser> ->
            println("Blocked users: ${blockedUsers.size}")
            blockedUsers.forEach { user ->
                println("- ${user.getDisplayName()}")
            }
        },
        { error ->
            println("Failed to get blocked users: ${error.message}")
        }
    )

​

Use Case: Feed Filtering

// Get all blocked user IDs for local filtering
userRepository.getAllBlockedUsers { result in
    switch result {
    case .success(let blockedUsers):
        let blockedUserIds = Set(blockedUsers.map { $0.userId })
        // Use blockedUserIds to filter feed content locally
    case .failure(let error):
        // Handle error — do not assume empty block list
        print("Error: \(error)")
    }
}

userRepository.getAllBlockedUsers()
    .subscribe(
        { blockedUsers ->
            val blockedUserIds = blockedUsers.map { it.getUserId() }.toSet()
            // Use blockedUserIds to filter feed content locally
        },
        { error ->
            // Handle error — do not assume empty block list
        }
    )

​

Limitations

• Hard limit of 100 users — Returns a maximum of 100 blocked users. If a user has more than 100 blocked users, only the most recent 100 are returned.
• Not a live collection — The result is a one-shot snapshot. It does not automatically update when block/unblock actions occur. Call the function again to get the latest list.
• Error propagation — If the server fetch fails (e.g., network error), the error is propagated to the caller. The SDK does not return a stale cached list on failure.

​

Best Practices