Voice calling (Android SDK)

// Paste below the package line already in your MainActivity.kt.
import ai.poly.messaging.Configuration
import ai.poly.messaging.PolyMessaging
import ai.poly.messaging.voice.CallState
import ai.poly.voice.PolyVoice
import android.Manifest
import android.content.pm.PackageManager
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.compose.setContent
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Button
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.core.content.ContextCompat
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import kotlinx.coroutines.launch

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // For this quick test, initialize before Compose creates the VoiceCall.
        PolyMessaging.initialize(
            context = this,
            config = Configuration(
                apiKey = "YOUR_CONNECTOR_TOKEN",
                webrtcToken = "YOUR_WEB_CALLING_TOKEN",
            ),
        )

        setContent {
            MaterialTheme {
                Surface(Modifier.fillMaxSize()) { CallScreen() }
            }
        }
    }
}

@Composable
private fun CallScreen() {
    val context = LocalContext.current
    val scope = rememberCoroutineScope()
    val call = remember { PolyVoice.call(context.applicationContext) }
    val state by call.state.collectAsStateWithLifecycle()
    var muted by remember { mutableStateOf(false) }
    var permissionDenied by remember { mutableStateOf(false) }

    DisposableEffect(call) {
        onDispose { call.close() }
    }

    fun startCall() {
        permissionDenied = false
        muted = false
        scope.launch { runCatching { call.start() } }
    }

    val requestMicrophone = rememberLauncherForActivityResult(
        ActivityResultContracts.RequestPermission(),
    ) { granted ->
        if (granted) startCall() else permissionDenied = true
    }

    fun toggleCall() {
        when (state) {
            is CallState.Connecting, is CallState.Connected -> scope.launch { call.end() }
            else -> {
                val granted = ContextCompat.checkSelfPermission(
                    context,
                    Manifest.permission.RECORD_AUDIO,
                ) == PackageManager.PERMISSION_GRANTED
                if (granted) startCall()
                else requestMicrophone.launch(Manifest.permission.RECORD_AUDIO)
            }
        }
    }

    val status = if (permissionDenied) {
        "Microphone permission is required"
    } else {
        when (val current = state) {
            is CallState.Idle -> "Tap to call the agent"
            is CallState.Connecting -> "Connecting…"
            is CallState.Connected -> "Connected — say hello 👋"
            is CallState.Ended -> "Call ended"
            is CallState.Failed -> "Failed: ${current.error.message}"
        }
    }

    Column(
        modifier = Modifier.fillMaxSize().padding(32.dp),
        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.Center,
    ) {
        Text("PolyAI Voice", style = MaterialTheme.typography.headlineMedium)
        Spacer(Modifier.height(12.dp))
        Text(
            text = status,
            color = if (state is CallState.Failed || permissionDenied) Color.Red else Color.Unspecified,
            textAlign = TextAlign.Center,
        )
        Spacer(Modifier.height(32.dp))
        Button(
            onClick = ::toggleCall,
            enabled = state !is CallState.Connecting,
            modifier = Modifier.fillMaxWidth().height(56.dp),
        ) {
            Text(if (state is CallState.Connected) "End call" else "Start call")
        }
        if (state is CallState.Connected) {
            Spacer(Modifier.height(12.dp))
            OutlinedButton(
                onClick = {
                    muted = !muted
                    scope.launch { call.setMuted(muted) }
                },
                modifier = Modifier.fillMaxWidth(),
            ) {
                Text(if (muted) "Unmute" else "Mute")
            }
        }
    }
}