Intelligent Media Services:サーバーサイドインターフェイスを使用して通話を開始する

シナリオ

ビジネスで各通話をリアルタイムでモニターまたはレコードする必要がある場合、サーバーサイド OpenAPI 操作である GenerateAIAgentCall を介して通話を開始できます。この操作はサーバーサイドから開始する必要があり、結果はクライアントに送信されます。クライアントは返された情報を使用して通話に参加します。

ワークフロー

アプリでインテリジェントエージェントが開始された後、アプリは call() メソッドを呼び出して通話を開始できます。通話中、アプリは AICallKit SDK の API 操作を呼び出して、ライブ字幕や割り込みなどのインタラクティブな機能を実装できます。AICallKit はリアルタイムの音声およびビデオ機能に依存しているため、内部で AliVCSDK_ARTC SDK の関連機能を実装しています。ビジネスシナリオでライブストリーミングやオンデマンド機能も必要な場合は、AliVCSDK_Standard や AliVCSDK_InteractiveLive などの音声・ビデオ端末組み合わせ SDK を使用できます。組み合わせメソッドの詳細については、「SDK の選択とダウンロード」をご参照ください。

サーバーサイドプロセス

サーバーサイドは、generateAIAgentCall 操作などの通話を開始するためのインターフェイスを提供します。コア実装は、クライアントからのリクエストを受信し、OpenAPI 操作である GenerateAIAgentCall - AI インテリジェントエージェント通話インスタンスの生成 を呼び出し、その結果をクライアントサイドに渡します。

// GenerateAIAgentCall の呼び出し方法のデモンストレーション  
// このファイルは自動生成されたものです。編集しないでください。ありがとうございます。
package com.aliyun.rtc;

import com.alibaba.fastjson.JSON;
import com.aliyun.ice20201109.models.GenerateAIAgentCallResponse;
import com.aliyun.tea.*;

public class SampleGenerateaiagentcall {

