app/src/main/java/net/osdn/gokigen/gr2control/camera/olympus/wrapper/OlyCameraWrapper.java

   1 package net.osdn.gokigen.gr2control.camera.olympus.wrapper;
   2
   3 import android.app.Activity;
   4 import android.content.SharedPreferences;
   5 import android.graphics.PointF;
   6 import android.util.Log;
   7
   8 import net.osdn.gokigen.gr2control.camera.ICameraRunMode;
   9 import net.osdn.gokigen.gr2control.camera.ILiveViewControl;
  10 import net.osdn.gokigen.gr2control.camera.olympus.wrapper.property.CameraPropertyUtilities;
  11 import net.osdn.gokigen.gr2control.liveview.liveviewlistener.IImageDataReceiver;
  12 import net.osdn.gokigen.gr2control.liveview.liveviewlistener.ILiveViewListener;
  13 import net.osdn.gokigen.gr2control.preference.IPreferencePropertyAccessor;
  14
  15 import java.util.Map;
  16
  17 import androidx.annotation.NonNull;
  18 import androidx.preference.PreferenceManager;
  19 import jp.co.olympus.camerakit.OLYCamera;
  20 import jp.co.olympus.camerakit.OLYCameraLiveViewListener;
  21
  22 /**
  23  *
  24  *
  25  */
  26 class OlyCameraWrapper implements ICameraRunMode, ILiveViewControl, ILiveViewListener, OLYCameraLiveViewListener
  27 {
  28     private final String TAG = toString();
  29     private final Activity context;
  30     private final OLYCamera camera;
  31     private IImageDataReceiver dataReceiver = null;
  32
  33     /**
  34      *
  35      *
  36      */
  37     OlyCameraWrapper(Activity context)
  38     {
  39         this.context = context;
  40         camera = new OLYCamera();
  41         camera.setContext(context.getApplicationContext());
  42     }
  43
  44     /**
  45      *
  46      *
  47      */
  48     OLYCamera getOLYCamera()
  49     {
  50         return (camera);
  51     }
  52
  53     /**
  54      *   ICameraRunMode の実装
  55      *
  56      */
  57     @Override
  58     public void changeRunMode(boolean isRecording)
  59     {
  60         OLYCamera.RunMode runMode = (isRecording) ? OLYCamera.RunMode.Recording : OLYCamera.RunMode.Playback;
  61         Log.v(TAG, "changeRunMode() : " + runMode);
  62         try
  63         {
  64             camera.changeRunMode(runMode);
  65         }
  66         catch (Exception e)
  67         {
  68             e.printStackTrace();
  69         }
  70     }
  71
  72     /**
  73      *
  74      *
  75      */
  76     @Override
  77     public boolean isRecordingMode()
  78     {
  79         boolean isRecordingMode = false;
  80         try
  81         {
  82             OLYCamera.RunMode runMode = camera.getRunMode();
  83             isRecordingMode =  (runMode == OLYCamera.RunMode.Recording);
  84         }
  85         catch (Exception e)
  86         {
  87             e.printStackTrace();
  88         }
  89         return (isRecordingMode);
  90     }
  91
  92
  93     /**
  94      *   ILiveViewControl の実装
  95      *
  96      */
  97     @Override
  98     public void changeLiveViewSize(String size)
  99     {
 100         try
 101         {
 102             camera.changeLiveViewSize(CameraPropertyUtilities.toLiveViewSizeType(size));
 103         }
 104         catch (Exception e)
 105         {
 106             e.printStackTrace();
 107         }
 108     }
 109
 110     /**
 111      *
 112      *
 113      */
 114     @Override
 115     public void startLiveView(boolean isCameraScreen)
 116     {
 117         Log.v(TAG, "startLiveView() : " + isCameraScreen);
 118         try
 119         {
 120             camera.startLiveView();
 121         }
 122         catch (Exception e)
 123         {
 124             e.printStackTrace();
 125         }
 126     }
 127
 128     /**
 129      *
 130      *
 131      */
 132     @Override
 133     public void stopLiveView()
 134     {
 135         try
 136         {
 137             camera.stopLiveView();
 138         }
 139         catch (Exception e)
 140         {
 141             e.printStackTrace();
 142         }
 143     }
 144
 145     /**
 146      *   ライブビューを拡大する
 147      *
 148      */
 149     @Override
 150     public void updateDigitalZoom()
 151     {
 152         try
 153         {
 154             float scale = getDigitalZoomScalePreference();
 155             camera.changeDigitalZoomScale(scale);
 156             Log.v(TAG, "DIGITAL ZOOM SCALE : " + scale);
 157         }
 158         catch (Exception e)
 159         {
 160             e.printStackTrace();
 161         }
 162     }
 163
 164     /**
 165      *   ライブビューを拡大する
 166      *
 167      */
 168     @Override
 169     public void updateMagnifyingLiveViewScale(boolean isChangeScale)
 170     {
 171        try
 172        {
 173            updateMagnifyingLiveViewScale(getMagnifyingLiveViewScale(isChangeScale));
 174        }
 175        catch (Exception e)
 176        {
 177            e.printStackTrace();
 178        }
 179     }
 180
 181     /**
 182      *   ライブビューのサイズ
 183      *
 184      * @return  ライブビュー倍率
 185      */
 186     @Override
 187     public float getMagnifyingLiveViewScale()
 188     {
 189         return (getMagnifyingLiveViewScale(false));
 190     }
 191
 192     /**
 193      *   デジタルズームの倍率を取得する
 194      *
 195      */
 196     @Override
 197     public float getDigitalZoomScale()
 198     {
 199         return (getDigitalZoomScalePreference());
 200     }
 201
 202     /**
 203      *
 204      *
 205      */
 206     private void updateMagnifyingLiveViewScale(float scale)
 207     {
 208         try
 209         {
 210             if (scale < 5.0f)
 211             {
 212                 if (camera.isMagnifyingLiveView())
 213                 {
 214                     camera.stopMagnifyingLiveView();
 215                     Log.v(TAG, "RESET LIVE VIEW SCALE : " + 1.0f);
 216                 }
 217                 return;
 218             }
 219             OLYCamera.MagnifyingLiveViewScale setScale;
 220             if (scale >= 14.0f)
 221             {
 222                 setScale = OLYCamera.MagnifyingLiveViewScale.X14;
 223             }
 224             else if (scale >= 10.0f)
 225             {
 226                 setScale = OLYCamera.MagnifyingLiveViewScale.X10;
 227             }
 228             else if (scale >= 7.0f)
 229             {
 230                 setScale = OLYCamera.MagnifyingLiveViewScale.X7;
 231             }
 232             else // if (scale >= 5.0f)
 233             {
 234                 setScale = OLYCamera.MagnifyingLiveViewScale.X5;
 235             }
 236             changeMagnifyingLiveView(setScale);
 237             Log.v(TAG, "SET LIVE VIEW SCALE : " + scale);
 238         }
 239         catch (Exception e)
 240         {
 241             e.printStackTrace();
 242         }
 243     }
 244
 245     /**
 246      *   ライブビューの中心を拡大する
 247      *
 248      */
 249     private void changeMagnifyingLiveView(OLYCamera.MagnifyingLiveViewScale setScale)
 250     {
 251         try
 252         {
 253             PointF centerPoint = new PointF(0.5f, 0.5f);  // 中心座標
 254             if (camera.isMagnifyingLiveView())
 255             {
 256                 camera.changeMagnifyingLiveViewScale(setScale);
 257             }
 258             else
 259             {
 260                 camera.startMagnifyingLiveViewAtPoint(centerPoint, setScale);
 261             }
 262         }
 263         catch (Exception e)
 264         {
 265             e.printStackTrace();
 266         }
 267     }
 268
 269     /**
 270      *   ライブビュー拡大倍率の設定値を応答する
 271      *
 272      */
 273     private float getMagnifyingLiveViewScale(boolean isChangeScale)
 274     {
 275         float scale;
 276         SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
 277         String value = preferences.getString(IPreferencePropertyAccessor.MAGNIFYING_LIVE_VIEW_SCALE, IPreferencePropertyAccessor.MAGNIFYING_LIVE_VIEW_SCALE_DEFAULT_VALUE);
 278         try
 279         {
 280             scale = Float.parseFloat(value);
 281             String changeValue = null;
 282             if(isChangeScale)
 283             {
 284                 if (scale >= 14.0f)
 285                 {
 286                     scale = 1.0f;
 287                     changeValue = "1.0";
 288                 }
 289                 else if (scale >= 10.0f)
 290                 {
 291                     scale = 14.0f;
 292                     changeValue = "14.0";
 293                 }
 294                 else if (scale >= 7.0f)
 295                 {
 296                     scale = 10.0f;
 297                     changeValue = "10.0";
 298                 }
 299                 else if (scale >= 5.0f)
 300                 {
 301                     scale = 7.0f;
 302                     changeValue = "7.0";
 303                 }
 304                 else // if (scale < 5.0f)
 305                 {
 306                     scale = 5.0f;
 307                     changeValue = "5.0";
 308                 }
 309             }
 310             if (changeValue != null)
 311             {
 312                 SharedPreferences.Editor editor = preferences.edit();
 313                 editor.putString(IPreferencePropertyAccessor.MAGNIFYING_LIVE_VIEW_SCALE, changeValue);
 314                 editor.apply();
 315             }
 316         }
 317         catch (Exception e)
 318         {
 319             e.printStackTrace();
 320             scale = 1.0f;
 321         }
 322         return (scale);
 323     }
 324
 325     /**
 326      *   デジタルズーム倍率の設定値を応答する
 327      *
 328      */
 329     private float getDigitalZoomScalePreference()
 330     {
 331         float scale;
 332         SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
 333         String value = preferences.getString(IPreferencePropertyAccessor.DIGITAL_ZOOM_LEVEL, IPreferencePropertyAccessor.DIGITAL_ZOOM_LEVEL_DEFAULT_VALUE);
 334         try
 335         {
 336             Map<String, Float> range = camera.getDigitalZoomScaleRange();
 337             float max = range.get(OLYCamera.DIGITAL_ZOOM_SCALE_RANGE_MAXIMUM_KEY);
 338             float min = range.get(OLYCamera.DIGITAL_ZOOM_SCALE_RANGE_MINIMUM_KEY);
 339
 340             if (value.equals("MAX"))
 341             {
 342                 scale = max;
 343             }
 344             else
 345             {
 346                 scale = Float.parseFloat(value);
 347             }
 348             if (scale < min)
 349             {
 350                 scale = min;
 351             }
 352             else if (scale > max)
 353             {
 354                 scale = max;
 355             }
 356         }
 357         catch (Exception e)
 358         {
 359             e.printStackTrace();
 360             scale = 1.0f;
 361         }
 362         return (scale);
 363     }
 364
 365     /**
 366      *
 367      *
 368      */
 369     @Override
 370     public void setCameraLiveImageView(@NonNull IImageDataReceiver target)
 371     {
 372         try
 373         {
 374             dataReceiver = target;
 375             if (camera != null)
 376             {
 377                 camera.setLiveViewListener(this);
 378             }
 379         }
 380         catch (Exception e)
 381         {
 382             e.printStackTrace();
 383         }
 384     }
 385
 386     /**
 387      *
 388      *
 389      */
 390     @Override
 391     public void onUpdateLiveView(OLYCamera olyCamera, byte[] bytes, Map<String, Object> map)
 392     {
 393         try
 394         {
 395             if (dataReceiver != null)
 396             {
 397                 dataReceiver.setImageData(bytes, map);
 398             }
 399         }
 400         catch (Exception e)
 401         {
 402             e.printStackTrace();
 403         }
 404     }
 405 }