Event-driven conversations using an activity handler

To implement your logic for these handlers, you'll override these methods in your bot, such as in the sample activity handler section below. For each of these handlers, there's no base implementation, so just add the logic that you want in your override.

There are certain situations where you'll want to override the base turn handler, such as saving state at the end of a turn. When doing so, be sure to first call await base.OnTurnAsync(turnContext, cancellationToken); to make sure the base implementation of OnTurnAsync is run before your additional code. That base implementation is, among other things, responsible for calling the rest of the activity handlers such as OnMessageActivityAsync.

The JavaScript ActivityHandler uses an event emitter and listener pattern. For example, use the onMessage method to register an event listener for message activities. You can register more than one listener. When the bot receives a message activity, the activity handler would see that incoming activity and send it each of the onMessage activity listeners, in the order in which they were registered.

When building your bot, your bot logic for handling and responding to messages will go in the onMessage listeners. Likewise, your logic for handling members being added to the conversation will go in your onMembersAdded listeners, which are called whenever a member is added to the conversation. To add these listeners, you'll register them in your bot as seen in the Bot logic section below. For each listener, include your bot logic, then be sure to call next() at the end. By calling next(), you ensure that the next listener is run.

Make sure to save state before the turn ends. You can do so by overriding the activity handler run method and saving state after the parent's run method completes.

There are no common situations where you'll want to override the base turn handler, so be careful if you try to do so. There's a special handler called onDialog. The onDialog handler runs at the end, after the rest of the handlers have run, and isn't tied to a certain activity type. As with all the above handlers, be sure to call next() to ensure the rest of the process wraps up.

To implement your logic for these handlers, you'll override these methods in your bot, such as in the sample activity handler section below. There's no base implementation for each of these handlers, so add the logic you want in your override.

There are certain situations where you'll want to override the base turn handler, such as saving state at the end of a turn. When doing so, be sure first to call super.onTurn(turnContext); to make sure the base implementation of onTurn is run before your additional code. That base implementation is, among other things, responsible for calling the rest of the activity handlers such as onMessageActivity.

When building your bot, your bot logic for handling and responding to messages will go in this on_message_activity handler. Likewise, your logic for handling members being added to the conversation will go in your on_members_added handler, which is called whenever a member is added to the conversation.

For example, if the bot receives a message activity, the turn handler would see that incoming activity and send it to the on_message_activity activity handler.

To implement your logic for these handlers, you'll override these methods in your bot, such as in the sample activity handler section below. For each of these handlers, there's no base implementation, so just add the logic that you want in your override.

There are certain situations where you'll want to override the base turn handler, such as saving state at the end of a turn. When doing so, be sure to first call await super().on_turn(turnContext); to make sure the base implementation of on_turn is run before your additional code. That base implementation is, among other things, responsible for calling the rest of the activity handlers such as on_message_activity.

The main bot logic is defined in the bot code. To implement a bot as an activity handler, derive your bot class from ActivityHandler, which implements the IBot interface. ActivityHandler defines various handlers for different types of activities, such as OnMessageActivityAsync, and OnMembersAddedAsync. These methods are protected, but can be overridden, since we're deriving from ActivityHandler.

The handlers defined in ActivityHandler are:

These different handlers have a turnContext that provides information about the incoming activity, which corresponds to the inbound HTTP request. Activities can be of various types, so each handler provides a strongly-typed activity in its turn context parameter; in most cases, OnMessageActivityAsync will always be handled, and is generally the most common.

As in previous 4.x versions of this framework, there's also the option to implement the public method OnTurnAsync. Currently, the base implementation of this method handles error checking and then calls each of the specific handlers (like the two we define in this sample) depending on the type of incoming activity. In most cases, you can leave that method alone and use the individual handlers, but if your situation requires a custom implementation of OnTurnAsync, it's still an option.

The main bot logic is defined in the bot code. To implement a bot as an activity handler, extend ActivityHandler. ActivityHandler defines various events for different types of activities, and you can modify your bot's behavior by registering event listeners, such as with onMessage and onConversationUpdate.

Use these methods to register listeners for each type of event:

Call the next continuation function from each handler to allow processing to continue. If next isn't called, processing of the activity ends.

The main bot logic is defined in the bot code. To implement a bot as an activity handler, derive your bot class from ActivityHandler, which implements the Bot interface. ActivityHandler defines various handlers for different types of activities, such as onMessageActivity, and onMembersAdded. These methods are protected, but can be overridden, since we're deriving from ActivityHandler.

The handlers defined in ActivityHandler are:

