终止成员连接

import { BirdRealtime } from "@messagebird/realtime";

const bird = new BirdRealtime({
  appKey: "your-app-key",
  region: "us1",
  memberAuthEndpoint: "/bird/auth/member",
});

const member = await bird.signin();
console.log("signed in as", member.member_id);

import BirdRealtime

let bird = BirdRealtime(options: .init(
    appKey: "your-app-key",
    region: "us1",
    memberAuthEndpoint: URL(string: "https://your-backend.example.com/bird/auth/member")
))

let member = try await bird.signin()
print("signed in as", member.memberId)

import com.bird.realtime.BirdRealtime
import com.bird.realtime.BirdRealtimeOptions

val bird = BirdRealtime(
    BirdRealtimeOptions(
        appKey = "your-app-key",
        region = "us1",
        memberAuthEndpoint = "https://your-backend.example.com/bird/auth/member",
    )
)

val member = bird.signin() // suspending
println("signed in as ${member.memberId}")

import { createHmac } from "node:crypto";

app.post("/bird/auth/member", (req, res) => {
  const { connection_id } = req.body;

  // Your own decision: who is this caller, and may they connect at all?
  const user = getUserFromSession(req);
  if (!user) return res.sendStatus(403);

  const memberData = JSON.stringify({
    member_id: user.id,
    member_info: { name: user.name },
  });
  const sig = createHmac("sha256", process.env.BIRD_REALTIME_SECRET)
    .update(`${connection_id}::member::${memberData}`)
    .digest("hex");

  res.json({ auth: `${process.env.BIRD_REALTIME_KEY}:${sig}`, member_data: memberData });
});

import hmac, hashlib, json, os

def sign_in(connection_id: str, user) -> dict:
    key = os.environ["BIRD_REALTIME_KEY"]
    secret = os.environ["BIRD_REALTIME_SECRET"].encode()

    member_data = json.dumps({"member_id": user.id, "member_info": {"name": user.name}})
    to_sign = f"{connection_id}::member::{member_data}"
    sig = hmac.new(secret, to_sign.encode(), hashlib.sha256).hexdigest()
    return {"auth": f"{key}:{sig}", "member_data": member_data}

func signIn(connectionID string, user User) (map[string]string, error) {
	key := os.Getenv("BIRD_REALTIME_KEY")
	secret := []byte(os.Getenv("BIRD_REALTIME_SECRET"))

	memberData, err := json.Marshal(map[string]any{
		"member_id":   user.ID,
		"member_info": map[string]string{"name": user.Name},
	})
	if err != nil {
		return nil, err
	}

	mac := hmac.New(sha256.New, secret)
	mac.Write([]byte(connectionID + "::member::" + string(memberData)))
	return map[string]string{
		"auth":        key + ":" + hex.EncodeToString(mac.Sum(nil)),
		"member_data": string(memberData),
	}, nil
}

function signIn(string $connectionId, User $user): array
{
    $key = getenv('BIRD_REALTIME_KEY');
    $secret = getenv('BIRD_REALTIME_SECRET');

    $memberData = json_encode(['member_id' => $user->id, 'member_info' => ['name' => $user->name]]);
    $sig = hash_hmac('sha256', "{$connectionId}::member::{$memberData}", $secret);

    return ['auth' => "{$key}:{$sig}", 'member_data' => $memberData];
}

await bird.realtime.members.disconnect("rap_01krdgeqcxet5s7t44vh8rt9mg", "u_42");

client.realtime.members.disconnect("rap_01krdgeqcxet5s7t44vh8rt9mg", "u_42")

if err := client.Realtime.Members.Disconnect(context.Background(), "rap_01krdgeqcxet5s7t44vh8rt9mg", "u_42"); err != nil {
	log.Fatal(err)
}

$bird->realtime->members->disconnect('rap_01krdgeqcxet5s7t44vh8rt9mg', 'u_42');

curl -X POST \
  https://us1.platform.bird.com/v1/realtime/apps/rap_01krdgeqcxet5s7t44vh8rt9mg/members/u_42/disconnect \
  -H "Authorization: Bearer $BIRD_API_KEY" \
  -H "X-Realtime-Key: $BIRD_REALTIME_KEY" \
  -H "X-Realtime-Secret: $BIRD_REALTIME_SECRET"

bird.connection.bind("error", (e) => {
  if (e.code === 4009) showSignedOutScreen();
});

bird.onError { error in
    if error.code == 4009 { showSignedOutScreen() }
}

bird.onError { error ->
    if (error.code == 4009) showSignedOutScreen()
}

bird.connection.bind("signin_error", (e) => {
  console.warn("connection has no identity:", e.message);
});

bird.onSigninError { error in
    print("connection has no identity:", error.message)
}

bird.onSigninError { error ->
    println("connection has no identity: ${error.message}")
}