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

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