This is documentation for Stream Chat Android SDK v5, which is nolonger actively maintained. For up-to-date documentation, see the latest version (v6).

Debugging

ChatClientDebugger might be useful in investigation of issues happening on users side.

To debug various flows inside the SDK, you can pass your own ChatClientDebugger implementation:

val client = ChatClient.Builder("apiKey", context)
    .clientDebugger(CustomChatClientDebugger())
    .build()

ChatClient client = new ChatClient.Builder("apiKey", context)
    .clientDebugger(new CustomChatClientDebugger())
    .build()

Debug Message Sending

To debug a message sending flow you can override ChatClientDebugger.debugSendMessage function and provide your own SendMessageDebugger implementation:

class CustomChatClientDebugger : ChatClientDebugger {

    override fun onNonFatalErrorOccurred(
        tag: String,
        src: String,
        desc: String,
        error: ChatError
    ) {
        // TODO: Implement your custom logic here
    }

    override fun debugSendMessage(
        channelType: String,
        channelId: String,
        message: Message,
        isRetrying: Boolean,
    ): SendMessageDebugger {
        return CustomSendMessageDebugger(
            channelType,
            channelId,
            message,
            isRetrying
        )
    }
}

class CustomChatClientDebugger implements ChatClientDebugger {

    @Override
    public void onNonFatalErrorOccurred(
        @NonNull String tag,
        @NonNull String src,
        @NonNull String desc,
        @NonNull ChatError error
    ) {
        // TODO: Implement your custom logic here
    }

    @Override
    public SendMessageDebugger debugSendMessage(
        @NonNull String channelType,
        @NonNull String channelId,
        @NonNull Message message,
        boolean isRetrying
    ) {
        return new CustomSendMessageDebugger(
            channelType,
            channelId,
            message,
            isRetrying
        );
    }
}

Then in you custom SendMessageDebugger implementation you will be able to handle the entire message sending flow:

class CustomSendMessageDebugger(
    private val channelType: String,
    private val channelId: String,
    private val message: Message,
    private val isRetrying: Boolean,
) : SendMessageDebugger {

    override fun onStart(message: Message) {
        // Called when the message sending flow starts.
    }

    override fun onInterceptionStart(message: Message) {
        // Called when the message interception before sending it to the API starts.
        // Reasons for interception might be:
        //   - message attachment uploading
        //   - message enriching by all required information
    }

    override fun onInterceptionUpdate(message: Message) {
        // Called when there are intermediate message data updates.
    }

    override fun onInterceptionStop(result: Result<Message>) {
        // Called when the message interception before sending it to the API stops.
    }

    override fun onSendStart(message: Message) {
        // Called when the message sending to the API starts.
    }

    override fun onSendStop(result: Result<Message>) {
        // Called when the message sending to the API stops.
    }

    override fun onStop(result: Result<Message>) {
        // Called when the message sending flow stops.
    }
}

public class CustomSendMessageDebugger implements SendMessageDebugger {
    @NonNull
    private final String channelType;
    @NonNull
    private final String channelId;
    @NonNull
    private final Message message;
    @NonNull
    private final boolean isRetrying;

    public JavaSendMessageDebugger(
            @NonNull String channelType,
            @NonNull String channelId,
            @NonNull Message message,
            boolean isRetrying
    ) {
        this.channelType = channelType;
        this.channelId = channelId;
        this.message = message;
        this.isRetrying = isRetrying;
    }

    @Override
    public void onStart(@NonNull Message message) {
        // Called when the message sending flow starts.
    }

    @Override
    public void onInterceptionStart(@NonNull Message message) {
        // Called when the message interception before sending it to the API starts.
        // Reasons for interception might be:
        //   - message attachment uploading
        //   - message enriching by all required information
    }

    @Override
    public void onInterceptionUpdate(@NonNull Message message) {
        // Called when there are intermediate message data updates.
    }

    @Override
    public void onInterceptionStop(@NonNull Result<Message> result) {
        // Called when the message interception before sending it to the API stops.
    }

    @Override
    public void onSendStart(@NonNull Message message) {
        // Called when the message sending to the API starts.
    }

    @Override
    public void onSendStop(@NonNull Result<Message> result) {
        // Called when the message sending to the API stops.
    }

    @Override
    public void onStop(@NonNull Result<Message> result) {
        // Called when the message sending flow stops.
    }
}

Logging

Users