現在、以下のプログラムでandroidの端末のカメラを起動するプログラムを作成しています。

```

    package com.example.mycameraxapp;
    
    import androidx.appcompat.app.AppCompatActivity
    import android.os.Bundle
    import android.Manifest
    import android.content.pm.PackageManager
    import android.net.Uri
    import android.util.Log
    import android.widget.Toast
    import androidx.core.app.ActivityCompat
    import androidx.core.content.ContextCompat
    import java.util.concurrent.Executors
    import androidx.camera.core.*
    import androidx.camera.lifecycle.ProcessCameraProvider
    import kotlinx.android.synthetic.main.activity_main.*
    import java.io.File
    import java.nio.ByteBuffer
    import java.text.SimpleDateFormat
    import java.util.*
    import java.util.concurrent.ExecutorService
    import androidx.camera.core.CameraControl
    
    typealias LumaListener = (luma: Double) -> Unit
    
    class MainActivity : AppCompatActivity() {
        private var imageCapture: ImageCapture? = null
    
        private lateinit var outputDirectory: File
        private lateinit var cameraExecutor: ExecutorService
    
        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            setContentView(R.layout.activity_main)
    
            // Request camera permissions
            if (allPermissionsGranted()) {
                startCamera()
            } else {
                ActivityCompat.requestPermissions(
                    this, REQUIRED_PERMISSIONS, REQUEST_CODE_PERMISSIONS)
            }
    
            // Set up the listener for take photo button
            camera_capture_button.setOnClickListener { takePhoto() }
    
            outputDirectory = getOutputDirectory()
    
            cameraExecutor = Executors.newSingleThreadExecutor()
        }
    
        private fun takePhoto() {}
    
        private fun startCamera() {
            val cameraProviderFuture = ProcessCameraProvider.getInstance(this)
            cameraProviderFuture.addListener(Runnable {
                // Used to bind the lifecycle of cameras to the lifecycle owner
                val cameraProvider: ProcessCameraProvider = cameraProviderFuture.get()
                // Preview
                val preview = Preview.Builder()
                    .build()
                    .also {
                        it.setSurfaceProvider(viewFinder.surfaceProvider)
                    }
                // Select back camera as a default
                val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA
                try {
                    // Unbind use cases before rebinding
                    cameraProvider.unbindAll()
                    // Bind use cases to camera
                    cameraProvider.bindToLifecycle(
                        this, cameraSelector, preview)
                } catch(exc: Exception) {
                    Log.e(TAG, "Use case binding failed", exc)
                }
                
                // 露光補正値設定
                var cameraexposure = Camera.CameraControl()
                    cameraexposure.setExposureCompensationIndex(30)
                
            }, ContextCompat.getMainExecutor(this))
        }
    
        private fun allPermissionsGranted() = REQUIRED_PERMISSIONS.all {
            ContextCompat.checkSelfPermission(
                baseContext, it) == PackageManager.PERMISSION_GRANTED
        }
    
        private fun getOutputDirectory(): File {
            val mediaDir = externalMediaDirs.firstOrNull()?.let {
                File(it, resources.getString(R.string.app_name)).apply { mkdirs() } }
            return if (mediaDir != null && mediaDir.exists())
                mediaDir else filesDir
        }
    
        override fun onDestroy() {
            super.onDestroy()
            cameraExecutor.shutdown()
        }
    
        companion object {
            private const val TAG = "CameraXBasic"
            private const val FILENAME_FORMAT = "yyyy-MM-dd-HH-mm-ss-SSS"
            private const val REQUEST_CODE_PERMISSIONS = 10
            private val REQUIRED_PERMISSIONS = arrayOf(Manifest.permission.CAMERA)
        }
    
        override fun onRequestPermissionsResult(
            requestCode: Int, permissions: Array<String>, grantResults:
            IntArray) {
            super.onRequestPermissionsResult(requestCode, permissions, grantResults)
            if (requestCode == REQUEST_CODE_PERMISSIONS) { //リクエストコードが正しいか確認
                if (allPermissionsGranted()) { //カメラへのアクセス権限がある場合はカメラを起動
                    startCamera()
                } else { //権限がなければトーストを提示して権限がないことを通知
                    Toast.makeText(this,
                        "Permissions not granted by the user.",
                        Toast.LENGTH_SHORT).show()
                    finish()
                }
            }
        }
    }
    
```

カメラの起動自体はできたので、次にプレビュー画面の露光補正値を変更しようと思い、公式ドキュメントを元に作成しているのですが、公式に記載された内容をどのように実装したら良いか分からず困っています。

<https://developer.android.com/reference/kotlin/androidx/camera/core/CameraControl?hl=ja#setExposureCompensationIndex(kotlin.Int)>

こちらのサイトの「setExposureCompensationIndex」を使用して値を変更しようとしています。  
上記のコードでもあるように、setExposureCompensationIndexをメソッドに持つ「CameraControl」インターフェースをインポートしています。

```

    import androidx.camera.core.CameraControl
    
```

そして、メソッドを使用するために以下の記述をしているのですが、CameraControlの部分が「Rename
Reference」と赤字になってしまいうまくいきません。

```

    // 露光補正値設定
    var cameraexposure = Camera.CameraControl()
        cameraexposure.setExposureCompensationIndex(30)
    
```

公式ドキュメントを見ても詳しい実装の方法が分からず困っています。
CC BY-SA 4.0
2021-08-19T08:43:15.897
80914
2021-08-22T02:19:08.107
46924
question
java android kotlin
androidXのCameraControlを使用して、カメラの露光補正値を変更したいです。
cameraに対して操作する時は、ライフサイクルに関連付けたインスタンスを操作する必要があります。

```

    val camera = cameraProvider.bindToLifecycle(this, cameraSelector, preview)
    
```

露出補正を設定する場合は、先にサポートしているかを確認します。

```

    val exposureState = camera.cameraInfo.exposureState
    if(exposureState.isExposureCompensationSupported) { ... }
    
```

端末のカメラがそれをサポートしている場合、露出補正値を設定します。  
ここでは露出補正が30を例にしていますが、Rangeの範囲内を指定してください。  
これは端末ごとに異なる可能性があります。

```

    if(exposureState.isExposureCompensationSupported) {
        val range = exposureState.exposureCompensationRange
    
        if(range.contains(30)) {
            camera.cameraControl.setExposureCompensationIndex(30)
        }
    }
    
```

cameraxのversionが 1.0系だと、露出補正は実験的APIのためのエラーが出る可能性があります。
CC BY-SA 4.0
2021-08-22T02:19:08.107
80961
2021-08-22T02:19:08.107
39410
80914
answer