接听第一通电话

import io.trtc.tuikit.atomicxcore.api.device.DeviceStore
import io.trtc.tuikit.atomicxcore.api.call.CallStore

class CallActivity : AppCompatActivity() {
    private var buttonContainer: LinearLayout? = null
    private var buttonAccept: Button? = null
    private var buttonReject: Button? = null
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 1.创建底部按钮栏容器
        createButtonContainer()
        // 2.添加"接听"与"拒接"按钮
        addRejectAndAcceptButtons()
        
        setContentView(buttonContainer)
    }
    
    // 创建底部按钮栏容器
    private fun createButtonContainer() {
        buttonContainer = LinearLayout(this).apply {
            orientation = LinearLayout.HORIZONTAL
            gravity = Gravity.CENTER
            layoutParams = FrameLayout.LayoutParams(
                FrameLayout.LayoutParams.MATCH_PARENT,
                FrameLayout.LayoutParams.WRAP_CONTENT
            ).apply {
                gravity = Gravity.BOTTOM
                bottomMargin = dpToPx(80)
            }
        }
    }
    
    // 添加"接听"与"拒接"按钮
    private fun addRejectAndAcceptButtons() {
        createAcceptButton()
        createRejectButton()
        buttonContainer?.addView(buttonAccept)
        buttonContainer?.addView(buttonReject)
    }

    // 创建接听按钮
    private fun createAcceptButton() {
        buttonAccept = Button(this).apply {
            text = "接听"
            layoutParams = LinearLayout.LayoutParams(0, LinearLayout.LayoutParams.WRAP_CONTENT, 1f).apply {
                marginEnd = dpToPx(8)
            }
            setOnClickListener {
                // 3.接听按钮点击事件绑定 accept
                CallStore.shared.accept(null)
            }
        }
    }

    // 创建拒接按钮
    private fun createRejectButton() {
        buttonReject = Button(this).apply {
            text = "拒接"
            layoutParams = LinearLayout.LayoutParams(0, LinearLayout.LayoutParams.WRAP_CONTENT, 1f).apply {
                marginStart = dpToPx(8)
            }
            setOnClickListener {
                // 3.拒接按钮点击事件绑定 reject
                CallStore.shared.reject(null)
            }
        }
    }
}

import io.trtc.tuikit.atomicxcore.api.call.CallEndReason
import io.trtc.tuikit.atomicxcore.api.call.CallListener
import io.trtc.tuikit.atomicxcore.api.call.CallMediaType
import io.trtc.tuikit.atomicxcore.api.call.CallStore

class CallActivity : AppCompatActivity() {
    
    private var callListener: CallListener? = null
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // ... 其他初始化代码
        
        // 1.通话结束事件监听
        addListener()
    }
    
    private fun addListener() {
        callListener = object : CallListener() {
            override fun onCallEnded(callId: String, mediaType: CallMediaType, reason: CallEndReason, userId: String) {
                // 2.通话结束关闭页面
                finish()
            }
        }
        callListener?.let { CallStore.shared.addListener(it) }
    }
}

<manifest xmlns:android="http://schemas.android.com/apk/res/android">
    <!-- 麦克风权限 -->
    <uses-permission android:name="android.permission.RECORD_AUDIO" />
    <!-- 摄像头权限 -->
    <uses-permission android:name="android.permission.CAMERA" />
    
    <application>
        <!-- ... -->
        <activity
            android:name=".CallActivity"
            android:exported="false"
            android:screenOrientation="portrait" />
    </application>
</manifest>

// 动态申请权限
private fun requestAllCallPermissions() {
    val allPermissions = arrayOf(
        Manifest.permission.CAMERA,
        Manifest.permission.RECORD_AUDIO
    )
        
    if (!checkPermissions(allPermissions)) {
        ActivityCompat.requestPermissions(this, allPermissions, PERMISSION_REQUEST_CODE)
    }
}

// 处理权限申请结果
override fun onRequestPermissionsResult(
    requestCode: Int,
    permissions: Array<out String>,
    grantResults: IntArray
) {
   super.onRequestPermissionsResult(requestCode, permissions, grantResults)

   if (requestCode == PERMISSION_REQUEST_CODE) {
       // 检查是否所有权限都已授予
       var allGranted = true
       for (result in grantResults) {
           if (result != PackageManager.PERMISSION_GRANTED) {
               allGranted = false
               break
           }
       }
       if (allGranted) {
           Log.d("MainActivity", "权限申请成功")
           } else {
           Log.w("MainActivity", "部分权限被拒绝")
       }
   }
}

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlinx.coroutines.launch

