Answering Your First Call

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. Create the bottom button bar container
        createButtonContainer()
        // 2. Add "Answer" and "Reject" buttons
        addRejectAndAcceptButtons()
        
        setContentView(buttonContainer)
    }
    
    // Create the bottom button bar container
    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)
            }
        }
    }
    
    // Add "Answer" and "Reject" buttons
    private fun addRejectAndAcceptButtons() {
        createAcceptButton()
        createRejectButton()
        buttonContainer?.addView(buttonAccept)
        buttonContainer?.addView(buttonReject)
    }

    // Create the Answer button
    private fun createAcceptButton() {
        buttonAccept = Button(this).apply {
            text = "Answer"
            layoutParams = LinearLayout.LayoutParams(0, LinearLayout.LayoutParams.WRAP_CONTENT, 1f).apply {
                marginEnd = dpToPx(8)
            }
            setOnClickListener {
                // 3. Bind accept to Answer button click event
                CallStore.shared.accept(null)
            }
        }
    }

    // Create the Reject button
    private fun createRejectButton() {
        buttonReject = Button(this).apply {
            text = "Reject"
            layoutParams = LinearLayout.LayoutParams(0, LinearLayout.LayoutParams.WRAP_CONTENT, 1f).apply {
                marginStart = dpToPx(8)
            }
            setOnClickListener {
                // 3. Bind reject to Reject button click event
                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)
        // ... other initialization code
        
        // 1. Listen for call ended events
        addListener()
    }
    
    private fun addListener() {
        callListener = object : CallListener() {
            override fun onCallEnded(callId: String, mediaType: CallMediaType, reason: CallEndReason, userId: String) {
                // 2. Close the page when the call ends
                finish()
            }
        }
        callListener?.let { CallStore.shared.addListener(it) }
    }
}

<manifest xmlns:android="http://schemas.android.com/apk/res/android">
    <!-- Microphone permission -->
    <uses-permission android:name="android.permission.RECORD_AUDIO" />
    <!-- Camera permission -->
    <uses-permission android:name="android.permission.CAMERA" />
    
    <application>
        <!-- ... -->
        <activity
            android:name=".CallActivity"
            android:exported="false"
            android:screenOrientation="portrait" />
    </application>
</manifest>

// Dynamically request permissions
private fun requestAllCallPermissions() {
    val allPermissions = arrayOf(
        Manifest.permission.CAMERA,
        Manifest.permission.RECORD_AUDIO
    )
        
    if (!checkPermissions(allPermissions)) {
        ActivityCompat.requestPermissions(this, allPermissions, PERMISSION_REQUEST_CODE)
    }
}

// Handle permission request result
override fun onRequestPermissionsResult(
    requestCode: Int,
    permissions: Array<out String>,
    grantResults: IntArray
) {
   super.onRequestPermissionsResult(requestCode, permissions, grantResults)

   if (requestCode == PERMISSION_REQUEST_CODE) {
       // Check if all permissions are granted
       var allGranted = true
       for (result in grantResults) {
           if (result != PackageManager.PERMISSION_GRANTED) {
               allGranted = false
               break
           }
       }
       if (allGranted) {
           Log.d("MainActivity", "Permission granted")
       } else {
           Log.w("MainActivity", "Some permissions denied")
       }
   }
}

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. Monitor current user's call status
        observeSelfStatus()
    }

    // Monitor current user's call status
    private fun observeSelfStatus() {
        stateJob = CoroutineScope(Dispatchers.Main).launch {
            CallStore.shared.observerState.selfInfo.collect { selfInfo ->
               // 2. Play/stop incoming call notification
               if (selfInfo.status == CallParticipantStatus.Waiting) {
                   // Start playing incoming call notification
               }
               if (selfInfo.status == CallParticipantStatus.Accept) {
                   // Stop playing incoming call notification
               }
            }
        }
    }
}

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)
        // ... other initialization code
        
        // 1. Listen for incoming call event
        addListener()
    }
    
    private fun addListener() {
        callListener = object : CallListener() {
            override fun onCallReceived(callId: String, mediaType: CallMediaType, userData: String) {
                super.onCallReceived(callId, mediaType, userData)
                // 2. Open devices based on media type
                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 "icon resource path")
    val callCoreView = CallCoreView(context)
    callCoreView.setVolumeLevelIcons(volumeLevelIcons)
}

private fun setNetworkQualityIcons() {
    val volumeLevelIcons = mapOf(NetworkQuality.BAD to "icon path")
    val callCoreView = CallCoreView(context)
    callCoreView.setNetworkQualityIcons(volumeLevelIcons)
}

private fun setParticipantAvatars() {
    val avatars: MutableMap<String, ParticipantAvatarInfo> = mutableMapOf()
    val userId = "" // User ID
    val avatarPath = "" // Default avatar resource path
    avatars[userId] = avatarPath
    val callCoreView = CallCoreView(context)
    callCoreView.setParticipantAvatars(avatars)
}

private fun setWaitingAnimation() {
    val waitingAnimationPath = "" // Path to the waiting animation GIF resource
    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. Subscribe to activeCall in the data layer
        registerActiveCallObserver()
    }

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

    private fun registerActiveCallObserver() {
        subscribeStateJob = CoroutineScope(Dispatchers.Main).launch {
            CallStore.shared.observerState.activeCall.collect { activeCall ->
                // 2. Bind call timer data, update call duration
                updateDurationView(activeCall)
            }
        }
    }

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