发送图片消息

val config = ConversationalAIAPIConfig(
    rtcEngine = rtcEngine,
    rtmClient = rtmClient,
    renderMode = TranscriptRenderMode.Word,
    enableLog = true,
    enableRenderModeFallback = true
)

val api = ConversationalAIAPIImpl(config)

let config = ConversationalAIAPIConfig(
    rtcEngine: rtcEngine,
    rtmEngine: rtmEngine,
    renderMode: .words,
    enableLog: true,
    enableRenderModeFallback: true
)

convoAIAPI = ConversationalAIAPIImpl(config: config)

const config: IConversationalAIAPIConfig = {
  rtcEngine: rtcEngine,
  rtmEngine: rtmEngine,
  renderMode: ETranscriptHelperMode.WORD,
  enableLog: true,
  enableRenderModeFallback: true,
};

const conversationalAIAPI = await ConversationalAIAPI.init(config);

api.subscribeMessage("channelName") { error ->
    if (error != null) {
        // 处理错误
    }
}

convoAIAPI.subscribeMessage(channelName: channelName) { error in
    if let error = error {
        print("订阅失败: \(error.message)")
    } else {
        print("订阅成功")
    }
}

conversationalAIAPI.subscribeMessage(channel_name)

val uuid = "unique-image-id-123" // 生成唯一的图片标识符
val imageUrl = "https://example.com/image.jpg" // 图片的 HTTP/HTTPS URL

api.chat("agentUserId", ImageMessage(uuid = uuid, imageUrl = imageUrl)) { error ->
    if (error != null) {
        Log.e("Chat", "Failed to send image: ${error.errorMessage}")
    } else {
        Log.d("Chat", "Image send request successful")
    }
}

let uuid = UUID().uuidString
let imageUrl = "https://example.com/image.jpg"
let message = ImageMessage(uuid: uuid, url: imageUrl)
self.convoAIAPI.chat(agentUserId: "\(agentUid)", message: message) { [weak self] error in
    if let error = error {
        print("send image failed, error: \(error.message)")
    } else {
        print("send image success")
    }
}

import { EChatMessageType } from '@/conversational-ai-api/type'

// 发送图片消息
await conversationalAIAPI.chat(`${agent_rtc_uid}`, {
          messageType: EChatMessageType.IMAGE,
          url: "https://example.com/image.jpg",
          uuid: genUUID()
        })

override fun onMessageReceiptUpdated(agentUserId: String, receipt: MessageReceipt) {
    if (receipt.chatMessageType == ChatMessageType.Image) {
        try {
            val json = JSONObject(receipt.message)
            // 检查是否包含 uuid 字段
            if (json.has("uuid")) {
                val receivedUuid = json.getString("uuid")

                // 如果 uuid 匹配，说明此图片发送成功
                if (receivedUuid == "your-sent-uuid") {
                    Log.d("ImageSend", "Image sent successfully: $receivedUuid")
                    // 更新 UI 显示发送成功状态
                }
            }
        } catch (e: Exception) {
            Log.e("ImageSend", "Failed to parse message receipt: ${e.message}")
        }
    }
}

struct PictureInfo: Codable {
    let uuid: String
}

public func onMessageReceiptUpdated(agentUserId: String, messageReceipt: MessageReceipt) {
      // 第一步：检查消息类型是否为 Context
      if messageReceipt.type == .context {
          guard let messageData = messageReceipt.message.data(using: .utf8) else {
              return
          }
          // 第二步：解析 receipt.message 为 JSON 对象
          do {
              let imageInfo = try JSONDecoder().decode(PictureInfo.self, from: messageData)
              // 第三步：检查是否包含 uuid 字段
              let uuid = imageInfo.uuid
              // 更新 UI 显示发送成功状态
              self.messageView.viewModel.updateImageMessage(uuid: uuid, state: .success)
          } catch {
              print("Failed to decode PictureInfo: \(error)")
          }

        print("Failed to parse message string from image info message")
        return
    }

  }

