Feature flag: timestampType: TimestampMode.RELATIVE

You can enable absolute or relative timestamps for chat messages. Absolute timestamps display the exact time for each message. Relative timestamps display only on the latest message and express the time in terms of the seconds, days, hours, months, or years ago relative to the previous message.The precision afforded by absolute timestamps make them ideal for archival tasks, but within the limited context of a chat session, this precision detracts from the user experience because users must compare timestamps to find out the passage of time between messages. Relative timestamps allow users to track the conversation easily through terms like Just Now and A few moments ago that can be immediately understood. Relative timestamps improve the user experience in another way while also simplifying your development tasks: because relative timestamps mark the messages in terms of seconds, days, hours, months, or years ago, you don't need to convert them for timezones.

Feature flag: actionsLayout

actionsLayout sets layout direction for the local, global, card and form actions. When you set this as LayoutOrientation.HORIZONTAL, these buttons are laid out horizontally and will wrap if the content overflows.

BotsConfiguration botsConfiguration = new BotsConfiguration.BotsConfigurationBuilder(<Server_URI>, false, getApplicationContext())
        .channelId(<CHANNEL_ID>)
        .userId(<USER_ID>)
        .actionsLayout(actionsLayout)
        .build();

(Required) <Enter a short description here.>

Feature flag: shareMenuItems

ArrayList<Object> customItems = new ArrayList<>();
        ShareMenuCustomItem shareMenuCustomItem1  = new ShareMenuCustomItem("pdf bin", "Label1", 1024, R.drawable.odaas_menuitem_share_file);
        ShareMenuCustomItem shareMenuCustomItem2  = new ShareMenuCustomItem("doc", "Label2", R.drawable.odaas_menuitem_share_file);
        ShareMenuCustomItem shareMenuCustomItem3  = new ShareMenuCustomItem("csv");
        ArrayList<Object> customItems = new ArrayList<>(Arrays.asList(shareMenuCustomItem1,shareMenuCustomItem2,shareMenuCustomItem3,ShareMenuItem.CAMERA));
        BotsConfiguration botsConfiguration = new BotsConfiguration.BotsConfigurationBuilder(sharedPreferences.getString(getString(R.string.pref_name_chat_server_host), Settings.CHAT_SERVER_URL), false, getApplicationContext())
        .channelId(<CHANNEL_ID>)
        .userId(<USER_ID>)
        .shareMenuItems(customItems)
        .enableAttachment(true)
        .build();

When a field has the autoSubmit property set to true, the client sends a FormSubmissionMessagePayload with the submittedField map containing either the valid field values that have been entered so far. Any fields that are not set yet (regardless of whether they are required), or fields that violate a client-side validation are not included in the submittedField map. If the auto-submitted field itself contains a value that's not valid, then the submission message is not sent and the client error message displays for that particular field. When an auto-submit succeeds, the partialSubmitField in the form submission message will be set to the id of the autoSubmit field.

Feature flag: enableDefaultClientResponse: true (default: false)

Use enableDefaultClientResponse: true to provide default client-side responses accompanied by a typing indicator when the skill response has been delayed, or when there's no skill response at all. If the user sends out the first message/query, but the skill does not respond with the number of seconds set by the odaas_default_greeting_timeout flag, the skill can display a greeting message that's configured using the odaas_default_greeting_message translation string. Next, the client checks again for the skill's response. The client displays the skill's response if it has been received, but if it hasn't, then the client displays a wait message (configured with the odaas_default_wait_message translation string) at intervals set by the odaas_default_wait_message_interval flag. When the wait for the skill response exceeds the threshold set by the typingIndicatorTimeout flag, the client displays a sorry response to the user and stops the typing indicator. You can configure the sorry response using the odaas_default_sorry_message translation string.

Feature configuration: messageModifierDelegate

private MessageDelegate implements MessageModifierDelegate {
    @Override
    public Message beforeSend(Message message) {
        // Handle before send delegate here
    }

    @Override
    public Message beforeDisplay(Message message) {
        if (message != null && message.getPayload() != null && message.getPayload().getType() == MessagePayload.MessageType.CARD) {
            ((CardMessagePayload)message.getPayload()).setLayout(CardLayout.VERTICAL);
        }
        return message;
    }

    @Override
    public Message beforeNotification(Message message) {
        // Handle before notification delegate here
    }
}
    @Override
    public void beforeEndConversation(CompletionHandler completionHandler) {
        // Handle before end conversation end delegate here
        // Trigger completionHandler.onSuccess() callback after successful execution of the task.
        // Trigger completionHandler.onFailure() callback when the task is unsucessful.
        }
        }

You can either enable or display of a user's local conversation histor after the SDK has been re-initialized by setting displayPreviousMessages to true or false in the bots configuration. When set to false, previous messages are not displayed for the user, after re-initialization of SDK.

FeatureFlag: enableEndConversation: true

enableEndConversation: true adds a close button to the header view that enables users to explicitly end the current chat session. A confirmation prompt dialog opens when users click this close button and when they confirm the close action, the SDK sends an event message to the skill that marks the end of the chat session. The SDK then disconnects the skill from the instance, collapses the chat widget, and erases the current user's conversation history. The SDK triggers a delegate on beforeEndConversation(CompletionHandler completionHandler) which can be used to perform a task before sending close session request to server. It also raises a OnChatEnd() event that you can register for.

