Notes for session...

[cdm2012]

import android.Manifest
import android.content.pm.PackageManager
import android.os.Bundle
import android.webkit.PermissionRequest
import android.webkit.WebChromeClient
import android.webkit.WebView
import androidx.activity.ComponentActivity
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.runtime.MutableState
import androidx.compose.runtime.mutableStateOf
import androidx.compose.ui.viewinterop.AndroidView
import androidx.core.content.ContextCompat
import androidx.compose.runtime.remember

class MainActivity : ComponentActivity() {

    private val recordAudioPermissionResult =
        registerForActivityResult(ActivityResultContracts.RequestPermission()) { isGranted: Boolean ->
            if (isGranted) {
                println("Microphone permission granted.")
                // You might want to reload the WebView or trigger the ElevenLabs initialization here
            } else {
                println("Microphone permission denied.")
                // Handle the case where the user denies permission (e.g., show a message)
            }
        }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // ... Compose UI setup ...
    }

    fun checkAndRequestAudioPermission() {
        if (ContextCompat.checkSelfPermission(
                this,
                Manifest.permission.RECORD_AUDIO
            ) == PackageManager.PERMISSION_GRANTED
        ) {
            println("Microphone permission already granted.")
            // Proceed with WebView initialization or ElevenLabs setup
        } else {
            recordAudioPermissionResult.launch(Manifest.permission.RECORD_AUDIO)
        }
    }

    // ... (Inside your Compose UI where you set up the WebView) ...
    val conversationText = remember { mutableStateOf("") }
    AndroidView(factory = { context ->
        WebView(context).apply {
            settings.javaScriptEnabled = true
            webViewClient = WebViewClient() // You might have your own WebViewClient
            webChromeClient = object : WebChromeClient() {
                override fun onPermissionRequest(request: PermissionRequest) {
                    if (request.resources.contains(PermissionRequest.RESOURCE_AUDIO_CAPTURE)) {
                        request.grant(request.resources.toTypedArray())
                    } else {
                        request.deny()
                    }
                }
            }
            addJavascriptInterface(WebAppInterface(conversationText), "Android")
            loadUrl("your_html_file_path_or_url")
        }
    })
    // ...
}

class WebAppInterface(private val conversationText: MutableState<String>) {
    @JavascriptInterface
    fun updateConversation(text: String, type: String, isFinal: Boolean) {
        // ... your implementation ...
    }
}

<elevenlabs-convai agent-id="iwFxFjZC0ZE6GBn5PwrI"></elevenlabs-convai>
<script>
  const convaiWidget = document.querySelector('elevenlabs-convai');

  convaiWidget.addEventListener('message', (event) => {
    const message = event.detail.message;
    // Process the message text here
    console.log('Message:', message);
  });
</script>
<script src="https://elevenlabs.io/convai-widget/index.js" async type="text/javascript"></script>

https://github.com/Kisheo/Kotlin-Webview-Example/tree/master

https://gist.github.com/wheeliechamp/5d5d96e0dcd345ab537195080b0c5398

document.addEventListener('DOMContentLoaded', async () => {
    const widget = document.querySelector('elevenlabs-convai');

    if (widget) {
        try {
            const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
            console.log('Microphone access granted in JavaScript.');
            stream.getTracks().forEach(track => track.stop()); // Stop the stream as we only needed to check permission

            // Now you can safely start the ElevenLabs session
            const conversation = await Conversation.startSession({
                agentId: 'YOUR_AGENT_ID',
                onMessage: (message) => {
                    // ... your onMessage logic ...
                },
                // ... other callbacks ...
            });

        } catch (error) {
            console.error('Error accessing microphone:', error);
            // Display a user-friendly message indicating that microphone access is needed
            alert('Microphone access is required for the ElevenLabs widget.');
        }
    }
});

[cdm2012]

        val html = """
            <!DOCTYPE html>
            <html>
            <head>
                <meta name="viewport" content="width=device-width, initial-scale=1.0">
            </head>
            <body>
                <elevenlabs-convai agent-id="iwFxFjZC0ZE6GBn5PwrI"></elevenlabs-convai>
                <script src="https://elevenlabs.io/convai-widget/index.js" async type="text/javascript"></script>
            </body>
            </html>
        """.trimIndent()

        elevenLabsWebView.loadData(html, "text/html", "UTF-8")

[cdm2012]

    // Request audio permission
    if (ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) {
        ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.RECORD_AUDIO), RECORD_AUDIO_PERMISSION_CODE)
    } else {
        // Permission already granted, load the WebView
        loadElevenLabsWidget()
    }

[cdm2012]

override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults)
    if (requestCode == RECORD_AUDIO_PERMISSION_CODE) {
        if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            // Audio permission granted, load the WebView
            loadElevenLabsWidget()
        } else {
            // Audio permission denied, you might want to show a message to the user
            // or disable voice input functionality in the WebView
            // For now, let's just load it without guaranteed microphone access
            loadElevenLabsWidget()
        }
    }
}

[cdm2012]

    private inner class MyWebViewClient : WebViewClient() {
        override fun onPermissionRequest(view: WebView?, request: PermissionRequest?) {
            request?.let {
                val resources = it.resources
                for (resource in resources) {
                    if (resource == PermissionRequest.RESOURCE_AUDIO_CAPTURE) {
                        if (ContextCompat.checkSelfPermission(view!!.context, Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED) {
                            it.grant(arrayOf(PermissionRequest.RESOURCE_AUDIO_CAPTURE))
                            return
                        } else {
                            it.deny()
                        }
                    }
                    // Handle other permissions if needed
                }
                it.deny()
            }
        }

        override fun onPermissionRequestCanceled(request: PermissionRequest?) {
            super.onPermissionRequestCanceled(request)
            // Handle cancellation if necessary
        }
    }

[cdm2012]

webView.webViewClient = MyWebViewClient() // Set the custom WebViewClient

[cdm2012]

override fun onPageFinished(view: WebView?, url: String?) {
                super.onPageFinished(view, url)
                // Inject and execute the JavaScript after the page has loaded
                val javascript = """
                    document.addEventListener('DOMContentLoaded', async () => {
                        const widget = document.querySelector('elevenlabs-convai');

                        if (widget) {
                            try {
                                const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
                                console.log('Microphone access granted in JavaScript.');
                                stream.getTracks().forEach(track => track.stop()); // Stop the stream

                                // You might need a way to signal back to Android that permission is granted
                                // For simplicity, let's just log for now. You could use JavaScript interface.

                            } catch (error) {
                                console.error('Error accessing microphone:', error);
                                alert('Microphone access is required for the ElevenLabs widget.');
                            }
                        }
                    });
                """.trimIndent()

                elevenLabsWebView.evaluateJavascript(javascript, null)
            }