<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />

object PermissionTool {
 
    /** 必要な権限 */
    val REQUIRED_PERMISSION_LIST = arrayOf(
        android.Manifest.permission.CAMERA,
        android.Manifest.permission.RECORD_AUDIO
    )
 
    /** 権限があるか */
    fun isGrantedPermission(context: Context): Boolean = REQUIRED_PERMISSION_LIST
        .map { permission -> ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED }
        .all { it }
}

/** 権限ください画面 */
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun PermissionScreen(onGranted: () -> Unit) {
    val permissionRequest = rememberLauncherForActivityResult(
        contract = ActivityResultContracts.RequestMultiplePermissions(),
        onResult = {
            // 権限付与された
            if (it.all { it.value }) {
                onGranted()
            }
        }
    )
 
    Scaffold(
        topBar = { TopAppBar(title = { Text(text = "権限ください") }) }
    ) { innerPadding ->
        Column(modifier = Modifier.padding(innerPadding)) {
 
            Text(text = "権限ください")
 
            Button(onClick = {
                permissionRequest.launch(PermissionTool.REQUIRED_PERMISSION_LIST)
            }) { Text(text = "権限を付与") }
        }
    }
}

/** カメラ画面 */
@Composable
fun CameraScreen() {
 
}

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent {
            KomaDroidTheme {
                CameraOrPermissionScreen()
            }
        }
    }
}
 
// 権限画面かカメラ画面
@Composable
private fun CameraOrPermissionScreen() {
    val context = LocalContext.current
 
    // 権限ない場合は権限ください画面
    val isGrantedPermission = remember { mutableStateOf(PermissionTool.isGrantedPermission(context)) }
    if (!isGrantedPermission.value) {
        PermissionScreen(
            onGranted = { isGrantedPermission.value = true }
        )
    } else {
        CameraScreen()
    }
}

/*
 * Copyright (C) 2021 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
package io.github.takusan23.komadroid.gl
 
import android.opengl.EGL14
import android.opengl.EGLConfig
import android.opengl.EGLExt
import android.view.Surface
 
/**
 * SurfaceView / MediaRecorder / MediaCodec で描画する際に OpenGL ES の設定が必要だが、EGL 周りの設定をしてくれるやつ。
 *
 * @param outputSurface 出力先 [Surface]
 */
class InputSurface(private val outputSurface: Surface) {
    private var mEGLDisplay = EGL14.EGL_NO_DISPLAY
    private var mEGLContext = EGL14.EGL_NO_CONTEXT
    private var mEGLSurface = EGL14.EGL_NO_SURFACE
 
    init {
        eglSetup()
    }
 
    /**
     * Prepares EGL.  We want a GLES 2.0 context and a surface that supports recording.
     */
    private fun eglSetup() {
        mEGLDisplay = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY)
        if (mEGLDisplay == EGL14.EGL_NO_DISPLAY) {
            throw RuntimeException("unable to get EGL14 display")
        }
        val version = IntArray(2)
        if (!EGL14.eglInitialize(mEGLDisplay, version, 0, version, 1)) {
            throw RuntimeException("unable to initialize EGL14")
        }
        // Configure EGL for recording and OpenGL ES 2.0.
        val attribList = intArrayOf(
            EGL14.EGL_RED_SIZE, 8,
            EGL14.EGL_GREEN_SIZE, 8,
            EGL14.EGL_BLUE_SIZE, 8,
            EGL14.EGL_ALPHA_SIZE, 8,
            EGL14.EGL_RENDERABLE_TYPE, EGL14.EGL_OPENGL_ES2_BIT,
            EGL_RECORDABLE_ANDROID, 1,
            EGL14.EGL_NONE
        )
        val configs = arrayOfNulls<EGLConfig>(1)
        val numConfigs = IntArray(1)
        EGL14.eglChooseConfig(mEGLDisplay, attribList, 0, configs, 0, configs.size, numConfigs, 0)
        checkEglError("eglCreateContext RGB888+recordable ES2")
 
        // Configure context for OpenGL ES 2.0.
        val attrib_list = intArrayOf(
            EGL14.EGL_CONTEXT_CLIENT_VERSION, 2,
            EGL14.EGL_NONE
        )
        mEGLContext = EGL14.eglCreateContext(
            mEGLDisplay, configs[0], EGL14.EGL_NO_CONTEXT,
            attrib_list, 0
        )
        checkEglError("eglCreateContext")
 
        // Create a window surface, and attach it to the Surface we received.
        val surfaceAttribs = intArrayOf(
            EGL14.EGL_NONE
        )
        mEGLSurface = EGL14.eglCreateWindowSurface(mEGLDisplay, configs[0], outputSurface, surfaceAttribs, 0)
        checkEglError("eglCreateWindowSurface")
    }
 
    /** Discards all resources held by this class, notably the EGL context. */
    fun destroy() {
        if (mEGLDisplay != EGL14.EGL_NO_DISPLAY) {
            EGL14.eglMakeCurrent(mEGLDisplay, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_CONTEXT)
            EGL14.eglDestroySurface(mEGLDisplay, mEGLSurface)
            EGL14.eglDestroyContext(mEGLDisplay, mEGLContext)
            EGL14.eglReleaseThread()
            EGL14.eglTerminate(mEGLDisplay)
        }
        mEGLDisplay = EGL14.EGL_NO_DISPLAY
        mEGLContext = EGL14.EGL_NO_CONTEXT
        mEGLSurface = EGL14.EGL_NO_SURFACE
    }
 
    /**
     * Makes our EGL context and surface current.
     */
    fun makeCurrent() {
        EGL14.eglMakeCurrent(mEGLDisplay, mEGLSurface, mEGLSurface, mEGLContext)
        checkEglError("eglMakeCurrent")
    }
 
    /**
     * Calls eglSwapBuffers.  Use this to "publish" the current frame.
     */
    fun swapBuffers(): Boolean {
        val result = EGL14.eglSwapBuffers(mEGLDisplay, mEGLSurface)
        checkEglError("eglSwapBuffers")
        return result
    }
 
    /**
     * Sends the presentation time stamp to EGL.  Time is expressed in nanoseconds.
     */
    fun setPresentationTime(nsecs: Long) {
        EGLExt.eglPresentationTimeANDROID(mEGLDisplay, mEGLSurface, nsecs)
        checkEglError("eglPresentationTimeANDROID")
    }
 
    /**
     * Checks for EGL errors.  Throws an exception if one is found.
     */
    private fun checkEglError(msg: String) {
        val error = EGL14.eglGetError()
        if (error != EGL14.EGL_SUCCESS) {
            throw RuntimeException("$msg: EGL error: 0x${Integer.toHexString(error)}")
        }
    }
 
    companion object {
        private const val EGL_RECORDABLE_ANDROID = 0x3142
    }
}

/**
 * 前面背面カメラを、OpenGL ES を使い、同時に重ねて描画する。
 * OpenGL 用スレッドで呼び出してください。
 */
class KomaDroidCameraTextureRenderer {
 
    private val mTriangleVertices = ByteBuffer.allocateDirect(mTriangleVerticesData.size * FLOAT_SIZE_BYTES).order(ByteOrder.nativeOrder()).asFloatBuffer()
    private val mMVPMatrix = FloatArray(16)
    private val mSTMatrix = FloatArray(16)
    private var mProgram = 0
    private var muMVPMatrixHandle = 0
    private var muSTMatrixHandle = 0
    private var maPositionHandle = 0
    private var maTextureHandle = 0
 