Opening the chat widget afterward starts a new chat session.

The SDK can be used without its UI. To use it in this mode, import only the com.oracle.bots.client.sdk.android.core-24.04.aar package into the project as described in Add the Oracle Android Client SDK to the Project.

The SDK maintains the connection to server and provides APIs to send messages, receive messages, and get updates for the network status and for other services. You can use the APIs to interact with the SDK and update the UI.

You can send a message using any of the send*() APIs available in Bots class. For example, public static void sendMessage(String text) sends text message to skill or digital assistant.

Feature flag: linkHandler

You can configure the link behavior in chat messages to allow users to access web pages from within the chat widget. Instead of having to switch from the conversation to view a page in a tab or separate browser window, a user can remain in the chat because the chat widget opens the link within a Webview.

Feature flag: multiLangChat

The Android SDK's native language support enables the chat widget to both detect a user's language and allow the user to select the conversation language from a dropdown menu in the header. Users can switch between languages, but only in between conversations, not during a conversation because the conversation gets reset whenever a user selects a new language.

By passing an ArrayList of Objects to shareMenuItems shareMenuItems(Arraylist<Object>), you can restrict, or filter, the type of items that are available in the menu, customize the menu's icons and labels, and limit the upload file size (such as 1024 in the following snippet). These objects can either be an object of shareMenuCustomItem, or ShareMenuItem enum values that are mapped to the share menu items: ShareMenuItem.CAMERA for the camera menu item (if supported by the device), ShareMenuItem.VISUAL for sharing an image or video item, ShareMenuItem.AUDIO for sharing an audio item, and ShareMenuItem.FILE for sharing a file item. Passing either an empty value or a null value displays all of the menu items that can be passed as ShareMenuItem enum values.

ArrayList<Object> customItems = new ArrayList<>();
ShareMenuCustomItem shareMenuCustomItem1  = new ShareMenuCustomItem("pdf bin", "Label1", 1024, R.drawable.odaas_menuitem_share_file);
ShareMenuCustomItem shareMenuCustomItem2  = new ShareMenuCustomItem("doc", "Label2", R.drawable.odaas_menuitem_share_file);
ShareMenuCustomItem shareMenuCustomItem3  = new ShareMenuCustomItem("csv");
ArrayList<Object> customItems = new ArrayList<>(Arrays.asList(shareMenuCustomItem1,shareMenuCustomItem2,shareMenuCustomItem3,ShareMenuItem.CAMERA));
BotsConfiguration botsConfiguration = new BotsConfiguration.BotsConfigurationBuilder(sharedPreferences.getString(getString(R.string.pref_name_chat_server_host), Settings.CHAT_SERVER_URL), false, getApplicationContext())
         .channelId(<CHANNEL_ID>)
         .userId(<USER_ID>)
        .shareMenuItems(customItems)
        .enableAttachment(true)
        .build();

Feature flag: enableSpeechRecognition

Setting the enableSpeechRecognition feature flag to true enables the microphone button to display along with the send button whenever the user input field is empty.

Setting this property to true also supports the functionality enabled by the enableSpeechRecognitionAutoSend property, which when also set to true, enables the user's speech response to be sent to the chat server automatically while displaying the response as a sent message in the chat window. You can allow users to first edit (or delete) their dictated messages before they send them manually by setting enableSpeechRecognitionAutoSend to false.

• Feature flag: enableSpeechSynthesis
• Functionality configuration: speechSynthesisVoicePreferences

Feature flag : ttsService

The speechSynthesisService feature flag allows you to inject any text-to-speech (TTS) service -- your own, or one provided by a third-party vendor -- into the SDK. To inject a TTS service, you must first set the enableSpeechSynthesis feature flag to true and then pass an instance of the SpeechSynthesisService interface to the speechSynthesisService flag.

Feature flag: enableSendTypingStatus

When enabled, the SDK sends a RESPONDING typing event along with the text that's currently being typed by the user to . This shows a typing indicator on the agent console. When the user has finished typing, the SDK sends a LISTENING event to Oracle B2C Service or Oracle Fusion Service. This hides the typing indicator on the agent console.

Similarly, when the agent is typing, the SDK receives a RESPONDING event from the service. On receiving this event, the SDK shows a typing indicator to the user. When the agent is idle, the SDK receives LISTENING event from the service. On receiving this event, the SDK hides the typing indicator that's shown to the user.

public void sendUserTypingStatus(TypingStatus status, String text)

You can enable dynamic updating of the user avatar at runtime.

Use these APIs to modify agent name, the text color, avatar, agent name initials, text color, and avatar background.

When voice support is enabled (enableSpeechRecognition(true)), the footer of the chat widget displays a voice visualizer, a dynamic visualizer graph that indicates the frequency level of the voice input. The visualizer responds to the modulation of the user's voice by indicating whether the user is speaking too softly or too loudly. This visualizer is created using the stream of bytes that are recorded while the user is speaking, which is also exposed in the IBotsSpeechListener#onActiveSpeechUpdate(byte[]) method for use in headless mode.

When enableSpeechRecognitionAutoSend(true), the recognized text is automatically sent to the skill after the user has finished dictating the message. The mode then reverts to text input. When enableSpeechRecognitionAutoSend(false), the mode also reverts to text input, but in this case, users can modify the recognized text before sending the message to the skill.