wear/src/main/java/jp/sfjp/gokigen/a01c/olycamerawrapper/OlyCameraCoordinator.java

   1 package jp.sfjp.gokigen.a01c.olycamerawrapper;
   2
   3 import android.app.Activity;
   4 import android.graphics.PointF;
   5 import android.util.Log;
   6 import android.view.MotionEvent;
   7 import android.widget.Toast;
   8
   9 import jp.co.olympus.camerakit.OLYCamera;
  10 import jp.co.olympus.camerakit.OLYCameraLiveViewListener;
  11 import jp.co.olympus.camerakit.OLYCameraStatusListener;
  12
  13 import jp.sfjp.gokigen.a01c.IShowInformation;
  14 import jp.sfjp.gokigen.a01c.R;
  15 import jp.sfjp.gokigen.a01c.liveview.IAutoFocusFrameDisplay;
  16 import jp.sfjp.gokigen.a01c.liveview.ICameraStatusReceiver;
  17 import jp.sfjp.gokigen.a01c.olycamerawrapper.takepicture.AutoFocusControl;
  18 import jp.sfjp.gokigen.a01c.olycamerawrapper.takepicture.MovieRecordingControl;
  19 import jp.sfjp.gokigen.a01c.olycamerawrapper.takepicture.SingleShotControl;
  20 import jp.sfjp.gokigen.a01c.preference.ICameraPropertyAccessor;
  21
  22 /**
  23  *   OlyCameraCoordinator : Olympus Air との接続、切断の間をとりもつクラス。
  24  *                         (OLYCameraクラスの実体を保持する)
  25  *
  26  *    1. クラスを作成する
  27  *    2. connectWifi() でカメラと接続する
  28  *    3. disconnect() でカメラと切断する
  29  *
  30  *    X. onDisconnectedByError() でカメラの通信状態が変更されたことを受信する
  31  *    o. CameraInteractionCoordinator.ICameraCallback でカメラとの接続状態を通知する
  32  *
  33  */
  34 public class OlyCameraCoordinator implements IOlyCameraCoordinator, IIndicatorControl, ICameraRunMode, IOLYCameraObjectProvider
  35 {
  36     private final String TAG = toString();
  37     private final IAutoFocusFrameDisplay focusFrameDisplay;
  38     private final OLYCamera camera;
  39     private final Activity context;
  40
  41     // 本クラスの配下のカメラ制御クラス群
  42     private final AutoFocusControl autoFocus;
  43     private final SingleShotControl singleShot;
  44     private final MovieRecordingControl movieControl;
  45     private final OlyCameraPropertyProxy propertyProxy;
  46     private final LoadSaveCameraProperties loadSaveCameraProperties;
  47     private final OlyCameraConnection cameraConnection;
  48     private final ICameraStatusDisplay cameraStatusDisplay;
  49     private final LevelMeterHolder levelMeter;
  50
  51     private boolean isManualFocus = false;
  52     private boolean isAutoFocusLocked = false;
  53     private boolean isExposureLocked = false;
  54
  55     /**
  56      * コンストラクタ
  57      */
  58     public OlyCameraCoordinator(Activity context, IAutoFocusFrameDisplay focusFrameDisplay, IShowInformation showInformation, ICameraStatusReceiver receiver)
  59     {
  60         this.context = context;
  61         this.focusFrameDisplay = focusFrameDisplay;
  62
  63         // OLYMPUS CAMERA クラスの初期化、リスナの設定
  64         camera = new OLYCamera();
  65         camera.setContext(context.getApplicationContext());
  66
  67         this.cameraConnection = new OlyCameraConnection(context, camera, receiver);
  68         camera.setConnectionListener(cameraConnection);
  69
  70         // 本クラスの配下のカメラ制御クラス群の設定
  71         autoFocus = new AutoFocusControl(camera, focusFrameDisplay, this); // AF制御
  72         singleShot = new SingleShotControl(camera, focusFrameDisplay, this, showInformation);  // １枚撮影
  73         movieControl = new MovieRecordingControl(context, camera, showInformation); // ムービー撮影
  74         propertyProxy = new OlyCameraPropertyProxy(camera); // カメラプロパティ
  75         cameraStatusDisplay = new CameraStatusDisplay(propertyProxy, showInformation);  // 画面表示
  76         this.levelMeter = new LevelMeterHolder(showInformation, android.support.v7.preference.PreferenceManager.getDefaultSharedPreferences(context).getBoolean(ICameraPropertyAccessor.SHOW_LEVEL_GAUGE_STATUS, false));  // デジタル水準器
  77         setCameraStatusListener(new CameraStatusListenerImpl(context, cameraStatusDisplay, levelMeter));
  78         camera.setCameraPropertyListener(new CameraPropertyListenerImpl(cameraStatusDisplay));
  79         loadSaveCameraProperties = new LoadSaveCameraProperties(context, propertyProxy, this);
  80     }
  81
  82     /**
  83      * ライブビューの設定
  84      */
  85     public void setLiveViewListener(OLYCameraLiveViewListener listener)
  86     {
  87         Log.v(TAG, "setLiveViewListener()");
  88         try
  89         {
  90             camera.setLiveViewListener(listener);
  91         }
  92         catch (Exception e)
  93         {
  94             e.printStackTrace();
  95         }
  96     }
  97
  98     /**
  99      *   ライブビューの解像度を設定する
 100      *
 101      */
 102     @Override
 103     public void changeLiveViewSize(String size)
 104     {
 105         Log.v(TAG, "changeLiveViewSize() : " + size);
 106         try
 107         {
 108             camera.changeLiveViewSize(CameraPropertyUtilities.toLiveViewSizeType(size));
 109         }
 110         catch (Exception e)
 111         {
 112             e.printStackTrace();
 113         }
 114     }
 115
 116     /**
 117      *   ライブビューの開始
 118      *
 119      */
 120     @Override
 121     public void startLiveView()
 122     {
 123         Log.v(TAG, "startLiveView()");
 124         try
 125         {
 126             camera.startLiveView();
 127         }
 128         catch (Exception e)
 129         {
 130             e.printStackTrace();
 131         }
 132     }
 133
 134     /**
 135      *   ライブビューの終了
 136      *
 137      */
 138     @Override
 139     public void stopLiveView()
 140     {
 141         Log.v(TAG, "stopLiveView()");
 142         try
 143         {
 144             camera.stopLiveView();
 145         }
 146         catch (Exception e)
 147         {
 148             e.printStackTrace();
 149         }
 150     }
 151
 152     /**
 153      *   撮影モードの更新
 154      *
 155      */
 156     @Override
 157     public void updateTakeMode()
 158     {
 159         cameraStatusDisplay.updateTakeMode();
 160     }
 161
 162     /**
 163      *   フォーカスロックの実行
 164      */
 165     public boolean driveAutoFocus(MotionEvent event)
 166     {
 167         if (event.getAction() != MotionEvent.ACTION_DOWN)
 168         {
 169             return (false);
 170         }
 171         PointF point = focusFrameDisplay.getPointWithEvent(event);
 172         return ((focusFrameDisplay.isContainsPoint(point)) && autoFocus.lockAutoFocus(point));
 173     }
 174
 175     /**
 176      *   フォーカスロックの解除
 177      */
 178     public void unlockAutoFocus()
 179     {
 180         autoFocus.unlockAutoFocus();
 181         focusFrameDisplay.hideFocusFrame();
 182         isAutoFocusLocked = false;
 183     }
 184
 185     /**
 186      *   画像を１枚撮影
 187      */
 188     @Override
 189     public void singleShot()
 190     {
 191         singleShot.singleShot();
 192         {
 193             // 撮影の表示をToastで行う (成功とか失敗とか言っていない)
 194             Toast.makeText(context, R.string.shoot_camera, Toast.LENGTH_SHORT).show();
 195         }
 196     }
 197
 198     /**
 199      *   ムービーの撮影・停止
 200      */
 201     @Override
 202     public void movieControl()
 203     {
 204         movieControl.movieControl();
 205     }
 206
 207     /**
 208      *   撮影確認画像を生成するか設定する
 209      *
 210      */
 211     @Override
 212     public void setRecViewMode(boolean isRecViewMode)
 213     {
 214         try
 215         {
 216             String value = "<" + IOlyCameraProperty.REC_PREVIEW + "/";
 217             if (isRecViewMode)
 218             {
 219                 value = value + "ON>";
 220             }
 221             else
 222             {
 223                 value = value + "OFF>";
 224             }
 225             propertyProxy.setCameraPropertyValue(IOlyCameraProperty.REC_PREVIEW, value);
 226         }
 227         catch (Exception e)
 228         {
 229             e.printStackTrace();
 230         }
 231     }
 232
 233
 234     @Override
 235     public void toggleAutoExposure()
 236     {
 237         try
 238         {
 239             if (isAELock())
 240             {
 241                 Log.v(TAG, "toggleAutoExposure() : unlockAutoExposure()");
 242                 camera.unlockAutoExposure();
 243             }
 244             else
 245             {
 246                 Log.v(TAG, "toggleAutoExposure() : lockAutoExposure()");
 247                 camera.lockAutoExposure();
 248             }
 249             updateIndicatorScreen(false);
 250         }
 251         catch (Exception e)
 252         {
 253             e.printStackTrace();
 254         }
 255         cameraStatusDisplay.updateAeLockState();
 256     }
 257
 258     /**
 259      *   AF/MF の切り替えを行う
 260      *
 261      */
 262     @Override
 263     public void toggleManualFocus()
 264     {
 265         try
 266         {
 267             boolean isHideFocusFrame = false;
 268             String property_name = IOlyCameraProperty.FOCUS_STILL;
 269             String poverty_value = "<" + IOlyCameraProperty.FOCUS_STILL + "/";
 270
 271             // マニュアルフォーカス切替え
 272             if (!isManualFocus)
 273             {
 274                 // AF -> MF  : オートフォーカスを解除して設定する
 275                 Log.v(TAG, "toggleManualFocus() : to " + IOlyCameraProperty.FOCUS_MF);
 276                 poverty_value = poverty_value + IOlyCameraProperty.FOCUS_MF + ">";
 277                 camera.unlockAutoFocus();
 278                 camera.setCameraPropertyValue(property_name, poverty_value);
 279                 isHideFocusFrame = true;
 280             }
 281             else
 282             {
 283                 // MF -> AF
 284                 Log.v(TAG, "toggleManualFocus() : to " + IOlyCameraProperty.FOCUS_SAF);
 285                 poverty_value = poverty_value + IOlyCameraProperty.FOCUS_SAF + ">";
 286                 camera.setCameraPropertyValue(property_name, poverty_value);
 287             }
 288             updateIndicatorScreen(isHideFocusFrame);
 289         }
 290         catch (Exception e)
 291         {
 292             e.printStackTrace();
 293         }
 294     }
 295
 296     private void updateIndicatorScreen(boolean isHideFocusFrame)
 297     {
 298         isManualFocus();
 299         if (isHideFocusFrame)
 300         {
 301             isAutoFocusLocked = false;
 302             focusFrameDisplay.hideFocusFrame();
 303         }
 304         cameraStatusDisplay.updateCameraStatus();
 305     }
 306
 307     @Override
 308     public boolean isManualFocus()
 309     {
 310         isManualFocus = propertyProxy.isManualFocus();
 311         return (isManualFocus);
 312     }
 313
 314     @Override
 315     public boolean isAFLock()
 316     {
 317         return (isAutoFocusLocked);
 318     }
 319
 320     @Override
 321     public boolean isAELock()
 322     {
 323         isExposureLocked = propertyProxy.isExposureLocked();
 324         return (isExposureLocked);
 325     }
 326
 327     @Override
 328     public void setCameraStatusListener(OLYCameraStatusListener listener)
 329     {
 330         camera.setCameraStatusListener(listener);
 331     }
 332
 333     @Override
 334     public String getCameraStatusSummary(ICameraStatusSummary decoder)
 335     {
 336         return (decoder.getCameraStatusMessage(camera, ""));
 337     }
 338
 339     /**
 340      *   ステータス表示をすべて更新する
 341      *
 342      */
 343     @Override
 344     public void updateStatusAll()
 345     {
 346         cameraStatusDisplay.updateCameraStatusAll();
 347     }
 348
 349     @Override
 350     public void changeRunMode(boolean isRecording)
 351     {
 352         OLYCamera.RunMode runMode = (isRecording) ? OLYCamera.RunMode.Recording : OLYCamera.RunMode.Playback;
 353         Log.v(TAG, "changeRunMode() : " + runMode);
 354         try
 355         {
 356             camera.changeRunMode(runMode);
 357         }
 358         catch (Exception e)
 359         {
 360             e.printStackTrace();
 361         }
 362     }
 363
 364     @Override
 365     public boolean isRecordingMode()
 366     {
 367         boolean isRecordingMode = false;
 368         try
 369         {
 370             OLYCamera.RunMode runMode = camera.getRunMode();
 371             isRecordingMode =  (runMode == OLYCamera.RunMode.Recording);
 372         }
 373         catch (Exception e)
 374         {
 375             e.printStackTrace();
 376         }
 377
 378         return (isRecordingMode);
 379     }
 380
 381     @Override
 382     public IOlyCameraPropertyProvider getCameraPropertyProvider()
 383     {
 384         return (propertyProxy);
 385     }
 386
 387     @Override
 388     public ILoadSaveCameraProperties getLoadSaveCameraProperties()
 389     {
 390         return (loadSaveCameraProperties);
 391     }
 392
 393     @Override
 394     public ICameraRunMode getChangeRunModeExecutor()
 395     {
 396         return (this);
 397     }
 398
 399     @Override
 400     public IOlyCameraConnection getConnectionInterface()
 401     {
 402         return (cameraConnection);
 403     }
 404
 405     @Override
 406     public ILevelGauge getLevelGauge()
 407     {
 408         return (levelMeter);
 409     }
 410
 411     @Override
 412     public void onAfLockUpdate(boolean isAfLocked)
 413     {
 414         isAutoFocusLocked = isAfLocked;
 415         updateIndicatorScreen(false);
 416     }
 417
 418     @Override
 419     public OLYCamera getOLYCamera()
 420     {
 421         return (camera);
 422     }
 423
 424 }