    // Uniform 変数のハンドル
    private var sFrontCameraTextureHandle = 0
    private var sBackCameraTextureHandle = 0
    private var iDrawFrontCameraTextureHandle = 0
 
    // スレッドセーフに Bool 扱うため Mutex と CoroutineScope
    private val frameMutex = Mutex()
    private val scope = CoroutineScope(Dispatchers.Default + Job())
 
    // カメラ映像が来ているか。カメラ映像が描画ループの速度よりも遅いので
    private var isAvailableFrontCameraFrame = false
    private var isAvailableBackCameraFrame = false
 
    // カメラ映像は SurfaceTexture を経由してフラグメントシェーダーでテクスチャとして使える
    private var frontCameraTextureId = -1
    private var backCameraTextureId = -1
 
    // SurfaceTexture。カメラ映像をテクスチャとして使えるやつ
    private var frontCameraSurfaceTexture: SurfaceTexture? = null
    private var backCameraSurfaceTexture: SurfaceTexture? = null
 
    // カメラ映像を流す Surface。SurfaceTexture として使われます
    var frontCameraInputSurface: Surface? = null
        private set
    var backCameraInputSurface: Surface? = null
        private set
 
    init {
        mTriangleVertices.put(mTriangleVerticesData).position(0)
    }
 