    /**
     * description

クライアントフロー

ARTCAICallEngine mARTCAICallEngine = null;

// エンジンインスタンスの作成
void initEngine(Context context, String userId) {
    // 初期化
    // context -> Android Context
    // userId -> RTC チャンネルに参加するためのユーザー ID
    mARTCAICallEngine = new ARTCAICallEngineImpl(context, userId);

    // インテリジェントエージェントのタイプを指定: 音声、デジタルヒューマン、または視覚理解
    ARTCAICallEngine.ARTCAICallAgentType aiAgentType = VoiceAgent;
    mARTCAICallEngine.setAICallAgentType(aiAgentType);

    // デジタルヒューマンエージェントを使用する場合はビューを設定
    if (aiAgentType == AvatarAgent) {
        ViewGroup avatarlayer;
        engine.setAgentView(
                avatarlayer,
                new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
                        ViewGroup.LayoutParams.MATCH_PARENT));
    }
    // 視覚理解エージェントを使用する場合はローカルビデオプレビュー用のビューを設定
    else if (aiAgentType == VisionAgent) {
        ViewGroup previewLayer;
        engine.setLocalView(previewLayer,
                new FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
                        ViewGroup.LayoutParams.MATCH_PARENT));
    } else if (aiAgentType == VideoAgent) {
        ARTCAICallEngine.ARTCAICallVideoCanvas remoteCanvas = new ARTCAICallEngine.ARTCAICallVideoCanvas();
        remoteCanvas.zOrderOnTop = false;
        remoteCanvas.zOrderMediaOverlay = false;
        ViewGroup avatarlayer;
        engine.setAgentView(
                avatarlayer,
                new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
                        ViewGroup.LayoutParams.MATCH_PARENT),
                remoteCanvas);

        ViewGroup previewLayer;
        engine.setLocalView(previewLayer,
                new FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
                        ViewGroup.LayoutParams.MATCH_PARENT));
    }
}

// コールバックの設定
void initCallback() {
    mARTCAICallEngine.setEngineCallback(mCallEngineCallbackWrapper);
}

// コールバックイベントの処理
ARTCAICallEngine.IARTCAICallEngineCallback mCallEngineCallbackWrapper = new ARTCAICallEngine.IARTCAICallEngineCallback() {
    @Override
    public void onErrorOccurs(ARTCAICallEngine.AICallErrorCode errorCode) {
        // エラーが発生したため、通話を終了
        mARTCAICallEngine.handup();
    }

    @Override
    public void onCallBegin() {
        // 通話開始時にトリガー
    }

    @Override
    public void onCallEnd() {
        // 通話終了時にトリガー
    }

    @Override
    public void onAICallEngineRobotStateChanged(ARTCAICallEngine.ARTCAICallRobotState oldRobotState,
            ARTCAICallEngine.ARTCAICallRobotState newRobotState) {
        // ロボットの状態同期
    }

    @Override
    public void onUserSpeaking(boolean isSpeaking) {
        // ユーザー発話コールバック
    }

    @Override
    public void onUserAsrSubtitleNotify(String text, boolean isSentenceEnd, int sentenceId) {
        // ASR 認識されたテキストを同期
    }

    @Override
    public void onAIAgentSubtitleNotify(String text, boolean end, int userAsrSentenceId) {
        // インテリジェントエージェントの応答を同期
    }

    @Override
    public void onNetworkStatusChanged(String uid, ARTCAICallEngine.ARTCAICallNetworkQuality quality) {
        // ネットワークステータスコールバック
    }

    @Override
    public void onVoiceVolumeChanged(String uid, int volume) {
        // ボリュームの変更
    }

    @Override
    public void onVoiceIdChanged(String voiceId) {
        // インテリジェントエージェントの音声が変更
    }

    @Override
    public void onVoiceInterrupted(boolean enable) {
        // 現在の通話の音声割り込み設定が変更
    }

    @Override
    public void onAgentVideoAvailable(boolean available) {
        // インテリジェントエージェントのビデオが利用可能かどうか (ストリーミング)
    }

    @Override
    public void onAgentAudioAvailable(boolean available) {
        // インテリジェントエージェントの音声が利用可能かどうか (ストリーミング)
    }

    @Override
    public void onAgentAvatarFirstFrameDrawn() {
        // デジタルヒューマンの最初のビデオフレームのレンダリング
    }

    @Override
    public void onUserOnLine(String uid) {
        // ユーザーオンラインコールバック
    }

};

// エンジンインスタンスの作成
let engine = ARTCAICallEngineFactory.createEngine()
let agentType: ARTCAICallAgentType

// エンジンインスタンスの初期化
public func setup() {
    // コールバックの設定
    self.engine.delegate = self

    // デジタルヒューマンエージェントを使用する場合はビューを設定
    if self.agentType == .AvatarAgent {
        let agentViewConfig = ARTCAICallViewConfig(view: self.avatarAgentView)
        self.engine.setAgentViewConfig(viewConfig: agentViewConfig)
    }
    // 視覚理解エージェントを使用する場合はローカルビデオプレビュー用のビューを設定
    else if self.agentType == .VisionAgent {
        let cameraViewConfig = ARTCAICallViewConfig(view: self.cameraView)
        self.engine.setLocalViewConfig(viewConfig: cameraViewConfig)
    }
    // ビデオ通話タイプの場合は、デジタルヒューマンビューとローカルビデオプレビューの両方を設定
    else if self.agentType == .VisionAgent {
        let agentViewConfig = ARTCAICallViewConfig(view: self.avatarAgentView)
        self.engine.setAgentViewConfig(viewConfig: agentViewConfig)

        let cameraViewConfig = ARTCAICallViewConfig(view: self.cameraView)
        self.engine.setLocalViewConfig(viewConfig: cameraViewConfig)
    }
}

// コールバックイベントの処理
public func onErrorOccurs(code: ARTCAICallErrorCode) {
    // エラーが発生しました
    self.engine.handup()
}

public func onCallBegin() {
    // 通話が開始します
}

public func onCallEnd() {
    // 通話が終了します
}

public func onAgentStateChanged(state: ARTCAICallAgentState) {
    // インテリジェントエージェントのステータスが変更されます
}

public func onUserSubtitleNotify(text: String, isSentenceEnd: Bool, sentenceId: Int) {
    // ユーザーの質問がインテリジェントエージェントによって認識されたときにトリガーされます
}

public func onVoiceAgentSubtitleNotify(text: String, isSentenceEnd: Bool, userAsrSentenceId: Int) {
    // インテリジェントエージェントが応答を生成したときにトリガーされます
}

public func onVoiceIdChanged(voiceId: String) {
    // インテリジェントエージェントの音声が変更されます
}

public func onVoiceInterrupted(enable: Bool) {
    // 現在の通話で音声割り込みが有効になっているかどうかを示します
}

// SDK のインポート
import AICallEngine, { AICallErrorCode, AICallAgentState, AICallAgentType } from 'aliyun-auikit-aicall';

// エンジンインスタンスの作成
const engine = new AICallEngine();

// 他のメソッドの呼び出し方法の詳細については、このトピックの「API リファレンス」セクションをご参照ください。

// コールバックイベントの処理
engine.on('errorOccurred', (code) => {
  // エラーが発生しました
  engine.handup();
});

engine.on('callBegin', () => {
  // 通話が開始します
});

engine.on('callEnd', () => {
  // 通話が終了します
});

engine.on('agentStateChanged', (state) => {
  // インテリジェントエージェントのステータスが変更されます
});

engine.on('userSubtitleNotify', (subtitle) => {
  // ユーザーの質問がインテリジェントエージェントによって認識されたときにトリガーされます
});

engine.on('agentSubtitleNotify', (subtitle) => {
  // インテリジェントエージェントが応答を生成したときにトリガーされます
});

engine.on('voiceIdChanged', (voiceId) => {
  // インテリジェントエージェントの音声が変更されます
});

engine.on('voiceInterruptChanged', (enable) => {
  // 現在の通話で音声割り込みが有効になっているかどうかを示します
});

// 初期化
await engine.init(agentType);

// インテリジェントエージェントが開始された後に通話を開始
void call() {
    // エンジンの起動パラメーターを設定
    ARTCAICallEngine.ARTCAICallConfig artcaiCallConfig = new ARTCAICallEngine.ARTCAICallConfig();
    // 必要に応じて、一時的なインテリジェントエージェント ID を指定
    artcaiCallConfig.agentId = aiAgentId;
    artcaiCallConfig.region = "cn-shanghai";//インテリジェントエージェントのリージョン、必須
    artcaiCallConfig.agentType = VoiceAgent;//インテリジェントエージェントのタイプ (音声、デジタルヒューマン、視覚理解など) を指定
    mARTCAICallEngine.init(artcaiCallConfig);

    // サーバーから aIAgentInstanceId、rtcAuthToken、aIAgentUserId、channelId を取得
    String aIAgentInstanceId = "XXX";
    String rtcAuthToken = "XXX";
    String aIAgentUserId = "XXX";
    String channelId = "XXX";
    mARTCAICallEngine.call(rtcAuthToken, aIAgentInstanceId, 
                           aIAgentUserId, channelId);
}

public func call() {
    // サーバーから agent_instance_id、rtc_auth_token、ai_agent_user_id、channel_id を取得
    let agentInfo = ARTCAICallAgentInfo(agentType: self.agentType, channelId: channel_id, uid: ai_agent_user_id, instanceId: agent_instance_id)
    self.engine.call(userId: self.userId, token: rtc_auth_token, agentInfo: agentInfo) { [weak self] error in
        if let error = error {
            // エラーの処理
        }
        else {
            // 通話は成功です
        }
    }
}

const userId = 'xxx';  // 通話を開始するユーザーの ID

// サーバーからインテリジェントエージェント情報を取得
// 独自の AppServer をデプロイし、GenerateAIAgentCall を呼び出して通話インスタンスを生成する必要があります
// 戻り値は agentInfo です
// agentInfo.instanceId: インテリジェントエージェントインスタンスの ID
// agentInfo.channelId: ARTC チャンネルの ID
// agentInfo.userId: ARTC ユーザーの ID
// agentInfo.rtcToken: ARTC トークン
// agentInfo.reqId: リクエスト ID
const agentInfo = await fetchAgentInfo();
// fetchAgentInfo と一緒に処理できます。agentType はインテリジェントエージェントのタイプを示します。詳細については、AICallAgentType をご参照ください
await engine.init(agentType);

try {
  // インテリジェントエージェントが開始された後に通話を開始
  engine.call(userId, agentInfo);
} catch (error) {}

// 通話を終了
void handup() {
    mARTCAICallEngine.handup();
}

public func handup() {
    // 通話を終了
    self.engine.handup()
}

// 必要に応じて通話を終了
engine.handup();

参考

通話を開始してから切断するまでの間、必要に応じて、字幕の処理、エージェントの発話への割り込み、その他の操作を実行できます。詳細については、「基本機能」をご参照ください。