app/src/main/java/jp/osdn/gokigen/gokigenassets/camera/camerax/operation/CameraXCameraControl.kt

   1 package jp.osdn.gokigen.gokigenassets.camera.camerax.operation
   2
   3 import android.annotation.SuppressLint
   4 import android.graphics.PointF
   5 import android.graphics.RectF
   6 import android.util.Log
   7 import android.view.MotionEvent
   8 import androidx.camera.camera2.interop.Camera2CameraControl
   9 import androidx.camera.camera2.interop.Camera2CameraInfo
  10 import androidx.camera.core.ExposureState
  11 import androidx.camera.core.FocusMeteringAction
  12 import androidx.camera.core.SurfaceOrientedMeteringPointFactory
  13 import jp.osdn.gokigen.gokigenassets.camera.interfaces.IDisplayInjector
  14 import jp.osdn.gokigen.gokigenassets.camera.interfaces.IFocusingControl
  15 import jp.osdn.gokigen.gokigenassets.camera.interfaces.IFocusingModeNotify
  16 import jp.osdn.gokigen.gokigenassets.liveview.IIndicatorControl
  17 import jp.osdn.gokigen.gokigenassets.liveview.focusframe.IAutoFocusFrameDisplay
  18 import kotlin.math.exp
  19
  20 class CameraXCameraControl : IFocusingControl, IDisplayInjector
  21 {
  22     private var isCameraControlPrepared: Boolean = false
  23     private var isFrameDisplayPrepared: Boolean = false
  24     private lateinit var cameraXCameraControl: androidx.camera.core.CameraControl
  25     private lateinit var cameraXCameraInfo: androidx.camera.core.CameraInfo
  26     private lateinit var frameDisplay: IAutoFocusFrameDisplay
  27     private lateinit var indicatorControl: IIndicatorControl
  28     private lateinit var focusModeNotify: IFocusingModeNotify
  29
  30     companion object
  31     {
  32         private val TAG = CameraXCameraControl::class.java.simpleName
  33     }
  34
  35     fun setCameraControl(camera:  androidx.camera.core.Camera)
  36     {
  37         cameraXCameraControl = camera.cameraControl
  38         cameraXCameraInfo = camera.cameraInfo
  39         isCameraControlPrepared = true
  40     }
  41
  42     // IDisplayInjector
  43     override fun injectDisplay(frameDisplayer: IAutoFocusFrameDisplay, indicator: IIndicatorControl, focusingModeNotify: IFocusingModeNotify)
  44     {
  45         Log.v(TAG, " injectDisplay()")
  46         frameDisplay = frameDisplayer
  47         indicatorControl = indicator
  48         focusModeNotify = focusingModeNotify
  49         isFrameDisplayPrepared = true
  50     }
  51
  52     // IFocusingControl
  53     override fun driveAutoFocus(motionEvent: MotionEvent?): Boolean
  54     {
  55         //Log.v(TAG, "driveAutoFocus()")
  56         if ((!isCameraControlPrepared) || (!isFrameDisplayPrepared) || (motionEvent == null) || (motionEvent.action != MotionEvent.ACTION_DOWN))
  57         {
  58             return (false)
  59         }
  60         try
  61         {
  62             val point: PointF? = frameDisplay.getPointWithEvent(motionEvent)
  63             if ((point != null) && (frameDisplay.isContainsPoint(point)))
  64             {
  65                 lockAutoFocus(point)
  66             }
  67         }
  68         catch (e: Exception)
  69         {
  70             e.printStackTrace()
  71         }
  72         return (false)
  73     }
  74
  75     // IFocusingControl
  76     override fun unlockAutoFocus()
  77     {
  78         if (!isCameraControlPrepared)
  79         {
  80             cameraXCameraControl.cancelFocusAndMetering()
  81         }
  82     }
  83
  84     // IFocusingControl
  85     override fun halfPressShutter(isPressed: Boolean)
  86     {
  87         try
  88         {
  89             val thread = Thread {
  90                 if ((isCameraControlPrepared) && (isFrameDisplayPrepared)) {
  91                     try {
  92                         if (isPressed) {
  93                             val autoFocusPoint =
  94                                 SurfaceOrientedMeteringPointFactory(1.0f, 1.0f).createPoint(.5f, .5f)
  95                             val action =
  96                                 FocusMeteringAction.Builder(autoFocusPoint, FocusMeteringAction.FLAG_AF)
  97                                     //.addPoint(autoFocusPoint, FocusMeteringAction.FLAG_AE)
  98                                     .apply { disableAutoCancel() }.build()
  99                             cameraXCameraControl.startFocusAndMetering(action)
 100                         } else {
 101                             cameraXCameraControl.cancelFocusAndMetering()
 102                         }
 103                     } catch (e: Exception) {
 104                         e.printStackTrace()
 105                     }
 106                 }
 107             }
 108             thread.start()
 109         }
 110         catch (e : Exception)
 111         {
 112             e.printStackTrace()
 113         }
 114     }
 115
 116     private fun lockAutoFocus(point : PointF)
 117     {
 118         try
 119         {
 120             Log.v(TAG, "lockAutoFocus() : [$point]")
 121             val thread = Thread {
 122                 try
 123                 {
 124                     //val autoFocusPoint = SurfaceOrientedMeteringPointFactory(1.0f, 1.0f).createPoint(point.x, point.y)
 125                     val autoFocusPoint = SurfaceOrientedMeteringPointFactory(1.0f, 1.0f).createPoint(point.y, point.x)
 126                     val action = FocusMeteringAction.Builder(autoFocusPoint, FocusMeteringAction.FLAG_AF)
 127                         //FocusMeteringAction.Builder(autoFocusPoint)
 128                             //    .addPoint(autoFocusPoint, FocusMeteringAction.FLAG_AE)
 129                             .apply { disableAutoCancel() }.build()
 130                     cameraXCameraControl.startFocusAndMetering(action)
 131
 132                     showFocusFrame(
 133                         getPreFocusFrameRect(point),
 134                         IAutoFocusFrameDisplay.FocusFrameStatus.Running,
 135                         0.0f
 136                     )
 137                 }
 138                 catch (e : Exception)
 139                 {
 140                     e.printStackTrace()
 141                 }
 142             }
 143             thread.start()
 144         }
 145         catch (e : Exception)
 146         {
 147             e.printStackTrace()
 148         }
 149     }
 150
 151     private fun getPreFocusFrameRect(point: PointF): RectF
 152     {
 153         val focusWidth = 0.075f // 0.075 is rough estimate.
 154         val focusHeight = 0.075f
 155         return RectF(point.x - focusWidth / 2.0f, point.y - focusHeight / 2.0f, point.x + focusWidth / 2.0f, point.y + focusHeight / 2.0f)
 156     }
 157
 158     private fun showFocusFrame(rect: RectF, status: IAutoFocusFrameDisplay.FocusFrameStatus, duration: Float)
 159     {
 160         frameDisplay.showFocusFrame(rect, status, duration)
 161         indicatorControl.onAfLockUpdate(IAutoFocusFrameDisplay.FocusFrameStatus.Focused === status)
 162     }
 163
 164     fun getExposureState() : ExposureState?
 165     {
 166         try
 167         {
 168             if (::cameraXCameraInfo.isInitialized)
 169             {
 170                 return (cameraXCameraInfo.exposureState)
 171             }
 172         }
 173         catch (e : Exception)
 174         {
 175             e.printStackTrace()
 176         }
 177         return (null)
 178     }
 179
 180     fun setExposureCompensation(indexValue : Int)
 181     {
 182         try
 183         {
 184             if (::cameraXCameraControl.isInitialized)
 185             {
 186                 cameraXCameraControl.setExposureCompensationIndex(indexValue)
 187             }
 188         }
 189         catch (e : Exception)
 190         {
 191             e.printStackTrace()
 192         }
 193     }
 194
 195
 196
 197     @SuppressLint("UnsafeOptInUsageError")
 198     fun getCamera2CameraInfo() : Camera2CameraInfo?
 199     {
 200         try
 201         {
 202             if (::cameraXCameraInfo.isInitialized)
 203             {
 204                 return (Camera2CameraInfo.from(cameraXCameraInfo))
 205             }
 206         }
 207         catch (e : Exception)
 208         {
 209             e.printStackTrace()
 210         }
 211         return (null)
 212     }
 213
 214
 215     @SuppressLint("UnsafeOptInUsageError")
 216     fun getCamera2CameraControl() : Camera2CameraControl?
 217     {
 218         try
 219         {
 220             if (::cameraXCameraControl.isInitialized)
 221             {
 222                 return (Camera2CameraControl.from(cameraXCameraControl))
 223             }
 224         }
 225         catch (e : Exception)
 226         {
 227             e.printStackTrace()
 228         }
 229         return (null)
 230     }
 231
 232
 233
 234 }