    /** バーテックスシェーダ、フラグメントシェーダーをコンパイルする。多分 GL スレッドから呼び出してください */
    fun createShader() {
        mProgram = createProgram(VERTEX_SHADER, FRAGMENT_SHADER)
        if (mProgram == 0) {
            throw RuntimeException("failed creating program")
        }
        maPositionHandle = GLES20.glGetAttribLocation(mProgram, "aPosition")
        checkGlError("glGetAttribLocation aPosition")
        if (maPositionHandle == -1) {
            throw RuntimeException("Could not get attrib location for aPosition")
        }
        maTextureHandle = GLES20.glGetAttribLocation(mProgram, "aTextureCoord")
        checkGlError("glGetAttribLocation aTextureCoord")
        if (maTextureHandle == -1) {
            throw RuntimeException("Could not get attrib location for aTextureCoord")
        }
        muMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix")
        checkGlError("glGetUniformLocation uMVPMatrix")
        if (muMVPMatrixHandle == -1) {
            throw RuntimeException("Could not get attrib location for uMVPMatrix")
        }
        muSTMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uSTMatrix")
        checkGlError("glGetUniformLocation uSTMatrix")
        if (muSTMatrixHandle == -1) {
            throw RuntimeException("Could not get attrib location for uSTMatrix")
        }
        sFrontCameraTextureHandle = GLES20.glGetUniformLocation(mProgram, "sFrontCameraTexture")
        checkGlError("glGetUniformLocation sFrontCameraTexture")
        if (sFrontCameraTextureHandle == -1) {
            throw RuntimeException("Could not get attrib location for sFrontCameraTexture")
        }
        sBackCameraTextureHandle = GLES20.glGetUniformLocation(mProgram, "sBackCameraTexture")
        checkGlError("glGetUniformLocation sBackCameraTexture")
        if (sBackCameraTextureHandle == -1) {
            throw RuntimeException("Could not get attrib location for sBackCameraTexture")
        }
        iDrawFrontCameraTextureHandle = GLES20.glGetUniformLocation(mProgram, "iDrawFrontCameraTexture")
        checkGlError("glGetUniformLocation iDrawFrontCameraTexture")
        if (iDrawFrontCameraTextureHandle == -1) {
            throw RuntimeException("Could not get attrib location for iDrawFrontCameraTexture")
        }
 
        // テクスチャ ID を払い出してもらう
        // 前面カメラの映像、背面カメラの映像で2個分
        val textures = IntArray(2)
        GLES20.glGenTextures(2, textures, 0)
 
        // 1個目はフロントカメラ映像
        frontCameraTextureId = textures[0]
        GLES20.glActiveTexture(GLES20.GL_TEXTURE0)
        GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, frontCameraTextureId)
        checkGlError("glBindTexture cameraTextureId")
        GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST.toFloat())
        GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR.toFloat())
        GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE)
        GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE)
        checkGlError("glTexParameter")
 
        // 2個目はバックカメラ映像
        backCameraTextureId = textures[1]
        GLES20.glActiveTexture(GLES20.GL_TEXTURE1)
        GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, backCameraTextureId)
        GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST.toFloat())
        GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR.toFloat())
        GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE)
        GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE)
        checkGlError("glTexParameter")
 
        // glGenTextures で作ったテクスチャは SurfaceTexture で使う
        // カメラ映像は Surface 経由で受け取る
        frontCameraSurfaceTexture = SurfaceTexture(frontCameraTextureId)
        frontCameraInputSurface = Surface(frontCameraSurfaceTexture)
        backCameraSurfaceTexture = SurfaceTexture(backCameraTextureId)
        backCameraInputSurface = Surface(backCameraSurfaceTexture)
 
        // 新しいフレームが使える場合に呼ばれるイベントリスナー
        // 他のスレッドからも書き換わるので Mutex() する
        frontCameraSurfaceTexture?.setOnFrameAvailableListener {
            scope.launch {
                frameMutex.withLock {
                    isAvailableFrontCameraFrame = true
                }
            }
        }
        backCameraSurfaceTexture?.setOnFrameAvailableListener {
            scope.launch {
                frameMutex.withLock {
                    isAvailableBackCameraFrame = true
                }
            }
        }
    }
 
    /** SurfaceTexture のサイズを設定する */
    fun setSurfaceTextureSize(width: Int, height: Int) {
        frontCameraSurfaceTexture?.setDefaultBufferSize(width, height)
        backCameraSurfaceTexture?.setDefaultBufferSize(width, height)
    }
 
    /** 新しいフロントカメラの映像が来ているか */
    suspend fun isAvailableFrontCameraFrame() = frameMutex.withLock {
        if (isAvailableFrontCameraFrame) {
            isAvailableFrontCameraFrame = false
            true
        } else {
            false
        }
    }
 
    /** 新しいバックカメラの映像が来ているか */
    suspend fun isAvailableBackCameraFrame() = frameMutex.withLock {
        if (isAvailableBackCameraFrame) {
            isAvailableBackCameraFrame = false
            true
        } else {
            false
        }
    }
 
    /** フロントカメラ映像のテクスチャを更新する */
    fun updateFrontCameraTexture() {
        if (frontCameraSurfaceTexture?.isReleased == false) {
            frontCameraSurfaceTexture?.updateTexImage()
        }
    }
 
    /** バックカメラ映像のテクスチャを更新する */
    fun updateBackCameraTexture() {
        if (backCameraSurfaceTexture?.isReleased == false) {
            backCameraSurfaceTexture?.updateTexImage()
        }
    }
 
    /** 描画する。GL スレッドから呼び出してください */
    fun draw() {
        // Snapdragon だと glClear が無いと映像が乱れる
        // Google Pixel だと何も起きないのに、、、
        GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT or GLES20.GL_COLOR_BUFFER_BIT)
 
        // 描画する
        checkGlError("draw() start")
        GLES20.glUseProgram(mProgram)
        checkGlError("glUseProgram")
 
        // テクスチャの ID をわたす
        GLES20.glUniform1i(sFrontCameraTextureHandle, 0) // GLES20.GL_TEXTURE0 なので 0
        GLES20.glUniform1i(sBackCameraTextureHandle, 1) // GLES20.GL_TEXTURE1 なので 1
        checkGlError("glUniform1i sFrontCameraTextureHandle sBackCameraTextureHandle")
 
        mTriangleVertices.position(TRIANGLE_VERTICES_DATA_POS_OFFSET)
        GLES20.glVertexAttribPointer(maPositionHandle, 3, GLES20.GL_FLOAT, false, TRIANGLE_VERTICES_DATA_STRIDE_BYTES, mTriangleVertices)
        checkGlError("glVertexAttribPointer maPosition")
        GLES20.glEnableVertexAttribArray(maPositionHandle)
        checkGlError("glEnableVertexAttribArray maPositionHandle")
        mTriangleVertices.position(TRIANGLE_VERTICES_DATA_UV_OFFSET)
        GLES20.glVertexAttribPointer(maTextureHandle, 2, GLES20.GL_FLOAT, false, TRIANGLE_VERTICES_DATA_STRIDE_BYTES, mTriangleVertices)
        checkGlError("glVertexAttribPointer maTextureHandle")
        GLES20.glEnableVertexAttribArray(maTextureHandle)
        checkGlError("glEnableVertexAttribArray maTextureHandle")
 
        //  --- まずバックカメラ映像を描画する ---
        GLES20.glUniform1i(iDrawFrontCameraTextureHandle, 0)
        checkGlError("glUniform1i iDrawFrontCameraTextureHandle")
 
        // mMVPMatrix リセット
        Matrix.setIdentityM(mMVPMatrix, 0)
 
        backCameraSurfaceTexture?.getTransformMatrix(mSTMatrix)
        GLES20.glUniformMatrix4fv(muSTMatrixHandle, 1, false, mSTMatrix, 0)
        GLES20.glUniformMatrix4fv(muMVPMatrixHandle, 1, false, mMVPMatrix, 0)
        GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4)
        checkGlError("glDrawArrays")
 
        // --- 次にフロントカメラ映像を描画する ---
        GLES20.glUniform1i(iDrawFrontCameraTextureHandle, 1)
        checkGlError("glUniform1i iDrawFrontCameraTextureHandle")
 
        // mMVPMatrix リセット
        Matrix.setIdentityM(mMVPMatrix, 0)
        // 右上に移動させる
        // Matrix.translateM(mMVPMatrix, 0, 1f - 0.3f, 1f - 0.3f, 1f)
        // 右下に移動なら
        Matrix.translateM(mMVPMatrix, 0, 1f - 0.3f, -1f + 0.3f, 1f)
        // 半分ぐらいにする
        Matrix.scaleM(mMVPMatrix, 0, 0.3f, 0.3f, 1f)
 
        // 描画する
        frontCameraSurfaceTexture?.getTransformMatrix(mSTMatrix)
        GLES20.glUniformMatrix4fv(muSTMatrixHandle, 1, false, mSTMatrix, 0)
        GLES20.glUniformMatrix4fv(muMVPMatrixHandle, 1, false, mMVPMatrix, 0)
        GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4)
        checkGlError("glDrawArrays")
        GLES20.glFinish()
    }
 
    /** 破棄時に呼び出す */
    fun destroy() {
        scope.cancel()
        frontCameraSurfaceTexture?.release()
        frontCameraInputSurface?.release()
        backCameraSurfaceTexture?.release()
        backCameraInputSurface?.release()
    }
 
    private fun checkGlError(op: String) {
        val error = GLES20.glGetError()
        if (error != GLES20.GL_NO_ERROR) {
            throw RuntimeException("$op: glError $error")
        }
    }
 
    /**
     * GLSL（フラグメントシェーダー・バーテックスシェーダー）をコンパイルして、OpenGL ES とリンクする
     *
     * @throws GlslSyntaxErrorException 構文エラーの場合に投げる
     * @throws RuntimeException それ以外
     * @return 0 以外で成功
     */
    private fun createProgram(vertexSource: String, fragmentSource: String): Int {
        val vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexSource)
        if (vertexShader == 0) {
            return 0
        }
        val pixelShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource)
        if (pixelShader == 0) {
            return 0
        }
        var program = GLES20.glCreateProgram()
        checkGlError("glCreateProgram")
        if (program == 0) {
            return 0
        }
        GLES20.glAttachShader(program, vertexShader)
        checkGlError("glAttachShader")
        GLES20.glAttachShader(program, pixelShader)
        checkGlError("glAttachShader")
        GLES20.glLinkProgram(program)
        val linkStatus = IntArray(1)
        GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, linkStatus, 0)
        if (linkStatus[0] != GLES20.GL_TRUE) {
            GLES20.glDeleteProgram(program)
            program = 0
        }
        return program
    }
 
    /**
     * GLSL（フラグメントシェーダー・バーテックスシェーダー）のコンパイルをする
     *
     * @throws GlslSyntaxErrorException 構文エラーの場合に投げる
     * @throws RuntimeException それ以外
     * @return 0 以外で成功
     */
    private fun loadShader(shaderType: Int, source: String): Int {
        var shader = GLES20.glCreateShader(shaderType)
        checkGlError("glCreateShader type=$shaderType")
        GLES20.glShaderSource(shader, source)
        GLES20.glCompileShader(shader)
        val compiled = IntArray(1)
        GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compiled, 0)
        if (compiled[0] == 0) {
            shader = 0
        }
        return shader
    }
 
    companion object {
        private const val FLOAT_SIZE_BYTES = 4
        private const val TRIANGLE_VERTICES_DATA_STRIDE_BYTES = 5 * FLOAT_SIZE_BYTES
        private const val TRIANGLE_VERTICES_DATA_POS_OFFSET = 0
        private const val TRIANGLE_VERTICES_DATA_UV_OFFSET = 3
 
        private val mTriangleVerticesData = floatArrayOf(
            -1.0f, -1.0f, 0f, 0f, 0f,
            1.0f, -1.0f, 0f, 1f, 0f,
            -1.0f, 1.0f, 0f, 0f, 1f,
            1.0f, 1.0f, 0f, 1f, 1f
        )
 
        private const val VERTEX_SHADER = """
uniform mat4 uMVPMatrix;
uniform mat4 uSTMatrix;
attribute vec4 aPosition;
attribute vec4 aTextureCoord;
varying vec2 vTextureCoord;
void main() {
  gl_Position = uMVPMatrix * aPosition;
  vTextureCoord = (uSTMatrix * aTextureCoord).xy;
}
"""
 
        private const val FRAGMENT_SHADER = """
#extension GL_OES_EGL_image_external : require
precision mediump float;
varying vec2 vTextureCoord;
 
uniform samplerExternalOES sFrontCameraTexture;
uniform samplerExternalOES sBackCameraTexture;
 
// sFrontCameraTexture を描画する場合は 1。
// sBackCameraTexture は 0。
uniform int iDrawFrontCameraTexture;
 
void main() { 
  // 出力色
  vec4 outColor = vec4(0., 0., 0., 1.);
 
  // どっちを描画するのか
  if (bool(iDrawFrontCameraTexture)) {
    // フロントカメラ（自撮り）
    vec4 cameraColor = texture2D(sFrontCameraTexture, vTextureCoord); 
    outColor = cameraColor;
  } else {
    // バックカメラ（外側）
    vec4 cameraColor = texture2D(sBackCameraTexture, vTextureCoord);
    outColor = cameraColor;
  }
 
  // 出力
  gl_FragColor = outColor;
}
"""
    }
 
}

