Événements sur mesure

Les événements personnalisés vous permettent d'ajouter des métadonnées personnalisées aux conversations en enregistrant des données avec vos événements textuels ou audio. Vous pouvez ajouter des événements en utilisant l'API REST ou l'un des SDK du client.

Créer un événement personnalisé

Chaque événement personnalisé consiste en un type et un data. Les type est soumis aux restrictions suivantes :

Ne doit pas dépasser 100 caractères
Doit contenir uniquement des caractères alphanumériques, - et _ personnages

En outre, l'événement data ne doit pas dépasser 4096 octets.

Once you've installed the JavaScript Client SDK and have a conversation object, you can call sendCustomEvent to add a custom event to the conversation.

conversation.sendCustomEvent({ type: 'my_custom_event', body: { your: 'data' }}).then((custom_event) => {
  console.log(custom_event);
});

conversation.sendCustomEvent("my_custom_event", hashMapOf("key" to "data"), object : NexmoRequestListener<Void> {
    override fun onError(apiError: NexmoApiError) {
        Log.d("TAG", "Custom event error")
    }

    override fun onSuccess(p0: Void?) {
        Log.d("TAG", "Custom event sent")
    }
})


HashMap<String, Object> data = new HashMap<>();
data.put("key", "data");

conversation.sendCustomEvent("my_custom_event", data, new NexmoRequestListener<Void>() {
    public void onSuccess(@Nullable Void p0) {
        Log.d("TAG", "Custom event sent");
    }

    public void onError(@NotNull NexmoApiError apiError) {
        Log.d("TAG", "Custom event error");
    }
});

Once you've installed the iOS Client SDK and have a conversation object, you can call sendCustom(withEvent: data: completionHandler:) to add a custom event to the conversation.

conversation.sendCustom(withEvent: "my_custom_event", data: ["your": "data"], completionHandler: { (error) in
    if let error = error {
        NSLog("Error sending custom event: \(error.localizedDescription)")
        return
    }
    NSLog("Custom event sent.")
})

Once you've installed the iOS Client SDK and have a conversation object, you can call sendCustomWithEvent:data:completionHandler: to add a custom event to the conversation.

[conversation sendCustomWithEvent:@"my_custom_event" data:@{@"your": @"data"} completionHandler:^(NSError * _Nullable error) {
    if (error) {
        NSLog(@"Error sending custom event: %@", error);
        return;
    }
    NSLog(@"Custom event sent.");
}];

Écouter les événements personnalisés

Outre l'ajout d'événements personnalisés à la conversation, vous pouvez écouter les événements personnalisés à l'aide du Client SDK. Enregistrez un gestionnaire d'événement qui écoute le nom de votre événement personnalisé :

conversation.on('my_custom_event', (from, event) => {
  console.log(event.body);
});

val customEventListener = NexmoCustomEventListener {
    Log.d("TAG", "Incoming custom event of type ${ it.customType} : ${it.data}")
}

conversation.addCustomEventListener(customEventListener)

private NexmoCustomEventListener customEventListener = new NexmoCustomEventListener() {
    @Override
    public void onCustomEvent(NexmoCustomEvent event) {
        Log.d("TAG", "Incoming custom event of type " + event.getCustomType() + ": " + event.getData());
    }
};

conversation.addCustomEventListener(customEventListener);

Implement conversation(_ conversation: NXMConversation, didReceive event: NXMCustomEvent), part of the NXMConversationDelegate protocol:

func conversation(_ conversation: NXMConversation, didReceive event: NXMCustomEvent) {
    NSLog("Received custom event with type \(String(describing: event.customType)): \(String(describing: event.data))");
}

Implement conversation:didReceiveCustomEvent::, part of the NXMConversationDelegate protocol:

- (void)conversation:(NXMConversation *)conversation didReceiveCustomEvent:(NXMCustomEvent *)event {
    NSLog(@"Received custom event with type %@: %@", event.customType, event.data);
}

Exemple complet

Here's an example application that registers a listener for my_custom_event, then emits that event:

Make sure to replace YOUR_JWT and YOUR_CONVERSATION_ID with the relevant values.

<script src="./node_modules/nexmo-client/dist/nexmoClient.js"></script>
<script>
  (async function() {
    let nexmo = new NexmoClient();
    let app = await nexmo.createSession(YOUR_JWT);
    let c = await app.getConversation(YOUR_CONVERSATION_ID);

    c.on('my_custom_event', (from, event) => {
        console.log(event.body);
    });

    c.sendCustomEvent({ type: 'my_custom_event', body: { your: 'data' }}).then((custom_event) => {
        console.log(custom_event);
    });
  })();
</script>

Troubleshooting

Object is missing self (me)

If you receive an error that states Object is missing self (me), ensure that the user you're authenticating as is a member of the conversation

class SendCustomEventActivity : AppCompatActivity() {

    private val customEventListener = NexmoCustomEventListener {
        Log.d("TAG", "Incoming custom event of type ${it.customType} : ${it.data}")
    }

    override fun onCreate(savedInstanceState: Bundle?, persistentState: PersistableBundle?) {
        super.onCreate(savedInstanceState, persistentState)

        // No need for client initialization here. Client initialization is already done in BaseApplication class.
        // NexmoClient.Builder().build(this)
        val client = NexmoClient.get()
        getConversation(client)
    }

