Integrate with Android apps

ARTCAICallEngine mARTCAICallEngine = null;

// Create an engine instance.
void initEngine(Context context, String userId) {
    // Initialize the engine instance.
    // context -> Android Context
    // userId -> The ID of the user who joins the Real-Time Communication (RTC) channel.
    mARTCAICallEngine = new ARTCAICallDepositEngineImpl(context, userId);   
}

// Configure callback events.
void initCallback() {
    mARTCAICallEngine.setEngineCallback(mCallEngineCallbackWrapper); 
}

// Start a call after an intelligent agent is started.
void call() {
    // Configure the startup parameters of the engine.
    ARTCAICallEngine.ARTCAICallConfig artcaiCallConfig = new ARTCAICallEngine.ARTCAICallConfig();
    // Specify a temporary intelligent agent ID, if required.
    artcaiCallConfig.aiAgentId = aiAgentId;
    mARTCAICallEngine.init(artcaiCallConfig);
    
    // Specify the type of the intelligent agent, such as voice agent, digital human agent, or visual understanding agent.
    ARTCAICallEngine.ARTCAICallAgentType aiAgentType = VoiceAgent;
    mARTCAICallEngine.setAiAgentType(aiAgentType);

    // Configure a view if a digital human agent is used.
    if (aiAgentType == AvatarAgent) {
        ViewGroup avatarlayer;
        mARTCAICallEngine.setAvatarAgentView(
            avatarlayer,
            new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
                                       ViewGroup.LayoutParams.MATCH_PARENT)
        );
    }
    // Configure a view for local video preview if a visual understanding agent is used.
    else if (aiAgentType == VisionAgent) {
        ViewGroup previewLayer;
        mARTCAICallEngine.setVisionPreviewView(previewLayer,
            new FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
                                         ViewGroup.LayoutParams.MATCH_PARENT)
        );
    }

    // Join a channel.
    String aIAgentInstanceId = "XXX";
    String rtcAuthToken = "XXX";
    String aIAgentUserId = "XXX";
    String channelId = "XXX";
    mARTCAICallEngine.call(rtcAuthToken, aIAgentInstanceId, 
                           aIAgentUserId, channelId);
}

// End the call.
void handup() {
    mARTCAICallEngine.handup();
}

// For more information about how to call other API operations, see the "API reference" section of this topic.

// The callback events. The following examples include only callback events that do not require specialized main code.
ARTCAICallEngine.IARTCAICallEngineCallback mCallEngineCallbackWrapper = new ARTCAICallEngine.IARTCAICallEngineCallback() {
    @Override
    public void onErrorOccurs(ARTCAICallEngine.AICallErrorCode errorCode) {
        // An error occurs and the call ends.
        mARTCAICallEngine.handup();
    }

    @Override
    public void onCallBegin() {
        // The call starts and the user joins the meeting.
    }

    @Override
    public void onCallEnd() {
        // The call ends and the user leaves the meeting.
    }

    @Override
    public void onAICallEngineRobotStateChanged(ARTCAICallEngine.ARTCAICallRobotState oldRobotState, ARTCAICallEngine.ARTCAICallRobotState newRobotState) {
        // The status of the intelligent agent changes.
    }

    @Override
    public void onUserSpeaking(boolean isSpeaking) {
        // Indicate whether the user is speaking.
    }

    @Override
    public void onUserAsrSubtitleNotify(String text, boolean isSentenceEnd, int sentenceId) {
        // The speech of the user is recognized by automatic speech recognition (ASR).
    }

    @Override
    public void onAIAgentSubtitleNotify(String text, boolean end, int userAsrSentenceId) {
        // The intelligent agent returns a response.
    }

    @Override
    public void onNetworkStatusChanged(String uid, ARTCAICallEngine.ARTCAICallNetworkQuality quality) {
        // The network status changes.
    }

    @Override
    public void onVoiceVolumeChanged(String uid, int volume) {
        // The voice volume changes.
    }

    @Override
    public void onVoiceIdChanged(String voiceId) {
        // The voice tone of the current call changes.
    }

    @Override
    public void onVoiceInterrupted(boolean enable) {
        // Indicate whether intelligent interruption is enabled for the current call.
    }

    @Override
    public void onAgentVideoAvailable(boolean available) {
        // Indicate whether the ingested video stream of the intelligent agent is available.
    }

    @Override
    public void onAgentAudioAvailable(boolean available) {
        // Indicate whether the ingested audio stream of the intelligent agent is available.
    }
    
    @Override
    public void onAgentAvatarFirstFrameDrawn() {
        // Render the first frame of the digital human video.
    }

    @Override
    public void onUserOnLine(String uid) {
        // Indicate whether the user is online.
    }

};