val cameraManager = context.getSystemService(Context.CAMERA_SERVICE) as CameraManager
val frontCameraId = cameraManager
    .cameraIdList
    .first { cameraId -> cameraManager.getCameraCharacteristics(cameraId).get(CameraCharacteristics.LENS_FACING) == CameraCharacteristics.LENS_FACING_FRONT }
cameraManager
    .getCameraCharacteristics(frontCameraId)
    .get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)
    ?.getOutputSizes(SurfaceTexture::class.java)
    ?.forEach {
        println("${it.width}x${it.height}")
    }

/** カメラを開いたり、プレビュー用の SurfaceView を作ったり、静止画撮影したりする */
@OptIn(ExperimentalCoroutinesApi::class)
class KomaDroidCameraManager(private val context: Context) {
    private val scope = CoroutineScope(Dispatchers.Default + Job())
    private val cameraManager = context.getSystemService(Context.CAMERA_SERVICE) as CameraManager
    private val cameraExecutor = Executors.newSingleThreadExecutor()
 
    /** 今のタスク（というか動画撮影）キャンセル用 */
    private var currentJob: Job? = null
 
    /** プレビュー用 OpenGL ES のスレッド */
    private val previewGlThreadDispatcher = newSingleThreadContext("PreviewGlThread")
 
    /** 録画用 OpenGL ES のスレッド */
    private val recordGlThreadDispatcher = newSingleThreadContext("RecordGlThread")
 
    /** 静止画撮影用[ImageReader] */
    private var imageReader: ImageReader? = null
 
    /** 録画用[OpenGlDrawPair] */
    private var recordOpenGlDrawPair: OpenGlDrawPair? = null
 
    /** 出力先 Surface */
    val surfaceView = SurfaceView(context)
 
    /** 破棄時に呼び出す。Activity の onDestroy とかで呼んでください。 */
    fun destroy() {
        scope.cancel()
        recordOpenGlDrawPair?.textureRenderer?.destroy()
        recordOpenGlDrawPair?.inputSurface?.destroy()
        previewGlThreadDispatcher.close()
        recordGlThreadDispatcher.close()
    }
 
    companion object {
        /** 横 */
        const val CAMERA_RESOLUTION_WIDTH = 720
        /** 縦 */
        const val CAMERA_RESOLUTION_HEIGHT = 1280
    }
}

fun main() {
    // テスト用なので runBlocking しています
    runBlocking {
        (0 until 100).map { i ->
            launch(Dispatchers.Default) {
                // どの Java のスレッドで処理されたかを見る
                println("Index = $i / CurrentThread = ${Thread.currentThread().name}")
            }
        }.joinAll() // 100個終わるのを待つ
    }
}

Index = 90 / CurrentThread = DefaultDispatcher-worker-1
Index = 91 / CurrentThread = DefaultDispatcher-worker-1
Index = 92 / CurrentThread = DefaultDispatcher-worker-1
Index = 93 / CurrentThread = DefaultDispatcher-worker-1
Index = 95 / CurrentThread = DefaultDispatcher-worker-3
Index = 98 / CurrentThread = DefaultDispatcher-worker-3
Index = 99 / CurrentThread = DefaultDispatcher-worker-3
Index = 94 / CurrentThread = DefaultDispatcher-worker-4
Index = 97 / CurrentThread = DefaultDispatcher-worker-2
Index = 96 / CurrentThread = DefaultDispatcher-worker-1

fun main() {
    // テスト用なので runBlocking しています
    val singleThreadDispatcher = newSingleThreadContext("SingleThreadDispatcher")
    runBlocking {
        (0 until 100).map { i ->
            launch(singleThreadDispatcher) {
                // どの Java のスレッドで処理されたかを見る
                println("Index = $i / CurrentThread = ${Thread.currentThread().name}")
            }
        }.joinAll() // 100個終わるのを待つ
    }
}

Index = 90 / CurrentThread = SingleThreadDispatcher
Index = 91 / CurrentThread = SingleThreadDispatcher
Index = 92 / CurrentThread = SingleThreadDispatcher
Index = 93 / CurrentThread = SingleThreadDispatcher
Index = 94 / CurrentThread = SingleThreadDispatcher
Index = 95 / CurrentThread = SingleThreadDispatcher
Index = 96 / CurrentThread = SingleThreadDispatcher
Index = 97 / CurrentThread = SingleThreadDispatcher
Index = 98 / CurrentThread = SingleThreadDispatcher
Index = 99 / CurrentThread = SingleThreadDispatcher

/** フロントカメラの ID を返す */
private fun getFrontCameraId(): String = cameraManager
    .cameraIdList
    .first { cameraId -> cameraManager.getCameraCharacteristics(cameraId).get(CameraCharacteristics.LENS_FACING) == CameraCharacteristics.LENS_FACING_FRONT }
 
/** バックカメラの ID を返す */
private fun getBackCameraId(): String = cameraManager
    .cameraIdList
    .first { cameraId -> cameraManager.getCameraCharacteristics(cameraId).get(CameraCharacteristics.LENS_FACING) == CameraCharacteristics.LENS_FACING_BACK }

/**
 * カメラを開く
 * 開くのに成功したら[CameraDevice]を流します。失敗したら null を流します。
 *
 * @param cameraId 起動したいカメラ
 */
@SuppressLint("MissingPermission")
private fun openCameraFlow(cameraId: String) = callbackFlow {
    var _cameraDevice: CameraDevice? = null
    cameraManager.openCamera(cameraId, cameraExecutor, object : CameraDevice.StateCallback() {
        override fun onOpened(camera: CameraDevice) {
            _cameraDevice = camera
            trySend(camera)
        }
 
        override fun onDisconnected(camera: CameraDevice) {
            _cameraDevice = camera
            camera.close()
            trySend(null)
        }
 
        override fun onError(camera: CameraDevice, error: Int) {
            _cameraDevice = camera
            camera.close()
            trySend(null)
        }
    })
    awaitClose { _cameraDevice?.close() }
}

/** 前面カメラ */
private val frontCameraFlow = openCameraFlow(getFrontCameraId()).stateIn(
    scope = scope,
    started = SharingStarted.Eagerly,
    initialValue = null
)
 
/** 背面カメラ */
private val backCameraFlow = openCameraFlow(getBackCameraId()).stateIn(
    scope = scope,
    started = SharingStarted.Eagerly,
    initialValue = null
)

// これでもいいけど、stateIn で変換するのが良さそう
var cameraDevice: CameraDevice? = null
 
openCameraFlow(getFrontCameraId()).collect { cameraDevice = it }

/**
 * [SessionConfiguration]が非同期なので、コルーチンで出来るように
 *
 * @param outputSurfaceList 出力先[Surface]
 */
private suspend fun CameraDevice.awaitCameraSessionConfiguration(
    outputSurfaceList: List<Surface>
) = suspendCancellableCoroutine { continuation ->
    // OutputConfiguration を作る
    val outputConfigurationList = outputSurfaceList.map { surface -> OutputConfiguration(surface) }
    val backCameraSessionConfiguration = SessionConfiguration(SessionConfiguration.SESSION_REGULAR, outputConfigurationList, cameraExecutor, object : CameraCaptureSession.StateCallback() {
        override fun onConfigured(captureSession: CameraCaptureSession) {
            continuation.resume(captureSession)
        }
 
        override fun onConfigureFailed(p0: CameraCaptureSession) {
            continuation.resume(null)
        }
    })
    createCaptureSession(backCameraSessionConfiguration)
}

