Quickblox iOS：避免呼叫冲突问题咨询

Hey, I’ve built a couple of random peer-to-peer matching systems before, so I know exactly how frustrating this bidirectional call chaos can get—those overlapping requests and system overload are classic pitfalls when you let users initiate calls freely. Here’s how I solved similar issues:

1. Replace Peer-to-Peer Initiation with a Centralized Matching Service #

The root problem here is that every user is both initiating and listening for calls at the same time. Instead, shift control to a central server that manages a "waiting pool":

• When a user clicks "Call", they don’t create a session immediately—they send a request to the matching service to join the waiting queue.
• The service pairs the earliest user in the queue with the next available user, then only instructs one party (say, the first to join) to initiate the call to the other.
• This way, the receiving user is never in a state where they’re both waiting to initiate a call and receiving one—they only get a single incoming request when matched.

2. Implement a Strict User State Machine #

Every user should have a clear, enforced state that prevents conflicting actions. Define states like:

• idle: Not looking for a call
• waiting_for_match: In the queue, waiting to be paired
• calling: Initiating a matched call
• receiving_call: Got an incoming call, deciding to accept/reject
• on_call: Active call in progress

Key rules for state transitions:

• A user can only join the waiting queue if they’re in idle.
• While in waiting_for_match, calling, or receiving_call, block any new "Call" button clicks.
• When a user gets an incoming call, if they’re in waiting_for_match, remove them from the queue immediately and switch to receiving_call—reject any other pending match requests.

3. Add Timeouts & Cleanup for Stale Requests #

Unresolved calls will clog your system fast. Add safeguards:

• If a user waits in the match queue for >30 seconds, automatically remove them and reset to idle (show a "Match timed out—try again" message).
• If an incoming call isn’t answered within 10 seconds, auto-reject it, reset both users to idle, and free up their slots in the system.
• On the server side, run periodic jobs to clear out users stuck in inconsistent states (e.g., calling but no active session for 20 seconds).

4. Enforce Request Idempotency & Concurrency Limits #

• On the frontend: Disable the "Call" button as soon as it’s clicked, only re-enabling it when the user returns to idle.
• On the backend: For each user, reject any new match/call requests if there’s already an active one in progress. Use user IDs to track active requests and prevent duplicate submissions.

5. Simplify Matching Logic to Avoid Bidirectional Requests #

Stick to a first-in-first-out (FIFO) queue for matching:

• The matching service pulls the oldest user from the queue, then pulls the next available user, creates a one-way call instruction (User A → User B), and removes both from the queue.
• This eliminates the chance of two users trying to call each other simultaneously—only one initiator exists per pair.

Example Flow to Illustrate #

User A (idle) clicks "Call" → joins waiting queue, state becomes waiting_for_match
User B (idle) clicks "Call" → joins waiting queue, state becomes waiting_for_match
Matching service pairs A and B → tells A to initiate call to B (A switches to calling), tells B an incoming call is pending (B switches to receiving_call)
B accepts → both switch to on_call, session connects
B rejects → both switch back to idle, can re-join queue later

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