Inviter des membres

Product deprecation notice

Effective April 30th, 2026, Vonage In-App Messaging will no longer be available. Access for new users will be closed, and the service will be discontinued for all existing users.

If you have any questions regarding this product’s discontinuation, please contact your account manager or our support team.

Vue d'ensemble

Ce guide traite de l'invitation d'utilisateurs à une conversation (membres), de l'écoute des invitations à rejoindre une conversation et de l'arrivée de nouveaux membres.

Avant de commencer, assurez-vous que ajouter le SDK à votre application et vous êtes en mesure de créer une conversation.

NOTE: A step-by-step tutorial to build a chat application is available here.

Ce guide vous présentera les concepts suivants.

Invitations - vous pouvez inviter des utilisateurs à une conversation
Applications - member:invited les événements qui se déclenchent sur une Applications, avant que vous ne soyez membre d'une Conversation
Événements de conversation - member:joined et text les événements qui se déclenchent sur une conversation, une fois que vous êtes membre

Écouter les invitations à la conversation et les accepter

Achieved by adding a listener on the application object for the member:invited event:

app.on("member:invited", (member, event) => {
  //identify the sender and type of conversation.
  if (event.body.cname.indexOf("CALL") != 0 && member.invited_by) {
    console.log("*** Invitation received:", event);

    //accept an invitation.
    app.getConversation(event.cid || event.body.cname)
      .then((conversation) => {
        conversation
          .join()
          .then(() => {
            ...
          })
          .catch(this.errorLogger)
      })
      .catch(this.errorLogger)
  }
})

private val memberEventListener = object : NexmoMemberEventListener {
    override fun onMemberInvited(event: NexmoMemberEvent, member: NexmoMemberSummary) {    
        Log.d("TAG", "Member ${event.embeddedInfo.user.name} invited to the conversation");

        // Join user to the conversation (accept the invitation)
        conversation?.join(event.embeddedInfo.user.name, joinConversationListener)
    }

    override fun onMemberAdded(event: NexmoMemberEvent, member: NexmoMemberSummary) {}
    
    override fun onMemberRemoved(event: NexmoMemberEvent, member: NexmoMemberSummary) {}
}

private val joinConversationListener = object: NexmoRequestListener<String>{
    override fun onSuccess(memberId: String?) {
        Log.d("TAG", "Member joined the conversation $memberId")
    }

    override fun onError(apiError: NexmoApiError) {
        Log.d("TAG", "Error: Unable to join member to the conversation $apiError")
    }
}

conversation?.addMemberEventListener(memberEventListener)

NexmoMemberEventListener memberEventListener = new NexmoMemberEventListener() {
    @Override
    public void onMemberInvited(@NonNull @NotNull NexmoMemberEvent event, @NonNull @NotNull NexmoMemberSummary member) {
        Log.d("TAG", "Member " + event.embeddedInfo().getUser().getName() + " invited to the conversation");

        // Join user to the conversation (accept the invitation)
        conversation.join(event.embeddedInfo().getUser().getName(), joinConversationListener);
    }

    @Override
    public void onMemberAdded(@NonNull @NotNull NexmoMemberEvent event, @NonNull @NotNull NexmoMemberSummary member) {}

    @Override
    public void onMemberRemoved(@NonNull @NotNull NexmoMemberEvent event, @NonNull @NotNull NexmoMemberSummary member) {}
};

NexmoRequestListener<String> joinConversationListener = new NexmoRequestListener<String>() {
    @Override
    public void onSuccess(@Nullable String memberId) {
        Log.d("TAG", "Member joined the conversation " + memberId);
    }

    @Override
    public void onError(@NonNull NexmoApiError apiError) {
        Log.d("TAG", "Error: Unable to join member to the conversation " + apiError);
    }
};

conversation.addMemberEventListener(memberEventListener);

Add NXMClientDelegate as an extension to a ViewController or similar, and implement client(_ client: NXMClient, didReceive conversation: NXMConversation):

Note: The first 2 methods below are required when implementing NXMClientDelegate:

extension ViewController: NXMClientDelegate {
    
    func client(_ client: NXMClient, didChange status: NXMConnectionStatus, reason: NXMConnectionStatusReason) {
        ...
    }
    
    func client(_ client: NXMClient, didReceiveError error: Error) {
        print("✆  ‼️ connection error: \(error.localizedDescription)")
        ...
    }

    func client(_ client: NXMClient, didReceive conversation: NXMConversation) {
        conversation.join { (error, member) in
            if let error = error {
                NSLog("Error joining conversation: \(error.localizedDescription)")
                return
            }
            NSLog("Conversation joined.")
        }
    }
}

Have a ViewController, or similar, conform to NXMClientDelegate and implement client:didReceiveConversation::

Note: The first 2 methods below are required when implementing NXMClientDelegate:

- (void)client:(nonnull NXMClient *)client didChangeConnectionStatus:(NXMConnectionStatus)status reason:(NXMConnectionStatusReason)reason {
    ...
}

- (void)client:(nonnull NXMClient *)client didReceiveError:(nonnull NSError *)error {
    NSLog(@"✆  ‼️ connection error: %@", [error localizedDescription]);
    ...
}

- (void)client:(NXMClient *)client didReceiveConversation:(NXMConversation *)conversation {
    [conversation join:^(NSError * _Nullable error, NXMMember * _Nullable member) {
        if (error) {
            NSLog(@"Error joining conversation: %@", error.localizedDescription);
            return;
        }
        NSLog(@"Conversation joined.");
    }];
}

Écoute des membres qui ont rejoint une conversation

Listen for the member:joined event on the conversation:

conversation.on("member:joined", (member, event) => {
  const date = new Date(Date.parse(event.timestamp))
  console.log(`*** ${member.user.name} joined the conversation`)
  ...
})


private val memberEventListener = object : NexmoMemberEventListener {
    override fun onMemberInvited(memberEvent: NexmoMemberEvent) {}

    override fun onMemberAdded(memberEvent: NexmoMemberEvent) {
        Log.d("TAG", "Member ${memberEvent.embeddedInfo.user.name} added to the conversation")
    }

    override fun onMemberRemoved(memberEvent: NexmoMemberEvent) {}
}

conversation?.addMemberEventListener(memberEventListener)

NexmoMemberEventListener memberEventListener = new NexmoMemberEventListener() {
    @Override
    public void onMemberInvited(@NonNull NexmoMemberEvent memberEvent) {}

    @Override
    public void onMemberAdded(@NonNull NexmoMemberEvent memberEvent) {
        Log.d("TAG", "Member " + memberEvent.getEmbeddedInfo().getUser().getName() + " added the conversation");
    }

    @Override
    public void onMemberRemoved(@NonNull NexmoMemberEvent memberEvent) {}
};

conversation.addMemberEventListener(memberEventListener);

Add NXMConversationDelegate as an extension to a ViewController or similar, and implement conversation(_ conversation: NXMConversation, didReceive event: NXMMemberEvent):

Note: The first method below is required when implementing NXMConversationDelegate:

extension ViewController: NXMConversationDelegate {
    func conversation(_ conversation: NXMConversation, didReceive error: Error) {
        NSLog("Conversation error: \(error.localizedDescription)")
    }
    func conversation(_ conversation: NXMConversation, didReceive event: NXMMemberEvent) {
        if event.state == .joined {
            NSLog("\(event.embeddedInfo?.user.name) joined.")
        }
    }
}

Have a ViewController, or similar, conform to NXMConversationDelegate and implement conversation:didReceiveImageEvent::