    private fun getConversation(client: NexmoClient) {
        client.getConversation("CONVERSATION_ID", object : NexmoRequestListener<NexmoConversation> {
            override fun onSuccess(conversation: NexmoConversation?) {
                Log.d("TAG", "Conversation loaded")

                conversation?.let {
                    it.addCustomEventListener(customEventListener)
                    sendCustomEvent(it, "my_custom_event", hashMapOf("my_key" to "my_data"))
                }
            }

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

    private fun sendCustomEvent(conversation: NexmoConversation, eventType: String, data: HashMap<String, Any>) {
        conversation.sendCustomEvent(eventType, data, object : NexmoRequestListener<Void> {
            override fun onSuccess(p0: Void?) {
                Log.d("TAG", "Custom event sent")
            }

            override fun onError(apiError: NexmoApiError) {
                Log.d("TAG", "Custom event error")
            }
        })
    }
}

import android.os.Bundle;
import android.os.PersistableBundle;
import android.util.Log;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import com.nexmo.client.NexmoClient;
import com.nexmo.client.NexmoConversation;
import com.nexmo.client.NexmoCustomEvent;
import com.nexmo.client.NexmoCustomEventListener;
import com.nexmo.client.request_listener.NexmoApiError;
import com.nexmo.client.request_listener.NexmoRequestListener;
import org.jetbrains.annotations.NotNull;

import java.util.HashMap;

public class SendCustomEventActivity extends AppCompatActivity {

    private NexmoCustomEventListener customEventListener = new NexmoCustomEventListener() {
        @Override
        public void onCustomEvent(NexmoCustomEvent event) {
            Log.d("TAG", "Incoming custom event of type " + event.getCustomType() + ": " + event.getData());
        }
    };

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState, @Nullable PersistableBundle persistentState) {
        super.onCreate(savedInstanceState, persistentState);

        // No need for client initialization here. Client initialization is already done in BaseApplication class.
        // new NexmoClient.Builder().build(this);
        NexmoClient client = NexmoClient.get();
        client.login("JWT token");
        getConversation(client);

    }

    private void getConversation(NexmoClient client) {
        client.getConversation("CONVERSATION_ID", new NexmoRequestListener<NexmoConversation>() {
            @Override
            public void onSuccess(@Nullable NexmoConversation conversation) {
                Log.d("TAG", "Conversation loaded");

                conversation.addCustomEventListener(customEventListener);

                HashMap<String, Object> data = new HashMap<>();
                data.put("my_key", "my_data");
                sendCustomEvent(conversation, "my_custom_event", data);
            }

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

    private void sendCustomEvent(@NonNull NexmoConversation conversation, String eventType, HashMap<String, Object> data) {
        conversation.sendCustomEvent(eventType, data, new NexmoRequestListener<Void>() {
            public void onSuccess(@Nullable Void p0) {
                Log.d("TAG", "Custom event sent");
            }

            public void onError(@NotNull NexmoApiError apiError) {
                Log.d("TAG", "Custom event error");
            }
        });
    }
}

class ConversationViewController: UIViewController {

    var error: Error?
    var conversation: NXMConversation?

    override func viewDidLoad() {
        super.viewDidLoad()
        getConversation()
    }

    func getConversation() {
        NXMClient.shared.getConversationWithUuid(conversationId) { [weak self] (error, conversation) in
            self?.error = error
            self?.conversation = conversation
            conversation?.delegate = self
        }
    }

    func sendCustomEvent() {
        conversation?.sendCustom(withEvent: "my_custom_event", data: ["your": "data"], completionHandler: { (error) in
            if let error = error {
                NSLog("Error sending custom event: \(error.localizedDescription)")
                return
            }
            NSLog("Custom event sent.")
        })
    }

}

//MARK: Conversation Delegate

extension ConversationViewController: NXMConversationDelegate {
    func conversation(_ conversation: NXMConversation, didReceive error: Error) {
        NSLog("Conversation error: \(error.localizedDescription)")
    }

    func conversation(_ conversation: NXMConversation, didReceive event: NXMCustomEvent) {
        NSLog("Received custome type \(String(describing: event.customType)): \(String(describing: event.data))");
    }
}

@interface ConversationViewController () <NXMConversationDelegate>

@property NSError *error;
@property NXMConversation *conversation;

@end

@implementation ConversationViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    [self getConversation];
}

- (void)getConversation {
    [NXMClient.shared getConversationWithUuid:conversationUUID completionHandler:^(NSError * _Nullable error, NXMConversation * _Nullable conversation) {
        self.error = error;
        self.conversation = conversation;
        [conversation setDelegate:self];
    }];
}

- (void)sendCustomEvent {
    [self.conversation sendCustomWithEvent:@"my_custom_event" data:@{@"your": @"data"} completionHandler:^(NSError * _Nullable error) {
        if (error) {
            NSLog(@"Error sending custom event: %@", error);
            return;
        }
        NSLog(@"Custom event sent.");
    }];
}

//MARK: Conversation Delegate

- (void)conversation:(NXMConversation *)conversation didReceive:(NSError *)error {
    NSLog(@"Conversation error: %@", error.localizedDescription);
}

- (void)conversation:(NXMConversation *)conversation didReceiveCustomEvent:(NXMCustomEvent *)event {
    NSLog(@"Received custome type %@: %@", event.customType, event.data);
}
@end