Einladende Mitglieder

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.

Übersicht

Dieser Leitfaden behandelt das Einladen von Nutzern in eine Unterhaltung (Mitglieder), das Abhören von Einladungen zum Beitritt zu einer Unterhaltung sowie den Beitritt neuer Mitglieder.

Bevor Sie beginnen, stellen Sie sicher, dass Sie das SDK zu Ihrer Anwendung hinzugefügt und Sie sind in der Lage ein Gespräch führen.

HINWEIS: Eine Schritt-für-Schritt-Anleitung zur Erstellung einer Chat-Anwendung ist verfügbar hier.

In diesem Leitfaden werden Sie mit den folgenden Concepts vertraut gemacht.

Einladungen - Sie können Benutzer zu einem Gespräch einladen
Application-Ereignisse - member:invited Ereignisse, die in einer Applikation ausgelöst werden, bevor Sie Mitglied einer Konversation sind
Konversation Veranstaltungen - member:joined und text Ereignisse, die bei einer Konversation ausgelöst werden, nachdem Sie ein Mitglied sind

Auf Gesprächseinladungen achten und sie annehmen

Erreicht durch Hinzufügen eines Listeners auf der application Objekt für die member:invited Veranstaltung:

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);

hinzufügen NXMClientDelegate als Erweiterung zu einer ViewController oder ähnlich, und implementieren client(_ client: NXMClient, didReceive conversation: NXMConversation):

Hinweis: Die ersten beiden Methoden unten sind erforderlich, wenn Sie 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.")
        }
    }
}

Haben Sie eine ViewControlleroder ähnlich, entsprechen NXMClientDelegate und umsetzen client:didReceiveConversation::

Hinweis: Die ersten beiden Methoden unten sind erforderlich, wenn Sie 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.");
    }];
}

Abhören von Mitgliedern, die sich an einem Gespräch beteiligt haben

Hören Sie auf die member:joined Ereignis auf das Gespräch:

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);

hinzufügen NXMConversationDelegate als Erweiterung zu einer ViewController oder ähnlich, und implementieren conversation(_ conversation: NXMConversation, didReceive event: NXMMemberEvent):

Hinweis: Die erste Methode unten ist erforderlich, wenn die 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.")
        }
    }
}

Haben Sie eine ViewControlleroder ähnlich, entsprechen NXMConversationDelegate und umsetzen conversation:didReceiveImageEvent::