/**
 * OpenGL ES 描画のための2点セット。
 * [InputSurface]、[KomaDroidCameraTextureRenderer]を持っているだけ。
 */
private data class OpenGlDrawPair(
    val inputSurface: InputSurface,
    val textureRenderer: KomaDroidCameraTextureRenderer
)

/**
 * [surface]を受け取って、[OpenGlDrawPair]を作る
 * この関数は[previewGlThreadDispatcher]や[recordGlThreadDispatcher]等、OpenGL 用スレッドの中で呼び出す必要があります。
 *
 * @param surface 描画先
 * @return [OpenGlDrawPair]
 */
private fun createOpenGlDrawPair(surface: Surface): OpenGlDrawPair {
    val inputSurface = InputSurface(surface)
    val textureRenderer = KomaDroidCameraTextureRenderer()
    // スレッド切り替え済みなはずなので
    inputSurface.makeCurrent()
    textureRenderer.createShader()
    // カメラ映像の解像度
    // 縦持ちだとしても、横のまま入れればいいらしい
    // https://developer.android.com/reference/android/hardware/camera2/CameraDevice#createCaptureSession(android.hardware.camera2.params.SessionConfiguration)
    textureRenderer.setSurfaceTextureSize(width = CAMERA_RESOLUTION_HEIGHT, height = CAMERA_RESOLUTION_WIDTH)
    return OpenGlDrawPair(inputSurface, textureRenderer)
}

/** 静止画モードの初期化 */
private suspend fun initPictureMode() {
    imageReader = ImageReader.newInstance(
        CAMERA_RESOLUTION_WIDTH,
        CAMERA_RESOLUTION_HEIGHT,
        PixelFormat.RGBA_8888,
        2
    )
    // 描画を OpenGL に、プレビューと同じ
    recordOpenGlDrawPair = withContext(recordGlThreadDispatcher) {
        createOpenGlDrawPair(surface = imageReader!!.surface)
    }
}

/**
 * [OpenGlDrawPair]を使って描画する。
 * スレッド注意です！！！。[previewGlThreadDispatcher]や[recordGlThreadDispatcher]から呼び出す必要があります。
 *
 * @param drawPair プレビューとか
 */
private suspend fun renderOpenGl(drawPair: OpenGlDrawPair) {
    if (drawPair.textureRenderer.isAvailableFrontCameraFrame() || drawPair.textureRenderer.isAvailableBackCameraFrame()) {
        // カメラ映像テクスチャを更新して、描画
        drawPair.textureRenderer.updateFrontCameraTexture()
        drawPair.textureRenderer.updateBackCameraTexture()
        drawPair.textureRenderer.draw()
        drawPair.inputSurface.swapBuffers()
    }
}

/**
 * [SurfaceView]へ OpenGL で描画できるやつ。
 * ただ、[SurfaceView]は生成と破棄の非同期コールバックを待つ必要があるため、このような[Flow]を使う羽目になっている。
 * これは[OpenGlDrawPair]の生成までしかやっていないので、破棄は使う側で頼みました。
 *
 * また、[stateIn]でホットフローに変換し、[SurfaceView]のコールバックがいつ呼ばれても大丈夫にする。
 * [callbackFlow]はコールドフローで、collect するまで動かない、いつコールバックが呼ばれるかわからないため、今回はホットフローに変換している。
 */
private val previewOpenGlDrawPairFlow = callbackFlow {
    val callback = object : SurfaceHolder.Callback {
        override fun surfaceCreated(holder: SurfaceHolder) {
            trySend(holder)
        }
 
        override fun surfaceChanged(holder: SurfaceHolder, format: Int, width: Int, height: Int) {
            // do nothing
        }
 
        override fun surfaceDestroyed(holder: SurfaceHolder) {
            trySend(null)
        }
    }
    surfaceView.holder.addCallback(callback)
    awaitClose { surfaceView.holder.removeCallback(callback) }
}.map { holder ->
    // OpenGL ES のセットアップ
    val surface = holder?.surface
    if (surface != null) {
        withContext(previewGlThreadDispatcher) {
            createOpenGlDrawPair(surface)
        }
    } else null
}.stateIn(
    scope = scope,
    started = SharingStarted.Eagerly,
    initialValue = null
)

/** 用意をする */
fun prepare() {
    scope.launch {
        // 静止画撮影の用意
        initPictureMode()
    }
}

/** 用意をする */
fun prepare() {
    scope.launch {
        // 静止画撮影の用意
        initPictureMode()
 
        // プレビュー Surface で OpenGL ES の描画と破棄を行う。OpenGL ES の用意は map { } でやっている。
        // 新しい値が来たら、既存の OpenGlDrawPair は破棄するので、collectLatest でキャンセルを投げてもらうようにする。
        // また、録画用（静止画撮影、動画撮影）も別のところで描画
        launch {
            previewOpenGlDrawPairFlow.collectLatest { previewOpenGlDrawPair ->
                previewOpenGlDrawPair ?: return@collectLatest
 
                try {
                    // OpenGL ES の描画のためのメインループ
                    withContext(previewGlThreadDispatcher) {
                        while (isActive) {
                            renderOpenGl(previewOpenGlDrawPair)
                        }
                    }
                } finally {
                    // 終了時は OpenGL ES の破棄
                    withContext(NonCancellable + previewGlThreadDispatcher) {
                        previewOpenGlDrawPair.textureRenderer.destroy()
                        previewOpenGlDrawPair.inputSurface.destroy()
                    }
                }
            }
        }
    }
}

/** プレビューを始める */
private fun startPreview() {
    scope.launch {
        // キャンセルして、コルーチンが終わるのを待つ
        currentJob?.cancelAndJoin()
        currentJob = launch {
 
            // カメラを開けるか
            // 全部非同期なので、Flow にした後、複数の Flow を一つにしてすべての準備ができるのを待つ。
            combine(
                frontCameraFlow,
                backCameraFlow,
                previewOpenGlDrawPairFlow
            ) { a, b, c -> Triple(a, b, c) }.collect { (frontCamera, backCamera, previewOpenGlDrawPair) ->
 
                // フロントカメラ、バックカメラ、プレビューの OpenGL ES がすべて準備完了になるまで待つ
                frontCamera ?: return@collect
                backCamera ?: return@collect
                previewOpenGlDrawPair ?: return@collect
                val recordOpenGlDrawPair = recordOpenGlDrawPair ?: return@collect
 
                // フロントカメラの設定
                // 出力先
                val frontCameraOutputList = listOfNotNull(
                    previewOpenGlDrawPair.textureRenderer.frontCameraInputSurface,
                    recordOpenGlDrawPair.textureRenderer.frontCameraInputSurface
                )
                val frontCameraCaptureRequest = frontCamera.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW).apply {
                    frontCameraOutputList.forEach { surface -> addTarget(surface) }
                }.build()
                val frontCameraCaptureSession = frontCamera.awaitCameraSessionConfiguration(frontCameraOutputList)
                frontCameraCaptureSession?.setRepeatingRequest(frontCameraCaptureRequest, null, null)
 
                // バックカメラの設定
                val backCameraOutputList = listOfNotNull(
                    previewOpenGlDrawPair.textureRenderer.backCameraInputSurface,
                    recordOpenGlDrawPair.textureRenderer.backCameraInputSurface
                )
                val backCameraCaptureRequest = backCamera.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW).apply {
                    backCameraOutputList.forEach { surface -> addTarget(surface) }
                }.build()
                val backCameraCaptureSession = backCamera.awaitCameraSessionConfiguration(backCameraOutputList)
                backCameraCaptureSession?.setRepeatingRequest(backCameraCaptureRequest, null, null)
            }
        }
    }
}

