implementation("com.infobip:google-webrtc:1.0.42469")

<?xml version="1.0" encoding="utf-8"?>
<androidx.appcompat.widget.LinearLayoutCompat xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">


    <org.webrtc.SurfaceViewRenderer
        android:id="@+id/viewRender"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

</androidx.appcompat.widget.LinearLayoutCompat>

package com.example.myapplication

import android.Manifest
import android.content.pm.PackageManager
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import com.example.myapplication.databinding.TestWebrtcBinding
import org.webrtc.AudioSource
import org.webrtc.Camera1Enumerator
import org.webrtc.EglBase
import org.webrtc.MediaConstraints
import org.webrtc.PeerConnectionFactory
import org.webrtc.PeerConnectionFactory.InitializationOptions
import org.webrtc.SurfaceTextureHelper
import org.webrtc.VideoCapturer
import org.webrtc.VideoSource


class WEbRTcDemo : AppCompatActivity() {


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

        val inflate = TestWebrtcBinding.inflate(layoutInflater)

        setContentView(inflate.root)

        checkPerson()


        // create PeerConnectionFactory
        val initializationOptions =
            InitializationOptions.builder(this).createInitializationOptions()
        PeerConnectionFactory.initialize(initializationOptions)
        val peerConnectionFactory = PeerConnectionFactory.builder().createPeerConnectionFactory()

        // create AudioSource

        val audioSource: AudioSource = peerConnectionFactory.createAudioSource(MediaConstraints())
        peerConnectionFactory.createAudioTrack("101", audioSource)

        val eglBaseContext = EglBase.create().eglBaseContext

        val surfaceTextureHelper = SurfaceTextureHelper.create("CaptureThread", eglBaseContext)

        // create VideoCapturer
        val videoCapturer: VideoCapturer = createCameraCapturer()!!
        val videoSource: VideoSource =
            peerConnectionFactory.createVideoSource(videoCapturer.isScreencast)
        videoCapturer.initialize(
            surfaceTextureHelper,
            applicationContext,
            videoSource.capturerObserver
        )
        videoCapturer.startCapture(480, 640, 30)

        val localView = inflate.viewRender
        localView.setMirror(true)
        localView.init(eglBaseContext, null)

        // create VideoTrack


        val videoTrack = peerConnectionFactory.createVideoTrack("101", videoSource)

        videoTrack.addSink(localView)


    }

    private fun createCameraCapturer(): VideoCapturer? {
        val enumerator = Camera1Enumerator(false)
        val deviceNames = enumerator.deviceNames

        // First, try to find front facing camera
        for (deviceName in deviceNames) {
            if (enumerator.isFrontFacing(deviceName)) {
                val videoCapturer: VideoCapturer? = enumerator.createCapturer(deviceName, null)
                if (videoCapturer != null) {
                    return videoCapturer
                }
            }
        }

        // Front facing camera not found, try something else
        for (deviceName in deviceNames) {
            if (!enumerator.isFrontFacing(deviceName)) {
                val videoCapturer: VideoCapturer? = enumerator.createCapturer(deviceName, null)
                if (videoCapturer != null) {
                    return videoCapturer
                }
            }
        }
        return null
    }


    private fun checkPerson() {
        if (!haNO(arrayOf(Manifest.permission.CAMERA, Manifest.permission.RECORD_AUDIO))) {
            ActivityCompat.requestPermissions(
                this,
                arrayOf(Manifest.permission.CAMERA, Manifest.permission.RECORD_AUDIO),
                500
            )
        }
    }

    private fun haNO(arrayOf: Array<String>): Boolean {
        for (i in arrayOf.indices) {

            if (ActivityCompat.checkSelfPermission(
                    this,
                    arrayOf[i]
                ) != PackageManager.PERMISSION_GRANTED
            ) {
                return false
            }
        }
        return true
    }

    override fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<out String>,
        grantResults: IntArray,
        deviceId: Int
    ) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults, deviceId)

        if (requestCode == 500) {
            for (i in permissions.indices) {
                if (ActivityCompat.checkSelfPermission(
                        this,
                        permissions[i]
                    ) == PackageManager.PERMISSION_GRANTED
                ) {
                    println("${permissions[i]}授权")
                } else {
                    println("${permissions[i]}为授权")
                }
            }
        }
    }


}