import { TMessageReceipt, EModuleType, EConversationalAIAPIEvents } from '@/conversational-ai-api/type'

// 处理图片消息的发送状态
conversationalAIAPI.on(EConversationalAIAPIEvents.MESSAGE_RECEIPT_UPDATED, (agentUserId: string,  messageReceipt: TMessageReceipt) => {
    // 第一步：检查消息类型是否为 Context
    if (messageReceipt.moduleType !== EModuleType.CONTEXT) {
        return
    }
    // 第二步：解析 receipt.message 为 JSON 对象
    try {
        const receiptMessage = JSON.parse(messageReceipt.message)
        // 第三步：检查是否包含 uuid 字段
        const uuid = receiptMessage.uuid
        if (!uuid) {
            return
        }
        // 第四步：播报发送成功状态
        console.log(`消息发送成功，UUID: ${uuid}`) // 这里可以替换为实际的播报逻辑
    } catch (error) {
        console.error('解析消息失败:', error)
    }
})

override fun onMessageError(agentUserId: String, error: MessageError) {
    if (error.chatMessageType == ChatMessageType.Image) {
        try {
            val json = JSONObject(error.message)
            // 检查是否包含 uuid 字段
            if (json.has("uuid")) {
                val failedUuid = json.getString("uuid")

                // 如果 uuid 匹配，说明此图片发送失败
                if (failedUuid == "your-sent-uuid") {
                    Log.e("ImageSend", "Image send failed: $failedUuid")
                    // 更新 UI 显示发送失败状态
                }
            }
        } catch (e: Exception) {
            Log.e("ImageSend", "Failed to parse error message: ${e.message}")
        }
    }
}

struct ImageUploadError: Codable {
    let code: Int
    let message: String
}

struct ImageUploadErrorResponse: Codable {
    let uuid: String
    let success: Bool
    let error: ImageUploadError?
}

public func onMessageError(agentUserId: String, error: MessageError) {
    if let messageData = error.message.data(using: .utf8) {
        do {
            let errorResponse = try JSONDecoder().decode(ImageUploadErrorResponse.self, from: messageData)
            if !errorResponse.success {
                let errorMessage = errorResponse.error?.message ?? "Unknown error"
                let errorCode = errorResponse.error?.code ?? 0

                addLog("<<< [ImageUploadError] Image upload failed: \(errorMessage) (code: \(errorCode))")

                // 更新 UI 显示发送失败状态
                DispatchQueue.main.async { [weak self] in
                    self?.messageView.viewModel.updateImageMessage(uuid: errorResponse.uuid, state: .failed)
                }
            }
        } catch {
            addLog("<<< [onMessageError] Failed to parse error message JSON: \(error)")
        }
    }
}

import { EConversationalAIAPIEvents, EChatMessageType } from '@/conversational-ai-api/type';

conversationalAIAPI.on(EConversationalAIAPIEvents.MESSAGE_ERROR, (agentUserId, error) => {
  console.error(`Message error for agent ${agentUserId}:`, error);
  if (error.type === EChatMessageType.IMAGE) {
    try {
        const errorData = JSON.parse(error.message);
        if (errorData?.uuid) {
            console.warn(`Image error for agent ${agentUserId} with UUID: ${errorData.uuid}`);
        }
    } catch (e) {
        console.error(`Failed to handle image error for agent ${agentUserId}:`, e);
    }
  }
 })

api.unsubscribeMessage("channelName") { error ->
    if (error != null) {
        // 处理错误
    }
}

/// 取消订阅频道消息
convoAIAPI.unsubscribeMessage(channelName: channelName) { error in
    if let error = error {
        print("取消订阅失败: \(error.message)")
    } else {
        print("取消订阅成功")
    }
}

conversationalAIAPI.unsubscribeMessage(channel_name)

api.destroy()

convoAIAPI.destroy()

conversationalAIAPI.destroy()