/** 用意をする */
fun prepare() {
    scope.launch {
 
        // 以下省略...
 
        // プレビューを開始する
        startPreview()
    }
}

/** カメラ画面 */
@Composable
fun CameraScreen() {
    val context = LocalContext.current
    val cameraManager = remember { KomaDroidCameraManager(context) }
 
    // カメラを開く、Composable が破棄されたら破棄する
    DisposableEffect(key1 = Unit) {
        cameraManager.prepare()
        onDispose { cameraManager.destroy() }
    }
 
    Box(modifier = Modifier.fillMaxSize()) {
 
        // OpenGL ES を描画する SurfaceView
        // アスペクト比
        AndroidView(
            modifier = Modifier
                .align(Alignment.Center)
                .fillMaxWidth()
                .aspectRatio(KomaDroidCameraManager.CAMERA_RESOLUTION_WIDTH / KomaDroidCameraManager.CAMERA_RESOLUTION_HEIGHT.toFloat()),
            factory = { cameraManager.surfaceView }
        )
 
        Button(
            modifier = Modifier
                .align(Alignment.BottomCenter)
                .padding(bottom = 50.dp),
            onClick = { /* TODO この後すぐ */ }
        ) { Text(text = "写真撮影") }
    }
}

/** [ImageReader]から写真を取り出して、端末のギャラリーに登録する拡張関数。 */
private suspend fun ImageReader.saveJpegImage() = withContext(Dispatchers.IO) {
    val image = acquireLatestImage()
    val width = image.width
    val height = image.height
    val planes = image.planes
    val buffer = planes[0].buffer
    // なぜか ImageReader のサイズに加えて、何故か Padding が入っていることを考慮する必要がある
    val pixelStride = planes[0].pixelStride
    val rowStride = planes[0].rowStride
    val rowPadding = rowStride - pixelStride * width
    // Bitmap 作成
    val readBitmap = Bitmap.createBitmap(width + rowPadding / pixelStride, height, Bitmap.Config.ARGB_8888)
    readBitmap.copyPixelsFromBuffer(buffer)
    // 余分な Padding を消す
    val editBitmap = Bitmap.createBitmap(readBitmap, 0, 0, CAMERA_RESOLUTION_WIDTH, CAMERA_RESOLUTION_HEIGHT)
    readBitmap.recycle()
    // ギャラリーに登録する
    val contentResolver = context.contentResolver
    val contentValues = contentValuesOf(
        MediaStore.Images.Media.DISPLAY_NAME to "${System.currentTimeMillis()}.jpg",
        MediaStore.Images.Media.RELATIVE_PATH to "${Environment.DIRECTORY_PICTURES}/KomaDroid"
    )
    val uri = contentResolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, contentValues) ?: return@withContext
    contentResolver.openOutputStream(uri)?.use { outputStream ->
        editBitmap.compress(Bitmap.CompressFormat.JPEG, 100, outputStream)
    }
    // 開放
    editBitmap.recycle()
    image.close()
}

/**
 * 静止画撮影する
 * 静止画撮影用に[CameraDevice.TEMPLATE_STILL_CAPTURE]と[CameraCaptureSession.capture]が使われます。
 */
fun takePicture() {
    scope.launch {
        // キャンセルして、コルーチンが終わるのを待つ
        currentJob?.cancelAndJoin()
        currentJob = launch {
 
            // 用意が揃うまで待つ
            val frontCamera = frontCameraFlow.filterNotNull().first()
            val backCamera = backCameraFlow.filterNotNull().first()
            val previewOpenGlDrawPair = previewOpenGlDrawPairFlow.filterNotNull().first()
            val recordOpenGlDrawPair = recordOpenGlDrawPair!!
 
            // フロントカメラの設定
            // 出力先
            val frontCameraOutputList = listOfNotNull(
                previewOpenGlDrawPair.textureRenderer.frontCameraInputSurface,
                recordOpenGlDrawPair.textureRenderer.frontCameraInputSurface
            )
            val frontCameraCaptureRequest = frontCamera.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE).apply {
                frontCameraOutputList.forEach { surface -> addTarget(surface) }
            }.build()
            val frontCameraCaptureSession = frontCamera.awaitCameraSessionConfiguration(frontCameraOutputList)
            frontCameraCaptureSession?.capture(frontCameraCaptureRequest, null, null)
 
            // バックカメラの設定
            val backCameraOutputList = listOfNotNull(
                previewOpenGlDrawPair.textureRenderer.backCameraInputSurface,
                recordOpenGlDrawPair.textureRenderer.backCameraInputSurface
            )
            val backCameraCaptureRequest = backCamera.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE).apply {
                backCameraOutputList.forEach { surface -> addTarget(surface) }
            }.build()
            val backCameraCaptureSession = backCamera.awaitCameraSessionConfiguration(backCameraOutputList)
            backCameraCaptureSession?.capture(backCameraCaptureRequest, null, null)
 
            // ImageReader に描画する
            withContext(recordGlThreadDispatcher) {
                renderOpenGl(recordOpenGlDrawPair)
            }
            // ImageReader で取り出す
            imageReader?.saveJpegImage()
 
            // 撮影したらプレビューに戻す
            withContext(Dispatchers.Main) {
                Toast.makeText(context, "撮影しました", Toast.LENGTH_SHORT).show()
            }
            startPreview()
        }
    }
}

Button(
    modifier = Modifier
        .align(Alignment.BottomCenter)
        .padding(bottom = 50.dp),
    onClick = { cameraManager.takePicture() } // ←ここ
) { Text(text = "写真撮影") }

class KomaDroidCameraManager(
    private val context: Context,
    private val mode: CaptureMode // これ
) {
 
    /** 静止画撮影 or 録画 */
    enum class CaptureMode {
        /** 静止画撮影 */
        PICTURE,
 
        /** 録画 */
        VIDEO
    }
}

/** 静止画撮影用[ImageReader] */
private var imageReader: ImageReader? = null
 
// 下2つを足す
 
/** 録画用の[MediaRecorder] */
private var mediaRecorder: MediaRecorder? = null
 
/** 録画保存先 */
private var saveVideoFile: File? = null

/** 録画モードの初期化 */
private suspend fun initVideoMode() {
    mediaRecorder = (if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) MediaRecorder(context) else MediaRecorder()).apply {
        setAudioSource(MediaRecorder.AudioSource.MIC)
        setVideoSource(MediaRecorder.VideoSource.SURFACE)
        setOutputFormat(MediaRecorder.OutputFormat.MPEG_4)
        setVideoEncoder(MediaRecorder.VideoEncoder.H264)
        setAudioEncoder(MediaRecorder.AudioEncoder.AAC)
        setAudioChannels(2)
        setVideoEncodingBitRate(3_000_000) // H.264 なので高めに
        setVideoFrameRate(30)
        setVideoSize(CAMERA_RESOLUTION_WIDTH, CAMERA_RESOLUTION_HEIGHT)
        setAudioEncodingBitRate(128_000)
        setAudioSamplingRate(44_100)
        // 一時的に getExternalFilesDir に保存する
        saveVideoFile = File(context.getExternalFilesDir(null), "${System.currentTimeMillis()}.mp4")
        setOutputFile(saveVideoFile!!)
        prepare()
    }
    // 描画を OpenGL に、プレビューと同じ
    recordOpenGlDrawPair = withContext(recordGlThreadDispatcher) {
        createOpenGlDrawPair(surface = mediaRecorder!!.surface)
    }
}

