Video Chat

// Include the app module
include ':app'

// Include the 1v1 video social UI module
include ':video-chat'

// Include the beauty filter module
include ':tebeautykit'
project(':tebeautykit').projectDir = file("./tuikit/tebeautykit")

// Include the IM common module
include ':timcommon'
project(':timcommon').projectDir = file("./tuikit/timcommon")

// Include the conversation module (core module)
include ':tuiconversation'
project(':tuiconversation').projectDir = file("./tuikit/tuiconversation")

// Include the chat module (core module)
include ':tuichat'
project(':tuichat').projectDir = file("./tuikit/tuichat")

// Include the contact module (core module)
include ':tuicontact'
project(':tuicontact').projectDir = file("./tuikit/tuicontact")

// Include the search module (requires the Ultimate or Enterprise Edition plan)
include ':tuisearch'
project(':tuisearch').projectDir = file("./tuikit/tuisearch")

import com.tencent.qcloud.tuikit.videochat.page.meet.MeetPage

class MeetPageFragment : Fragment() {
  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        addMeetPage()
  }
  
  private fun addMeetPage() {
    val meetPage = MeetPage(requireContext())
    val container = findViewById<FrameLayout>(R.id.meet_container)
    container.addView(meetPage, MATCH_PARENT, MATCH_PARENT)
  }
}

import com.tencent.qcloud.tuikit.videochat.page.meet.MeetPage

meetPage.setListener(object : MeetPage.Listener {
    // Triggered upon a pull-down-to-refresh action
    override fun onRefreshRequested() {
        // Fully update the user list
        fetchUsers { users, hasMore ->
            // Pass in the user list
            meetPage.setPageUsers(users, hasMore)
        }
    }
    
    // Triggered upon a pull-up-to-load-more action
    override fun onLoadMoreRequested() {
        // Append new users to the end of the list
        fetchNextPage { users, hasMore ->
            // Pass in the user list
            meetPage.setPageUsers(users, hasMore)
        }
    }
})

fun setPageUsers(users: List<V2TIMUserFullInfo>, hasMore: Boolean)

import com.tencent.qcloud.tuikit.videochat.page.meet.MeetPage

class MeetPageFragment : Fragment() {
  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        addMeetPage()
  }
  
  private fun addMeetPage() {
    val meetPage = MeetPage(requireContext())
    // Set the layout
    meetPage.setLayoutTemplate(MeetPage.Template.LIST)  // Set to list layout (default)
    // meetPage.setLayoutTemplate(MeetPage.Template.GRID)  // Set to grid layout
    val container = findViewById<FrameLayout>(R.id.meet_container)
    container.addView(meetPage, MATCH_PARENT, MATCH_PARENT)
  }
}

fun setLayoutTemplate(template: MeetPage.Template)

val conversationPage = ConversationPage()

// R.id.container is the FrameLayout in your layout that hosts the conversation list Fragment
supportFragmentManager.beginTransaction()
    .add(R.id.container, conversationPage)
    .commit()

Bundle param = new Bundle();
param.putInt(TUIConstants.TUIChat.CHAT_TYPE, V2TIMConversation.V2TIM_C2C);
val userId = "jack" // The peer's UserId
param.putString(TUIConstants.TUIChat.CHAT_ID, userId);
TUICore.startActivity("TUIC2CChatActivity", param);

// Initiate a video call via CallStore.calls of the AtomicxCore SDK calling module.
CallStore.shared.calls(list, mediaType, params, object : CompletionHandler {
      override fun onFailure(code: Int, desc: String) {
            completion?.onFailure(code, desc)
      }

      override fun onSuccess() {
            completion?.onSuccess()
            // Call succeeded. Navigate to the VideoCallPage UI.
            val intent = Intent(context, VideoCallPage::class.java)
            intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
            context.startActivity(intent)
      }
})

/**
 * Customize the display text for 1v1 call status messages
 *
 * Modification location: CallModel.java -> getContentForSimplifyAppearance()
 * You only need to modify the text inside the `participantType == CALL_PARTICIPANT_TYPE_C2C` branch.
 *
 * The following fields can be used directly within the method:
 * - protocolType: Call protocol type (Initiated/Answered/Rejected/Canceled/Hung up/Timeout/Line Busy)
 * - participantRole: Current user role (CALLER / CALLEE)
 * - streamMediaType: Media type (VOICE / VIDEO)
 * - duration: Call duration (in seconds)
 */

// =================== Example: Customizing 1v1 Call Display Text ===================

// In the getContentForSimplifyAppearance() method, 
// locate the `if (participantType == CALL_PARTICIPANT_TYPE_C2C)` branch and modify it as follows:

if (participantType == CALL_PARTICIPANT_TYPE_C2C) {
    // Determine the media type to append the text prefix
    val mediaPrefix = if (streamMediaType == CALL_STREAM_MEDIA_TYPE_VIDEO) {
        "[Video Call]" // Enter your custom text for video calls
    } else {
        "[Voice Call]" // Enter your custom text for voice calls
    }

    val isCaller = (participantRole == CALL_PARTICIPANT_ROLE_CALLER)
    
    // `display` is the call status message shown on the UI
    display = when (protocolType) {
        // Call rejected (actionType = 4, excluding line_busy)
        CALL_PROTOCOL_TYPE_REJECT -> {
            if (isCaller) {
                "$mediaPrefix The peer rejected the call"
            } else {
                "$mediaPrefix Call rejected"
            }
        }

        // Call canceled (actionType = 2, canceled by caller)
        CALL_PROTOCOL_TYPE_CANCEL -> {
            if (isCaller) {
                "$mediaPrefix Call canceled"
            } else {
                "$mediaPrefix The peer canceled the call"
            }
        }

        // Call ended (actionType = 1, cmd = "hangup")
        // The `duration` field indicates the call duration in seconds
        CALL_PROTOCOL_TYPE_HANGUP -> {
            val formattedDuration = DateTimeUtil.formatSecondsTo00(duration)
            "$mediaPrefix Call duration: $formattedDuration"
        }

        // Timeout/Unanswered (actionType = 5)
        CALL_PROTOCOL_TYPE_TIMEOUT -> {
            if (isCaller) {
                "$mediaPrefix No response from the peer"
            } else {
                "$mediaPrefix Unanswered"
            }
        }

        // Rejected due to line busy (actionType = 4, top-level JSON contains the "line_busy" field)
        CALL_PROTOCOL_TYPE_LINE_BUSY -> {
            if (isCaller) {
                "$mediaPrefix The peer is busy"
            } else {
                "$mediaPrefix Line busy"
            }
        }

        // Call initiated (actionType = 1, cmd = "videoCall" or "audioCall")
        CALL_PROTOCOL_TYPE_SEND -> {
            "$mediaPrefix Call initiated"
        }

        // Call answered (actionType = 3)
        CALL_PROTOCOL_TYPE_ACCEPT -> {
            "$mediaPrefix Call answered"
        }

        else -> {
            context.getString(R.string.invalid_command)
        }
    }
}

// Set the message listener
V2TIMManager.getMessageManager().addAdvancedMsgListener(advancedMsgListener)

/**
 * Received a new message
 * @param msg The message object
 */
override fun onRecvNewMessage(msg: V2TIMMessage) {
    // Get signaling information. Returns null for non-signaling messages
    val signalingInfo = V2TIMManager.getSignalingManager().getSignalingInfo(msg)
        ?: return

    // Only process 1v1 chats (an empty groupID indicates a 1v1 chat; non-empty indicates a group chat)
    if (!signalingInfo.groupID.isNullOrEmpty()) {
        return
    }

    // Parse the data field of the signaling message (JSON format)
    val gson = Gson()
    val jsonData: Map<String, Any> = try {
        gson.fromJson(signalingInfo.data, object : TypeToken<Map<String, Any>>() {}.type)
    } catch (e: Exception) {
        return
    }

    // Verify businessID to confirm it is a call signaling message
    val businessId = jsonData["businessID"] as? String
    if (businessId != "av_call" && businessId != "tuikit_calling") {
        return
    }

    // Extract `cmd` from the nested `data` object
    val dataMap = jsonData["data"] as? Map<*, *>
    val cmd = dataMap?.get("cmd") as? String

    // Determine the call status based on actionType
    when (signalingInfo.actionType) {

        // ========== actionType = 1: Initiate Invitation ==========
        V2TIMSignalingInfo.SIGNALING_ACTION_TYPE_INVITE -> {
            when (cmd) {
                // Initiate a video call
                "videoCall" -> {
                    val mediaType = "video"
                    Log.i(TAG, "Call initiated | Type: $mediaType, Caller: ${msg.sender}")
                }
                // Initiate a voice call
                "audioCall" -> {
                    val mediaType = "audio"
                    Log.i(TAG, "Call initiated | Type: $mediaType, Caller: ${msg.sender}")
                }
                // Hang up (Call ended)
                "hangup" -> {
                    // Call duration is obtained from the top-level `call_end` field (in seconds)
                    val duration = jsonData["call_end"]
                        ?.toString()?.toDoubleOrNull()?.toInt() ?: 0
                    Log.i(TAG, "Call ended | Duration: ${duration}s")
                }
            }
        }

        // ========== actionType = 2: Cancel Call (Canceled by Caller) ==========
        V2TIMSignalingInfo.SIGNALING_ACTION_TYPE_CANCEL_INVITE -> {
            Log.i(TAG, "Call canceled | Caller: ${msg.sender}")
        }

        // ========== actionType = 3: Answer Call (Accepted by Callee) ==========
        V2TIMSignalingInfo.SIGNALING_ACTION_TYPE_ACCEPT_INVITE -> {
            Log.i(TAG, "Call answered")
        }

        // ========== actionType = 4: Reject Call (Rejected by Callee) ==========
        V2TIMSignalingInfo.SIGNALING_ACTION_TYPE_REJECT_INVITE -> {
            // Determine if it was rejected due to line busy: the top-level JSON contains a "line_busy" field
            if (jsonData.containsKey("line_busy")) {
                Log.i(TAG, "Rejected: The peer is busy")
            } else {
                Log.i(TAG, "Call rejected")
            }
        }

        // ========== actionType = 5: Timeout (Unanswered) ==========
        V2TIMSignalingInfo.SIGNALING_ACTION_TYPE_INVITE_TIMEOUT -> {
            Log.i(TAG, "Call timeout (Unanswered)")
        }
    }
}