/**
 * Initialize an engine instance.
 * @param config The configurations to be initialized.
 */
public abstract void init(ARTCAICallConfig config);

/**
 * Specify the type of an intelligent agent.
 * @param aiAgentType
 */
public abstract void setAICallAgentType(ARTCAICallAgentType aiAgentType);

/**
 * Create and start a call.
 */
public abstract void call(String rtcToken, String aiAgentInstanceId, String aiAgentUserId, String channelId);

/**
 * End a call.
 */
public abstract void handup();

/**
 * Change the microphone status.
 * @param on
 */
public abstract void switchMicrophone(boolean on);

/**
 * Interrupt the speech of an intelligent agent.
 */
public abstract boolean interruptSpeaking();

/**
 * Enable or disable intelligent interruption.
 */
public abstract boolean enableVoiceInterrupt(boolean enable);

/**
 * Enable or disable the speaker.
 */
public abstract boolean enableSpeaker(boolean enable);

/**
 * Enable or disable the intercom mode. In intercom mode, the intelligent agent returns a result only after the finishPushToTalk operation is called.
 * @param enable
 * @return
 */
public abstract boolean enablePushToTalk(boolean enable);

/**
 * Check whether the intercom mode is enabled.
 * @return
 */
public abstract boolean isPushToTalkEnable();

/**
 * Start a speech in intercom mode.
 * @return
 */
public abstract boolean startPushToTalk();

/**
 * End a speech in intercom mode.
 * @return
 */
public abstract boolean finishPushToTalk();

/**
 * Cancel a speech in intercom mode.
 * @return
 */
public abstract boolean cancelPushToTalk();

/**
 * Change the voice tone.
 */
public abstract boolean switchRobotVoice(String voiceId);

/**
 * Query the voice tone in use.
 * @return
 */
public abstract String getRobotVoiceId();

/**
 * Configure callback events.
 * @param engineCallback
 */
public abstract void setEngineCallback(IARTCAICallEngineCallback engineCallback);

/**
 * Check whether the microphone is enabled.
 * @return
 */
public abstract boolean isMicrophoneOn();

/**
 * Check whether the speaker is enabled.
 * @return
 */
public abstract boolean isSpeakerOn();

/**
 * Check whether intelligent interruption is enabled.
 * @return
 */
public abstract boolean isVoiceInterruptEnable();

/**
 * Configure a view for a digital human agent.
 * @param viewGroup
 * @param avatarLayoutParams
 */
public abstract void setAvatarAgentView(ViewGroup viewGroup, ViewGroup.LayoutParams avatarLayoutParams);

/**
 * Configure a view for local video preview.
 * @param viewGroup
 * @param visionLayoutParams
 */
public abstract void setVisionPreviewView(ViewGroup viewGroup, ViewGroup.LayoutParams visionLayoutParams);

/**
 * Turn on or off a camera.
 */
public abstract boolean muteLocalCamera(boolean mute);

/**
 * Check whether a camera is turned off.
 * @return
 */
public abstract boolean isLocalCameraMute();

/**
 * Switch between the front camera and the rear camera.
 */
public abstract boolean switchCamera();

/**
 * Query the information about an RTC engine instance.
 * @return
 */
public abstract AliRtcEngine getRtcEngine();

/**
 * Query the implementation class of the official protocol.
 * @return
 */