/** 用意をする */
fun prepare() {
    scope.launch {
        // モードに応じて初期化を分岐
        when (mode) {
            CaptureMode.PICTURE -> initPictureMode()
            CaptureMode.VIDEO -> initVideoMode()
        }
 
        // プレビュー Surface で OpenGL ES の描画と破棄を行う。OpenGL ES の用意は map { } でやっている。
        // 新しい値が来たら、既存の OpenGlDrawPair は破棄するので、collectLatest でキャンセルを投げてもらうようにする。
        // また、録画用（静止画撮影、動画撮影）も別のところで描画
        launch {
            previewOpenGlDrawPairFlow.collectLatest { previewOpenGlDrawPair ->
                previewOpenGlDrawPair ?: return@collectLatest
 
                try {
                    // OpenGL ES の描画のためのメインループ
                    withContext(previewGlThreadDispatcher) {
                        while (isActive) {
                            renderOpenGl(previewOpenGlDrawPair)
                        }
                    }
                } finally {
                    // 終了時は OpenGL ES の破棄
                    withContext(NonCancellable + previewGlThreadDispatcher) {
                        previewOpenGlDrawPair.textureRenderer.destroy()
                        previewOpenGlDrawPair.inputSurface.destroy()
                    }
                }
            }
        }
 
        // プレビューを開始する
        startPreview()
    }
}

/**
 * 動画撮影をする
 * 静止画撮影用に[CameraDevice.TEMPLATE_RECORD]と[CameraCaptureSession.setRepeatingRequest]が使われます。
 */
fun startRecordVideo() {
    scope.launch {
        // キャンセルして、コルーチンが終わるのを待つ
        currentJob?.cancelAndJoin()
        currentJob = launch {
 
            // カメラを開けるか
            // 全部非同期なのでコールバックを待つ
            combine(
                frontCameraFlow,
                backCameraFlow,
                previewOpenGlDrawPairFlow
            ) { a, b, c -> Triple(a, b, c) }.collectLatest { (frontCamera, backCamera, previewOpenGlDrawPair) ->
 
                // フロントカメラ、バックカメラ、プレビューの OpenGL ES がすべて準備完了になるまで待つ
                frontCamera ?: return@collectLatest
                backCamera ?: return@collectLatest
                previewOpenGlDrawPair ?: return@collectLatest
                val recordOpenGlDrawPair = recordOpenGlDrawPair ?: return@collectLatest
 
                // フロントカメラの設定
                // 出力先
                val frontCameraOutputList = listOfNotNull(
                    previewOpenGlDrawPair.textureRenderer.frontCameraInputSurface,
                    recordOpenGlDrawPair.textureRenderer.frontCameraInputSurface
                )
                val frontCameraCaptureRequest = frontCamera.createCaptureRequest(CameraDevice.TEMPLATE_RECORD).apply {
                    frontCameraOutputList.forEach { surface -> addTarget(surface) }
                }.build()
                val frontCameraCaptureSession = frontCamera.awaitCameraSessionConfiguration(frontCameraOutputList)
                frontCameraCaptureSession?.setRepeatingRequest(frontCameraCaptureRequest, null, null)
 
                // バックカメラの設定
                val backCameraOutputList = listOfNotNull(
                    previewOpenGlDrawPair.textureRenderer.backCameraInputSurface,
                    recordOpenGlDrawPair.textureRenderer.backCameraInputSurface
                )
                val backCameraCaptureRequest = backCamera.createCaptureRequest(CameraDevice.TEMPLATE_RECORD).apply {
                    backCameraOutputList.forEach { surface -> addTarget(surface) }
                }.build()
                val backCameraCaptureSession = backCamera.awaitCameraSessionConfiguration(backCameraOutputList)
                backCameraCaptureSession?.setRepeatingRequest(backCameraCaptureRequest, null, null)
 
                // 録画開始
                mediaRecorder?.start()
                try {
                    // MediaRecorder に OpenGL ES で描画
                    // 録画中はループするのでこれ以降の処理には進まない
                    withContext(recordGlThreadDispatcher) {
                        while (isActive) {
                            renderOpenGl(recordOpenGlDrawPair)
                        }
                    }
                } finally {
                    // 録画終了処理
                    // stopRecordVideo を呼び出したときか、collectLatest から新しい値が来た時
                    // キャンセルされた後、普通ならコルーチンが起動できない。
                    // NonCancellable を付けることで起動できるが、今回のように終了処理のみで使いましょうね
                    withContext(NonCancellable) {
                        mediaRecorder?.stop()
                        mediaRecorder?.release()
                        // 動画ファイルを動画フォルダへコピーさせ、ファイルを消す
                        withContext(Dispatchers.IO) {
                            val contentResolver = context.contentResolver
                            val contentValues = contentValuesOf(
                                MediaStore.Images.Media.DISPLAY_NAME to saveVideoFile!!.name,
                                MediaStore.Images.Media.RELATIVE_PATH to "${Environment.DIRECTORY_MOVIES}/KomaDroid"
                            )
                            val uri = contentResolver.insert(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, contentValues)!!
                            saveVideoFile!!.inputStream().use { inputStream ->
                                contentResolver.openOutputStream(uri)?.use { outputStream ->
                                    inputStream.copyTo(outputStream)
                                }
                            }
                            saveVideoFile!!.delete()
                        }
                        // MediaRecorder は stop したら使えないので、MediaRecorder を作り直してからプレビューに戻す
                        initVideoMode()
                        startPreview()
                    }
                }
            }
        }
    }
}
 
/** [startRecordVideo]を終了する */
fun stopRecordVideo() {
    // startRecordVideo の finally に進みます
    currentJob?.cancel()
}

/** カメラ画面 */
@Composable
fun CameraScreen() {
    val context = LocalContext.current
    // 静止画撮影 or 動画撮影
    val currentMode = remember { mutableStateOf(KomaDroidCameraManager.CaptureMode.PICTURE) }
 
    Box(modifier = Modifier.fillMaxSize()) {
 
        // 静止画モード・動画撮影モード
        when (currentMode.value) {
            KomaDroidCameraManager.CaptureMode.PICTURE -> PictureModeScreen()
            KomaDroidCameraManager.CaptureMode.VIDEO -> VideoModeScreen()
        }
 
        // 切り替えボタン
        SwitchModeButton(
            modifier = Modifier
                .align(Alignment.TopCenter)
                .statusBarsPadding(),
            currentMode = currentMode.value,
            onSelect = { currentMode.value = it }
        )
    }
}
 
@OptIn(ExperimentalMaterial3Api::class)
@Composable
private fun SwitchModeButton(
    modifier: Modifier = Modifier,
    currentMode: KomaDroidCameraManager.CaptureMode,
    onSelect: (KomaDroidCameraManager.CaptureMode) -> Unit
) {
    SingleChoiceSegmentedButtonRow(modifier = modifier) {
        KomaDroidCameraManager.CaptureMode.entries.forEachIndexed { index, mode ->
            SegmentedButton(
                selected = mode == currentMode,
                onClick = { onSelect(mode) },
                shape = SegmentedButtonDefaults.itemShape(
                    index = index,
                    count = KomaDroidCameraManager.CaptureMode.entries.size
                )
            ) {
                Text(text = mode.name)
            }
        }
    }
}
 