These different handlers have a turnContext that provides information about the incoming activity, which corresponds to the inbound HTTP request. Activities can be of various types, so each handler provides a strongly-typed activity in its turn context parameter; in most cases, onMessageActivity will always be handled, and is generally the most common.

There's also the option to implement the public method onTurn. Currently, the base implementation of this method handles error checking and then calls each of the specific handlers (like the two we define in this sample) depending on the type of incoming activity. In most cases, you can leave that method alone and use the individual handlers, but if your situation requires a custom implementation of onTurn, it's still an option.

The main bot logic is defined in the bot code. To implement a bot as an activity handler, derive your bot class from ActivityHandler, which in turn derives from the abstract Bot class. ActivityHandler defines various handlers for different types of activities, such as on_message_activity and on_members_added. These methods are protected, but can be overridden, since we're deriving from ActivityHandler.

The handlers defined in ActivityHandler are:

These different handlers have a turn_context that provides information about the incoming activity, which corresponds to the inbound HTTP request. Activities can be of various types, so each handler provides a strongly-typed activity in its turn context parameter; in most cases, on_message_activity will always be handled, and is generally the most common.

As in previous 4.x versions of this framework, there's also the option to implement the public method on_turn. Currently, the base implementation of this method handles error checking and then calls each of the specific handlers (like the two we define in this sample) depending on the type of incoming activity. In most cases, you can leave that method alone and use the individual handlers, but if your situation requires a custom implementation of on_turn, it's still an option.

public class EchoBot : ActivityHandler
{
    protected override async Task OnMessageActivityAsync(ITurnContext<IMessageActivity> turnContext, CancellationToken cancellationToken)
    {
        var replyText = $"Echo: {turnContext.Activity.Text}";
        await turnContext.SendActivityAsync(MessageFactory.Text(replyText, replyText), cancellationToken);
    }

    protected override async Task OnMembersAddedAsync(IList<ChannelAccount> membersAdded, ITurnContext<IConversationUpdateActivity> turnContext, CancellationToken cancellationToken)
    {
        var welcomeText = "Hello and welcome!";
        foreach (var member in membersAdded)
        {
            if (member.Id != turnContext.Activity.Recipient.Id)
            {
                await turnContext.SendActivityAsync(MessageFactory.Text(welcomeText, welcomeText), cancellationToken);
            }
        }
    }
}

class EchoBot extends ActivityHandler {
    constructor() {
        super();
        // See https://aka.ms/about-bot-activity-message to learn more about the message and other activity types.
        this.onMessage(async (context, next) => {
            const replyText = `Echo: ${ context.activity.text }`;
            await context.sendActivity(MessageFactory.text(replyText, replyText));
            // By calling next() you ensure that the next BotHandler is run.
            await next();
        });

        this.onMembersAdded(async (context, next) => {
            const membersAdded = context.activity.membersAdded;
            const welcomeText = 'Hello and welcome!';
            for (let cnt = 0; cnt < membersAdded.length; ++cnt) {
                if (membersAdded[cnt].id !== context.activity.recipient.id) {
                    await context.sendActivity(MessageFactory.text(welcomeText, welcomeText));
                }
            }
            // By calling next() you ensure that the next BotHandler is run.
            await next();
        });
    }
}

public class EchoBot extends ActivityHandler {

    @Override
    protected CompletableFuture<Void> onMessageActivity(TurnContext turnContext) {
        return turnContext.sendActivity(
            MessageFactory.text("Echo: " + turnContext.getActivity().getText())
        ).thenApply(sendResult -> null);
    }

    @Override
    protected CompletableFuture<Void> onMembersAdded(
        List<ChannelAccount> membersAdded,
        TurnContext turnContext
    ) {
        String welcomeText = "Hello and welcome!";
        return membersAdded.stream()
            .filter(
                member -> !StringUtils
                    .equals(member.getId(), turnContext.getActivity().getRecipient().getId())
            ).map(channel -> turnContext.sendActivity(MessageFactory.text(welcomeText, welcomeText, null)))
            .collect(CompletableFutures.toFutureList()).thenApply(resourceResponses -> null);
    }
}

class EchoBot(ActivityHandler):
    async def on_members_added_activity(
        self, members_added: [ChannelAccount], turn_context: TurnContext
    ):
        for member in members_added:
            if member.id != turn_context.activity.recipient.id:
                await turn_context.send_activity("Hello and welcome!")

    async def on_message_activity(self, turn_context: TurnContext):
        return await turn_context.send_activity(
            MessageFactory.text(f"Echo: {turn_context.activity.text}")
        )