public abstract IARTCAICallService getIARTCAICallService();

/**
 * An error occurs.
 * @param errorCode The error code.
 */
void onErrorOccurs(AICallErrorCode errorCode);

/**
 * A call starts and a user joins the meeting.
 */
void onCallBegin();

/**
 * A call ends and a user leaves the meeting.
 */
void onCallEnd();

/**
 * The status of an intelligent agent changes.
 * @param oldRobotState
 * @param newRobotState
 */
void onAICallEngineRobotStateChanged(ARTCAICallRobotState oldRobotState, ARTCAICallRobotState newRobotState);

/**
 * A user is speaking.
 * @param isSpeaking Indicates whether the user is speaking.
 */
void onUserSpeaking(boolean isSpeaking);

/**
 * The speech of a user is recognized by ASR.
 * @param text The specific text that is recognized by ASR.
 * @param isSentenceEnd Indicates whether the current text is the end of the sentence.
 * @param sentenceId The ID of the sentence to which the current text belongs.
 */
void onUserAsrSubtitleNotify(String text, boolean isSentenceEnd, int sentenceId);

/**
 * An intelligent agent returns a response.
 * @param text The response of the intelligent agent.
 * @param end Indicates whether the current response ends.
 * @param userAsrSentenceId The ID of the sentence to which the speech of the user recognized by a large language model (LLM) belongs.
 */
void onAIAgentSubtitleNotify(String text, boolean end, int userAsrSentenceId);

/**
 * The network status changes.
 * @param uid The ID of the user who joins the meeting.
 * @param quality The network status.
 */
void onNetworkStatusChanged(String uid, ARTCAICallNetworkQuality quality);

/**
 * The voice volume changes.
 * @param uid The user ID.
 * @param volume The voice volume. Valid values: 0 to 255.
 */
void onVoiceVolumeChanged(String uid, int volume);

/**
 * The voice tone of the current call changes.
 */
void onVoiceIdChanged(String voiceId);

/**
 * The status of intelligent interruption changes.
 */
void onVoiceInterrupted(boolean enable);

/**
 * The first video frame of an intelligent agent is ingested.
 */
void onAgentVideoAvailable(boolean available);

/**
 * The first audio frame of an intelligent agent is ingested.
 */
void onAgentAudioAvailable(boolean available);

/**
* The first frame of a digital human video is rendered.
*/
void onAgentAvatarFirstFrameDrawn();

/**
* A user is online.
*/
void onUserOnLine(String uid);

/**
 * The current intelligent agent is leaving and the call ends.
 * @param reason The reason for the end of the call. A value of 2001 indicates a session timeout. A value of 0 indicates other reasons.
 @param message The description of the reason.
 */
void onAgentWillLeave(int reason, String message);

/**
 * A custom message is received from an intelligent agent.
 * @param data The custom message body, which is a JSON string.
 */
public void onReceivedAgentCustomMessage(String data);

/**
 * Initiate a request to start a call with a shared intelligent agent.
 * @param userId The ID of the current user.
 * @param aiAgentId The ID of the intelligent agent.
 * @param aiAgentType The type of the intelligent agent.
 * @param artcaiCallConfig The configurations of the intelligent agent.
 @param callback The request for a callback.
 */
void generateAIAgentShareCall(String userId, String aiAgentId, ARTCAICallEngine.ARTCAICallAgentType aiAgentType, ARTCAICallEngine.ARTCAICallConfig artcaiCallConfig, IARTCAICallServiceCallback callback);

/**
 * Parse the information about a shared intelligent agent.
 * @param shareInfoText
 * @return The structured configurations of the shared intelligent agent.
 */
public static ARTCAIAgentShareInfo parseAiAgentShareInfo(String shareInfoText);

/**
 * Parse the response of an intelligent agent when the intelligent agent is started.
 * @param jsonObject The response of the intelligent agent.
 * @return The structured response of the intelligent agent.
 */
public static ARTCAIAgentInfo parseAiAgentInfo(JSONObject jsonObject);