@Composable
private fun PictureModeScreen() {
    val context = LocalContext.current
    val cameraManager = remember { KomaDroidCameraManager(context, KomaDroidCameraManager.CaptureMode.PICTURE) }
 
    // カメラを開く、Composable が破棄されたら破棄する
    DisposableEffect(key1 = Unit) {
        cameraManager.prepare()
        onDispose { cameraManager.destroy() }
    }
 
    Box(modifier = Modifier.fillMaxSize()) {
 
        // OpenGL ES を描画する SurfaceView
        // アスペクト比
        AndroidView(
            modifier = Modifier
                .align(Alignment.Center)
                .fillMaxWidth()
                .aspectRatio(KomaDroidCameraManager.CAMERA_RESOLUTION_WIDTH / KomaDroidCameraManager.CAMERA_RESOLUTION_HEIGHT.toFloat()),
            factory = { cameraManager.surfaceView }
        )
 
        Button(
            modifier = Modifier
                .align(Alignment.BottomCenter)
                .padding(bottom = 50.dp),
            onClick = { cameraManager.takePicture() }
        ) { Text(text = "写真撮影") }
    }
}
 
@Composable
private fun VideoModeScreen() {
    val context = LocalContext.current
    val cameraManager = remember { KomaDroidCameraManager(context, KomaDroidCameraManager.CaptureMode.VIDEO) }
 
    // 仮でここに置かせて
    val isRecording = remember { mutableStateOf(false) }
 
    // カメラを開く、Composable が破棄されたら破棄する
    DisposableEffect(key1 = Unit) {
        cameraManager.prepare()
        onDispose { cameraManager.destroy() }
    }
 
    Box(modifier = Modifier.fillMaxSize()) {
 
        // OpenGL ES を描画する SurfaceView
        // アスペクト比
        AndroidView(
            modifier = Modifier
                .align(Alignment.Center)
                .fillMaxWidth()
                .aspectRatio(KomaDroidCameraManager.CAMERA_RESOLUTION_WIDTH / KomaDroidCameraManager.CAMERA_RESOLUTION_HEIGHT.toFloat()),
            factory = { cameraManager.surfaceView }
        )
 
        Button(
            modifier = Modifier
                .align(Alignment.BottomCenter)
                .padding(bottom = 50.dp),
            onClick = {
                if (isRecording.value) {
                    cameraManager.stopRecordVideo()
                } else {
                    cameraManager.startRecordVideo()
                }
                isRecording.value = !isRecording.value
            }
        ) {
            Text(text = if (isRecording.value) "録画終了" else "録画開始")
        }
    }
}

val previewSurface = viewBinding.previewSurface.holder.surface
 
// OpenGL ES の上に構築された、映像を加工するやつ
val akariGraphicsProcessor = AkariGraphicsProcessor(
    outputSurface = previewSurface.surface,
    width = CAMERA_RESOLUTION_WIDTH,
    height = CAMERA_RESOLUTION_HEIGHT
)
akariGraphicsProcessor.prepare()
 
// カメラ映像を OpenGL のテクスチャとして利用できる SurfaceTexture を作る
val frontCameraTexture = akariGraphicsProcessor.genTextureId { texId -> AkariSurfaceTexture(texId) }
val backCameraTexture = akariGraphicsProcessor.genTextureId { texId -> AkariSurfaceTexture(texId) }
 
// エフェクト
val blurEffect = akariGraphicsProcessor.genEffect { AkariEffectFragmentShader(Shaders.BLUR) }
 
// カメラのセットアップ
// 省略...
frontCameraCaptureSession?.setRepeatingRequest(...)
backCameraCaptureSession?.setRepeatingRequest(...)
 
try {
    // 描画のループ
    akariGraphicsProcessor.drawLoop {
        // カメラ映像描画
        drawSurfaceTexture(backCameraTexture) { mvpMatrix ->
            // do nothing
        }
        drawSurfaceTexture(frontCameraTexture) { mvpMatrix ->
            // 小さくする
            Matrix.scaleM(mvpMatrix, 0, 0.3f, 0.3f, 0.3f)
        }
        // Canvas も重ねる
        drawCanvas {
            drawText("Camera Preview", 100f, 100f, paint)
        }
        // エフェクト
        textureRenderer.applyEffect(blurEffect)
    }
} finally {
    akariGraphicsProcessor.destroy()
}

// SurfaceView と OpenGL ES 用スレッドを作る
val openGlDispatcher = newSingleThreadContext("OpenGlThread")
val surfaceView = SurfaceView(this)
 
// SurfaceView の生成コールバックを待つ
surfaceView.holder.addCallback(object : SurfaceHolder.Callback {
    override fun surfaceCreated(holder: SurfaceHolder) {
        // Surface が出来たら OpenGL ES の作成（どっちかというと EGL の作成）と破棄を2回やる
        lifecycleScope.launch {
            // InputSurface.java
            // https://cs.android.com/android/platform/superproject/main/+/main:cts/tests/mediapc/src/android/mediapc/cts/InputSurface.java
            val inputSurface1 = InputSurface(holder.surface)
            withContext(openGlDispatcher) {
                inputSurface1.makeCurrent()
            }
            inputSurface1.release()
            // 同じ Surface で、違う EGL のセットアップをする。inputSurface1 は破棄済み
            val inputSurface2 = InputSurface(holder.surface)
            withContext(openGlDispatcher) {
                inputSurface2.makeCurrent()
            }
            inputSurface2.release()
            println("おわり")
        }
    }
 
    override fun surfaceChanged(holder: SurfaceHolder, format: Int, width: Int, height: Int) {
        // do nothing
    }
 
    override fun surfaceDestroyed(holder: SurfaceHolder) {
        // do nothing
    }
})
 
// 画面に置く
setContentView(surfaceView)

FATAL EXCEPTION: main
Process: io.github.takusan23.opengldrivererror, PID: 31834
java.lang.RuntimeException: eglCreateWindowSurface: EGL error: 0x3003
	at io.github.takusan23.opengldrivererror.InputSurface.checkEglError(InputSurface.java:29)
	at io.github.takusan23.opengldrivererror.InputSurface.createEGLSurface(InputSurface.java:88)
	at io.github.takusan23.opengldrivererror.InputSurface.eglSetup(InputSurface.java:76)
	at io.github.takusan23.opengldrivererror.InputSurface.<init>(InputSurface.java:120)
	at io.github.takusan23.opengldrivererror.MainActivity$onCreate$1$surfaceCreated$1.invokeSuspend(MainActivity.kt:35)

// Surface が出来たら OpenGL ES の作成（どっちかというと EGL の作成）と破棄を2回やる
lifecycleScope.launch {
    // InputSurface.java
    // https://cs.android.com/android/platform/superproject/main/+/main:cts/tests/mediapc/src/android/mediapc/cts/InputSurface.java
    val inputSurface1 = InputSurface(holder.surface)
    withContext(openGlDispatcher) {
        inputSurface1.makeCurrent()
        inputSurface1.release()
    }
    // 同じ Surface で、違う EGL のセットアップをする。inputSurface1 は破棄済み
    val inputSurface2 = InputSurface(holder.surface)
    withContext(openGlDispatcher) {
        inputSurface2.makeCurrent()
        inputSurface2.release()
    }
    println("おわり")
}