class MainActivity : AppCompatActivity() {
    private var stateJob: Job? = null
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 1.监听当前用户的通话状态
        observeSelfStatus()
    }

    // 监听当前用户的通话状态
    private fun observeSelfStatus() {
        stateJob = CoroutineScope(Dispatchers.Main).launch {
            CallStore.shared.observerState.selfInfo.collect { selfInfo ->
               // 2.播放/停止来电提示
               if (selfInfo.status == CallParticipantStatus.Waiting) {
                   // 等待接听时，开始播放来电提示
               }
               if (selfInfo.status == CallParticipantStatus.Accept) {
                   // 接听后，停止播放来电提示
               }
            }
        }
    }
}

import io.trtc.tuikit.atomicxcore.api.device.DeviceStore
import io.trtc.tuikit.atomicxcore.api.call.CallMediaType
import io.trtc.tuikit.atomicxcore.api.call.*

class MainActivity : AppCompatActivity() {
    private var callListener: CallListener? = null
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // ... 其他初始化代码
        
        // 1.监听来电事件
        addListener()
    }
    
    private fun addListener() {
        callListener = object : CallListener() {
            override fun onCallReceived(callId: String, mediaType: CallMediaType, userData: String) {
                super.onCallReceived(callId, mediaType, userData)
                // 2.根据来电媒体类型打开设备
                openDeviceForMediaType(mediaType)
            }
        }
        callListener?.let { CallStore.shared.addListener(it) }
    }

    private fun openDeviceForMediaType(mediaType: CallMediaType?) {
        mediaType?.let {
            DeviceStore.shared().openLocalMicrophone(null)
            if (mediaType == CallMediaType.Video) {
                val isFrontCamera = true
                DeviceStore.shared().openLocalCamera(isFrontCamera, null)
            }
        }
    }
 }

private fun setIconResourcePath() {
    val volumeLevelIcons = mapOf(VolumeLevel.Mute to "对应图标资源的路径")
    val callCoreView = CallCoreView(context)
    callCoreView.setVolumeLevelIcons(volumeLevelIcons)
}

private fun setNetworkQualityIcons() {
    val volumeLevelIcons = mapOf(NetworkQuality.BAD to "对应图标的路径")
    val callCoreView = CallCoreView(context)
    callCoreView.setNetworkQualityIcons(volumeLevelIcons)
}

private fun setParticipantAvatars() {
    val avatars: MutableMap<String, ParticipantAvatarInfo> = mutableMapOf()
    val userId = "" // 用户 ID
    val avatarPath = "" // 用户默认头像资源的路径
    avatars[userId] = avatarPath
    val callCoreView = CallCoreView(context)
    callCoreView.setParticipantAvatars(avatars)
}

private fun setWaitingAnimation() {
    val waitingAnimationPath = "" // 等待动画 GIF 图像资源的路径
    val callCoreView = CallCoreView(context)
    callCoreView.setWaitingAnimation(waitingAnimationPath)
}

import android.content.Context
import androidx.appcompat.widget.AppCompatTextView
import androidx.core.content.ContextCompat
import com.tencent.qcloud.tuicore.util.DateTimeUtil
import io.trtc.tuikit.atomicx.R
import io.trtc.tuikit.atomicxcore.api.call.CallStore
import io.trtc.tuikit.atomicxcore.api.call.CallParticipantStatus
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlinx.coroutines.launch

class TimerView(context: Context) : AppCompatTextView(context) {
    private var subscribeStateJob: Job? = null

    override fun onAttachedToWindow() {
        super.onAttachedToWindow()
        // 1.数据层订阅 activeCall
        registerActiveCallObserver()
    }

    override fun onDetachedFromWindow() {
        super.onDetachedFromWindow()
        subscribeStateJob?.cancel()
    }

    private fun registerActiveCallObserver() {
        subscribeStateJob = CoroutineScope(Dispatchers.Main).launch {
            CallStore.shared.observerState.activeCall.collect { activeCall ->
                // 2.绑定通话计时数据，更新通话计时
                updateDurationView(activeCall)
            }
        }
    }

    private fun updateDurationView(activeCall: CallInfo) {
        val currentDuration = activeCall.duration
        text = DateTimeUtil.formatSecondsTo00(currentDuration.toInt())
    }
}