wear/src/main/java/jp/sfjp/gokigen/a01c/olycamerawrapper/takepicture/AutoFocusControl.java

   1 package jp.sfjp.gokigen.a01c.olycamerawrapper.takepicture;
   2
   3 import android.graphics.PointF;
   4 import android.graphics.RectF;
   5
   6 import jp.co.olympus.camerakit.OLYCamera;
   7 import jp.co.olympus.camerakit.OLYCameraAutoFocusResult;
   8 import jp.co.olympus.camerakit.OLYCameraKitException;
   9 import jp.sfjp.gokigen.a01c.liveview.IAutoFocusFrameDisplay;
  10 import jp.sfjp.gokigen.a01c.olycamerawrapper.IIndicatorControl;
  11
  12 /**
  13  *   オートフォーカス制御クラス
  14  *
  15  *     1. setAutoFocusFrameDisplay() で AFフレームの表示クラスを設定
  16  *     2. lockAutoFocus() で AF-Lockを実行
  17  *     3. unlockAutoFocus() で AF-Unlock を実行
  18  *
  19  */
  20 public class AutoFocusControl implements OLYCamera.TakePictureCallback
  21 {
  22     private final OLYCamera camera;
  23     private final IIndicatorControl indicator;
  24     private final IAutoFocusFrameDisplay focusFrameDrawer;
  25     private RectF focusFrameRect = null;
  26
  27     /**
  28      *   コンストラクタ
  29      *
  30      */
  31     public AutoFocusControl(OLYCamera camera, IAutoFocusFrameDisplay focusFrameDrawer, IIndicatorControl indicator)
  32     {
  33         this.camera = camera;
  34         this.indicator = indicator;
  35         this.focusFrameDrawer = focusFrameDrawer;
  36     }
  37
  38     /**
  39      *   オートフォーカスを駆動させ、ロックする
  40      *
  41      * @param point  ターゲットAF点
  42      *
  43      */
  44     public boolean lockAutoFocus(PointF point)
  45     {
  46         if (camera.isTakingPicture() || camera.isRecordingVideo())
  47         {
  48             //  撮影中の場合にはフォーカスロックはやらない。
  49             return (false);
  50         }
  51
  52         RectF preFocusFrameRect = getPreFocusFrameRect(point);
  53         showFocusFrame(preFocusFrameRect, IAutoFocusFrameDisplay.FocusFrameStatus.Running, 0.0);
  54
  55         try
  56         {
  57             // Set auto-focus point.
  58             camera.setAutoFocusPoint(point);
  59
  60             // Lock auto-focus.
  61             focusFrameRect = preFocusFrameRect;
  62             camera.lockAutoFocus(this);
  63         }
  64         catch (Exception e)
  65         {
  66             e.printStackTrace();
  67             // Lock failed.
  68             try
  69             {
  70                 camera.clearAutoFocusPoint();
  71                 camera.unlockAutoFocus();
  72                 showFocusFrame(preFocusFrameRect, IAutoFocusFrameDisplay.FocusFrameStatus.Failed, 1.0);
  73             }
  74             catch (Exception ee)
  75             {
  76                 ee.printStackTrace();
  77             }
  78             return (false);
  79         }
  80         return (true);
  81     }
  82
  83     /**
  84      *   AF-Lを解除する
  85      *
  86      */
  87     public void unlockAutoFocus()
  88     {
  89         if (camera.isTakingPicture() || camera.isRecordingVideo())
  90         {
  91             // 撮影中の場合には、フォーカスロック解除はやらない
  92             return;
  93         }
  94
  95         // Unlock auto-focus.
  96         try
  97         {
  98             camera.unlockAutoFocus();
  99             camera.clearAutoFocusPoint();
 100             hideFocusFrame();
 101         }
 102         catch (Exception e)
 103         {
 104             e.printStackTrace();
 105         }
 106     }
 107
 108     @Override
 109     public void onProgress(OLYCamera olyCamera, OLYCamera.TakingProgress takingProgress, OLYCameraAutoFocusResult olyCameraAutoFocusResult)
 110     {
 111         if (takingProgress == OLYCamera.TakingProgress.EndFocusing)
 112         {
 113             if (olyCameraAutoFocusResult.getResult().equals("ok") && olyCameraAutoFocusResult.getRect() != null)
 114             {
 115                 // Lock succeed.
 116                 RectF postFocusFrameRect = olyCameraAutoFocusResult.getRect();
 117                 showFocusFrame(postFocusFrameRect, IAutoFocusFrameDisplay.FocusFrameStatus.Focused, 0.0);
 118
 119             }
 120             else if (olyCameraAutoFocusResult.getResult().equals("none"))
 121             {
 122                 // Could not lock.
 123                 try
 124                 {
 125                     camera.clearAutoFocusPoint();
 126                     camera.unlockAutoFocus();
 127                 }
 128                 catch (OLYCameraKitException ee)
 129                 {
 130                     ee.printStackTrace();
 131                 }
 132                 hideFocusFrame();
 133             }
 134             else
 135             {
 136                 // Lock failed.
 137                 try
 138                 {
 139                     camera.clearAutoFocusPoint();
 140                     camera.unlockAutoFocus();
 141                 }
 142                 catch (OLYCameraKitException ee)
 143                 {
 144                     ee.printStackTrace();
 145                 }
 146                 showFocusFrame(focusFrameRect, IAutoFocusFrameDisplay.FocusFrameStatus.Failed, 1.0);
 147             }
 148         }
 149     }
 150
 151     @Override
 152     public void onCompleted()
 153     {
 154         // フォーカスロック成功、なにもしない
 155     }
 156
 157     @Override
 158     public void onErrorOccurred(Exception e)
 159     {
 160         // フォーカスロック失敗 : 通知される
 161         e.printStackTrace();
 162         try
 163         {
 164             camera.clearAutoFocusPoint();
 165             camera.unlockAutoFocus();
 166             hideFocusFrame();
 167         }
 168         catch (Exception ee)
 169         {
 170             ee.printStackTrace();
 171         }
 172         showFocusFrame(focusFrameRect, IAutoFocusFrameDisplay.FocusFrameStatus.Errored, 1.0);
 173     }
 174
 175     private void showFocusFrame(RectF rect, IAutoFocusFrameDisplay.FocusFrameStatus status, double duration)
 176     {
 177         if (focusFrameDrawer != null)
 178         {
 179             focusFrameDrawer.showFocusFrame(rect, status, duration);
 180         }
 181         indicator.onAfLockUpdate(IAutoFocusFrameDisplay.FocusFrameStatus.Focused == status);
 182     }
 183
 184     private void hideFocusFrame()
 185     {
 186         if (focusFrameDrawer != null)
 187         {
 188             focusFrameDrawer.hideFocusFrame();
 189         }
 190         indicator.onAfLockUpdate(false);
 191     }
 192
 193     private RectF getPreFocusFrameRect(PointF point)
 194     {
 195         float imageWidth = 1.0f;
 196         float imageHeight = 1.0f;
 197         if (focusFrameDrawer != null)
 198         {
 199             imageWidth = focusFrameDrawer.getContentSizeWidth();
 200             imageHeight = focusFrameDrawer.getContentSizeHeight();
 201         }
 202         // Display a provisional focus frame at the touched point.
 203         float focusWidth = 0.125f;  // 0.125 is rough estimate.
 204         float focusHeight = 0.125f;
 205         if (imageWidth > imageHeight)
 206         {
 207             focusHeight *= (imageWidth / imageHeight);
 208         }
 209         else
 210         {
 211             focusHeight *= (imageHeight / imageWidth);
 212         }
 213         return (new RectF(point.x - focusWidth / 2.0f, point.y - focusHeight / 2.0f,
 214                  point.x + focusWidth / 2.0f, point.y + focusHeight / 2.0f));
 215     }
 216 }