wear/src/main/java/jp/sfjp/gokigen/a01c/thetacamerawrapper/ThetaFeatureDispatcher.kt

   1 package jp.sfjp.gokigen.a01c.thetacamerawrapper
   2
   3 import android.util.Log
   4 import android.view.MotionEvent
   5 import androidx.appcompat.app.AppCompatActivity
   6 import androidx.preference.PreferenceDataStore
   7 import jp.sfjp.gokigen.a01c.ICameraController
   8 import jp.sfjp.gokigen.a01c.ICameraFeatureDispatcher
   9 import jp.sfjp.gokigen.a01c.IShowInformation
  10 import jp.sfjp.gokigen.a01c.R
  11 import jp.sfjp.gokigen.a01c.liveview.ILiveImageStatusNotify
  12 import jp.sfjp.gokigen.a01c.olycamerawrapper.property.IOlyCameraProperty
  13 import jp.sfjp.gokigen.a01c.olycamerawrapper.takepicture.IBracketingShotStyle
  14 import jp.sfjp.gokigen.a01c.thetacamerawrapper.operation.ThetaOptionUpdateControl
  15
  16 class ThetaFeatureDispatcher(private val context: AppCompatActivity, private val statusDrawer: IShowInformation, private val camera: ICameraController, private val preferences: PreferenceDataStore, private val liveImageView: ILiveImageStatusNotify, private val optionSet : ThetaOptionUpdateControl, private val statusHolder : IThetaStatusHolder, private val sessionIdProvider : IThetaSessionIdProvider): ICameraFeatureDispatcher
  17 {
  18     private var exposureCompensationIndex : Int = 6
  19     private var exposureProgramIndex : Int = 1
  20     private var thetaFilterModeIndex : Int = 0
  21     private var thetaWhiteBalanceIndex : Int = 0
  22
  23     /**
  24      * 指定した機能を実行する
  25      *
  26      * @param objectId　　　　　操作したオブジェクト
  27      * @param key　          　操作する機能
  28      * @param defaultAction   標準機能
  29      */
  30     override fun dispatchAction(objectId: Int, key: String, defaultAction: Int): Boolean
  31     {
  32         val featureNumber = preferences.getInt(key, defaultAction)
  33         if (featureNumber <= ICameraFeatureDispatcher.FEATURE_ACTION_NONE)
  34         {
  35             // 何もしない
  36             return false
  37         }
  38
  39         // AREA1: Movie/Video切替
  40         // AREA2: Exposure Program
  41         // AREA3: Filter
  42         // AREA4: Settings (未実装)
  43
  44         // 機能実行の割り当て...
  45         var duration = IShowInformation.VIBRATE_PATTERN_SIMPLE_SHORT
  46         when (featureNumber) {
  47             ICameraFeatureDispatcher.FEATURE_TOGGLE_SHOW_GRID ->                    // グリッド標示ON/OFF
  48                 changeShowGrid(objectId)
  49             ICameraFeatureDispatcher.FEATURE_SHUTTER_SINGLESHOT ->                  // シャッター(一枚撮影)
  50                 pushShutterButton()
  51             ICameraFeatureDispatcher.FEATURE_SETTINGS -> {
  52                 showSettingsScreen()                                                // 設定画面を開く
  53                 duration = IShowInformation.VIBRATE_PATTERN_NONE
  54             }
  55             ICameraFeatureDispatcher.FEATURE_CONTROL_MOVIE ->                       // 動画の撮影・撮影終了
  56                 movieControl()
  57             ICameraFeatureDispatcher.FEATURE_CHANGE_TAKEMODE ->                    // 撮影モードの変更
  58                 changeTakeMode()
  59             ICameraFeatureDispatcher.FEATURE_CHANGE_TAKEMODE_REVERSE ->            // 撮影モードの変更（逆順）
  60                 changeTakeModeReverse()
  61             ICameraFeatureDispatcher.FEATURE_EXPOSURE_BIAS_DOWN ->                 // 露出補正を１段階下げる
  62                 changeExposureBiasValueDown()
  63             ICameraFeatureDispatcher.FEATURE_EXPOSURE_BIAS_UP ->                   // 露出補正を１段階上げる
  64                 changeExposureBiasValueUp()
  65             ICameraFeatureDispatcher.FEATURE_SHOW_FAVORITE_DIALOG ->               // Exposure Program(SHOW_FAVORITE_DIALOG)
  66                 changeExposureProgram()
  67             ICameraFeatureDispatcher.FEATURE_CHAGE_AE_LOCK_MODE ->                 // FILTER MODE (AE LOCKのON/OFF切り替え)
  68                 changeFilterMode()
  69             ICameraFeatureDispatcher.FEATURE_CHANGE_AE ->                          // FILTER MODE AE(測光方式)を選択
  70                 changeFilterMode()
  71             ICameraFeatureDispatcher.FEATURE_WB_DOWN ->                            // ホワイトバランスを選択
  72                 changeWhiteBalanceDown()
  73             ICameraFeatureDispatcher.FEATURE_WB_UP ->                              // ホワイトバランスを選択
  74                 changeWhiteBalanceUp()
  75
  76 /*
  77             ICameraFeatureDispatcher.FEATURE_APERTURE_DOWN ->                      // 絞り値を１段階下げる
  78                 changeApertureValueDown()
  79             ICameraFeatureDispatcher.FEATURE_APERTURE_UP ->                        // 絞り値を１段階上げる
  80                 changeApertureValueUp()
  81             ICameraFeatureDispatcher.FEATURE_SHUTTER_SPEED_DOWN ->                 // シャッター速度を１段階下げる
  82                 changeShutterSpeedDown()
  83             ICameraFeatureDispatcher.FEATURE_SHUTTER_SPEED_UP ->                   // シャッター速度を１段階上げる
  84                 changeShutterSpeedUp()
  85             ICameraFeatureDispatcher.FEATURE_COLORTONE_DOWN ->                    // 仕上がり・ピクチャーモードを選択
  86                 changeColorToneDown()
  87             ICameraFeatureDispatcher.FEATURE_COLORTONE_UP ->                       // 仕上がり・ピクチャーモードを選択
  88                 changeColorToneUp()
  89             ICameraFeatureDispatcher.FEATURE_ART_FILTER_DOWN ->                    // アートフィルターを選択
  90                 changeArtFilterDown()
  91             ICameraFeatureDispatcher.FEATURE_ART_FILTER_UP ->                      // アートフィルターを選択
  92                 changeArtFilterUp()
  93             ICameraFeatureDispatcher.FEATURE_TOGGLE_SHOW_LEVEL_GAUGE ->                 // デジタル水準器の表示・非表示
  94                 changeShowLevelGauge()
  95             ICameraFeatureDispatcher.FEATURE_AE_DOWN ->                 // AE(測光方式)を選択
  96                 changeAEModeDown()
  97             ICameraFeatureDispatcher.FEATURE_AE_UP ->                 // AE(測光方式)を選択
  98                 changeAEModeUp()
  99             ICameraFeatureDispatcher.FEATURE_ISO_DOWN ->                 // ISO感度を選択
 100                 changeIsoSensitivityDown()
 101             ICameraFeatureDispatcher.FEATURE_ISO_UP ->                 // ISO感度を選択
 102                 changeIsoSensitivityUp()
 103             ICameraFeatureDispatcher.FEATURE_QUALITY_MOVIE_DOWN ->                 // 動画撮影クオリティを選択
 104                 changeMovieQualityModeDown()
 105             ICameraFeatureDispatcher.FEATURE_QUALITY_MOVIE_UP ->                 // 動画撮影クオリティを選択
 106                 changeMovieQualityModeUp()
 107             ICameraFeatureDispatcher.FEATURE_SHORT_MOVIE_RECORD_TIME_DOWN ->                 // ショートムービー時の撮影時間を選択
 108                 changeShortMovieRecordLengthDown()
 109             ICameraFeatureDispatcher.FEATURE_SHORT_MOVIE_RECORD_TIME_UP ->                 // ショートムービー時の撮影時間を選択
 110                 changeShortMovieRecordLengthUp()
 111             ICameraFeatureDispatcher.FEATURE_EXPOSE_MOVIE_SELECT_DOWN ->                 // 動画の撮影モードを選択
 112                 changeMovieTakeModeDown()
 113             ICameraFeatureDispatcher.FEATURE_EXPOSE_MOVIE_SELECT_UP ->                 // 動画の撮影モードを選択
 114                 changeMovieTakeModeUp()
 115             ICameraFeatureDispatcher.FEATURE_CHANGE_AF_MF ->                 // AF/MFの切り替えを行う
 116                 toggleAfMf()
 117             ICameraFeatureDispatcher.FEATURE_CHANGE_AE ->                 // AE(測光方式)を選択
 118                 changeAEMode(1)
 119             ICameraFeatureDispatcher.FEATURE_CHANGE_AE_REVERSE ->                 // AE(測光方式)を選択
 120                 changeAEMode(-1)
 121             ICameraFeatureDispatcher.FEATURE_SHOT_INTERVAL_3SEC ->                 // ３秒待ってから１枚撮影する
 122                 intervalOneShot(3)
 123             ICameraFeatureDispatcher.FEATURE_SHOT_INTERVAL_5SEC ->                 // 5秒待ってから１枚撮影する
 124                 intervalOneShot(5)
 125             ICameraFeatureDispatcher.FEATURE_SHOT_INTERVAL_10SEC ->                 // 10秒待ってから１枚撮影する
 126                 intervalOneShot(10)
 127             ICameraFeatureDispatcher.FEATURE_SHOT_BRACKET_EXPOSURE ->                 // 露出ブラケット撮影を行う (5枚)
 128                 bracketingShot(IBracketingShotStyle.BRACKET_EXPREV, 5)
 129             ICameraFeatureDispatcher.FEATURE_SHOT_BRACKET_APERATURE ->                 // 絞りブラケット撮影を行う
 130                 bracketingShot(IBracketingShotStyle.BRACKET_APERTURE, 5)
 131             ICameraFeatureDispatcher.FEATURE_SHOT_BRACKET_SHUTTER ->                       // シャッターブラケット撮影を行う
 132                 bracketingShot(IBracketingShotStyle.BRACKET_SHUTTER, 5)
 133             ICameraFeatureDispatcher.FEATURE_SHOT_BRACKET_COLORTONE ->                      // カラートーンブラケット撮影を行う
 134                 bracketingShot(IBracketingShotStyle.BRACKET_COLOR_TONE, 11)
 135             ICameraFeatureDispatcher.FEATURE_SHOT_BRACKET_WB ->                             // ホワイトバランスブラケット撮影を行う
 136                 bracketingShot(IBracketingShotStyle.BRACKET_WB, 7)
 137             ICameraFeatureDispatcher.FEATURE_SHOT_BRACKET_ART_FILTER ->                     // アートフィルターブラケット撮影を行う
 138                 bracketingShot(IBracketingShotStyle.BRACKET_ART_FILTER, 5)
 139             ICameraFeatureDispatcher.FEATURE_SHOT_BRACKET_ISO ->                            // ブラケット撮影を行う
 140                 bracketingShot(IBracketingShotStyle.BRACKET_ISO, 3)
 141             ICameraFeatureDispatcher.FEATURE_SHOW_FAVORITE_DIALOG ->                        // お気に入りのダイアログ表示を行う
 142                 showFavoriteDialog()
 143             ICameraFeatureDispatcher.FEATURE_LENS_ZOOMIN ->                                 // ズームイン（パワーズームレンズ装着時）
 144                 if (!driveZoomLens(1)) {
 145                     duration = IShowInformation.VIBRATE_PATTERN_NONE
 146                 }
 147             ICameraFeatureDispatcher.FEATURE_LENS_ZOOMOUT ->                                // ズームアウト（パワーズームレンズ装着時）
 148                 if (!driveZoomLens(-1)) {
 149                     duration = IShowInformation.VIBRATE_PATTERN_NONE
 150                 }
 151             ICameraFeatureDispatcher.FEATURE_LENS_ZOOMIN_2X ->                              // ズームイン（パワーズームレンズ装着時）
 152                 if (!driveZoomLens(2)) {
 153                     duration = IShowInformation.VIBRATE_PATTERN_NONE
 154                 }
 155             ICameraFeatureDispatcher.FEATURE_LENS_ZOOMOUT_2X ->                             // ズームアウト（パワーズームレンズ装着時）
 156                 if (!driveZoomLens(-2)) {
 157                     duration = IShowInformation.VIBRATE_PATTERN_NONE
 158                 }
 159             ICameraFeatureDispatcher.FEATURE_DIGITAL_ZOOM_RESET ->                         // デジタルズームのリセット
 160                 resetDigitalZoom()
 161             ICameraFeatureDispatcher.FEATURE_DIGITAL_ZOOM_CHANGE ->                        // デジタルズームの設定 (繰り返し)
 162                 if (!driveDigitalZoom(0)) {
 163                     duration = IShowInformation.VIBRATE_PATTERN_NONE
 164                 }
 165             ICameraFeatureDispatcher.FEATURE_DIGITAL_ZOOMIN ->                             // デジタルズーム ズームイン
 166                 if (!driveDigitalZoom(1)) {
 167                     duration = IShowInformation.VIBRATE_PATTERN_NONE
 168                 }
 169             ICameraFeatureDispatcher.FEATURE_DIGITAL_ZOOMOUT ->                            // デジタルズーム ズームアウト
 170                 if (!driveDigitalZoom(-1)) {
 171                     duration = IShowInformation.VIBRATE_PATTERN_NONE
 172                 }
 173             ICameraFeatureDispatcher.FEATURE_CHANGE_LIVEVIEW_MAGNIFY_X5 ->                 // ライブビュー拡大（5倍）
 174                 if (!changeLiveViewMagnify(5)) {
 175                     duration = IShowInformation.VIBRATE_PATTERN_NONE
 176                 }
 177             ICameraFeatureDispatcher.FEATURE_CHANGE_LIVEVIEW_MAGNIFY_X7 ->                 // ライブビュー拡大（7倍）
 178                 if (!changeLiveViewMagnify(7)) {
 179                     duration = IShowInformation.VIBRATE_PATTERN_NONE
 180                 }
 181             ICameraFeatureDispatcher.FEATURE_CHANGE_LIVEVIEW_MAGNIFY_X10 ->                 // ライブビュー拡大（10倍）
 182                 if (!changeLiveViewMagnify(10)) {
 183                     duration = IShowInformation.VIBRATE_PATTERN_NONE
 184                 }
 185             ICameraFeatureDispatcher.FEATURE_CHANGE_LIVEVIEW_MAGNIFY_X14 ->                 // ライブビュー拡大（14倍）
 186                 if (!changeLiveViewMagnify(14)) {
 187                     duration = IShowInformation.VIBRATE_PATTERN_NONE
 188                 }
 189 */
 190             else ->                 // 上記以外...なにもしない
 191                 duration = IShowInformation.VIBRATE_PATTERN_NONE
 192         }
 193
 194         // コマンド実行完了後、ぶるぶるさせる
 195         statusDrawer.vibrate(duration)
 196         return (true)
 197     }
 198
 199     override fun dispatchAreaAction(event: MotionEvent?, areaFeatureNumber: Int): Boolean
 200     {
 201         var ret = false
 202         when (areaFeatureNumber)
 203         {
 204             ICameraFeatureDispatcher.FEATURE_AREA_ACTION_DRIVE_AUTOFOCUS -> ret = camera.driveAutoFocus(event)
 205             ICameraFeatureDispatcher.FEATURE_AREA_ACTION_NOT_CONNECTED -> {
 206             }
 207             ICameraFeatureDispatcher.FEATURE_AREA_ACTION_CHECK_CONTAINS_AUTOFOCUS_AREA ->                 // AUTOFOCUS エリアに含まれているかどうかチェックする
 208                 ret = camera.isContainsAutoFocusPoint(event)
 209             ICameraFeatureDispatcher.FEATURE_AREA_ACTION_NONE ->                 // 何もしない
 210                 ret = false
 211             else -> ret = false
 212         }
 213         return ret
 214     }
 215
 216     /**
 217      * 撮影モードの取得
 218      *
 219      */
 220     override fun getTakeMode(): String
 221     {
 222         return (statusHolder.captureMode)
 223     }
 224
 225     /**
 226      * 撮影モードの変更指示
 227      */
 228     private fun changeTakeMode()
 229     {
 230         //  撮影モードの更新
 231         camera.updateTakeMode()
 232     }
 233
 234     /**
 235      * 撮影モードの変更指示
 236      * (iAuto < P < A < S < M < ART < movie < iAuto < ...)
 237      */
 238     private fun changeTakeModeReverse()
 239     {
 240         changeTakeMode()
 241     }
 242
 243     /**
 244      * シャッターボタンが押された！
 245      * （現在は、連続撮影モードについてはまだ非対応）
 246      */
 247     private fun pushShutterButton()
 248     {
 249         // カメラ側のシャッターを押す
 250         camera.singleShot()
 251     }
 252
 253     /**
 254      * 動画の撮影・停止を行う
 255      *
 256      */
 257     private fun movieControl()
 258     {
 259         camera.movieControl()
 260     }
 261
 262     /**
 263      *   フィルター
 264      *
 265      */
 266     private fun changeFilterMode()
 267     {
 268         try
 269         {
 270             thetaFilterModeIndex++
 271             if (thetaFilterModeIndex > MAX_FILTER_SELECTION)
 272             {
 273                 thetaFilterModeIndex = 0
 274             }
 275             val optionStr = context.resources.getStringArray(R.array.theta_filter_set_value)[thetaFilterModeIndex]
 276             optionSet.setOptions(optionStr, sessionIdProvider.sessionId.isEmpty())
 277         }
 278         catch (e : Exception)
 279         {
 280             e.printStackTrace()
 281         }
 282     }
 283
 284     /**
 285      *   Exposure Program
 286      *
 287      */
 288     private fun changeExposureProgram()
 289     {
 290         try
 291         {
 292             exposureProgramIndex++
 293             if (exposureProgramIndex > MAX_EXPOSURE_PROGRAM)
 294             {
 295                 exposureProgramIndex = 0
 296             }
 297             val optionStr = context.resources.getStringArray(R.array.exposure_program_value)[exposureProgramIndex]
 298             optionSet.setOptions(optionStr, sessionIdProvider.sessionId.isEmpty())
 299         }
 300         catch (e : Exception)
 301         {
 302             e.printStackTrace()
 303         }
 304     }
 305
 306     /**
 307      * AF/MFの切り替えを行う
 308      */
 309     private fun toggleAfMf()
 310     {
 311         camera.toggleManualFocus()
 312     }
 313
 314     /**
 315      * グリッド表示の ON/OFFを切り替える
 316      *
 317      */
 318     private fun changeShowGrid(objectId: Int)
 319     {
 320         liveImageView.toggleShowGridFrame()
 321         updateGridStatusButton(objectId)
 322     }
 323
 324     /**
 325      * 　デジタル水準器の ON/OFFを切り替える
 326      *
 327      */
 328     private fun changeShowLevelGauge()
 329     {
 330         liveImageView.toggleShowLevelGauge()
 331     }
 332
 333     /**
 334      * AE-Lock/Lock解除を行う
 335      *
 336      */
 337     private fun changeAeLockMode()
 338     {
 339         camera.toggleAutoExposure()
 340     }
 341
 342     /**
 343      * グリッドフレームの表示・非表示ボタンを更新する
 344      *
 345      */
 346     private fun updateGridStatusButton(buttonId: Int)
 347     {
 348         val btnResId: Int
 349         btnResId = if (liveImageView.isShowGrid) {
 350             // グリッドがON状態、グリッドをOFFにするボタンを出す
 351             R.drawable.btn_ic_grid_off
 352         } else {
 353             //  グリッドがOFF状態、グリッドをONにするボタンを出す
 354             R.drawable.btn_ic_grid_on
 355         }
 356         statusDrawer.setButtonDrawable(buttonId, btnResId)
 357     }
 358
 359     /**
 360      * 　  露出補正を１段階下げる
 361      */
 362     private fun changeExposureBiasValueDown()
 363     {
 364         try
 365         {
 366             if (exposureCompensationIndex > 0)
 367             {
 368                 exposureCompensationIndex--
 369
 370                 val optionStr = context.resources.getStringArray(R.array.exposure_compensation_value)[exposureCompensationIndex]
 371                 optionSet.setOptions(optionStr, sessionIdProvider.sessionId.isEmpty())
 372             }
 373         }
 374         catch (e : Exception)
 375         {
 376             e.printStackTrace()
 377         }
 378     }
 379
 380     /**
 381      * 露出補正を１段階あげる
 382      *
 383      */
 384     private fun changeExposureBiasValueUp()
 385     {
 386         try
 387         {
 388             if (exposureCompensationIndex < MAX_EXPOSURE_COMPENSATION)
 389             {
 390                 exposureCompensationIndex++
 391
 392                 val optionStr = context.resources.getStringArray(R.array.exposure_compensation_value)[exposureCompensationIndex]
 393                 optionSet.setOptions(optionStr, sessionIdProvider.sessionId.isEmpty())
 394             }
 395         }
 396         catch (e : Exception)
 397         {
 398             e.printStackTrace()
 399         }
 400     }
 401
 402     /**
 403      * 　  絞り値を１段階下げる
 404      */
 405     private fun changeApertureValueDown()
 406     {
 407         val propertyProxy = camera.cameraPropertyProvider
 408         propertyProxy.updateCameraPropertyDown(IOlyCameraProperty.APERTURE)
 409     }
 410
 411     /**
 412      * 絞り値を１段階あげる
 413      *
 414      */
 415     private fun changeApertureValueUp()
 416     {
 417         val propertyProxy = camera.cameraPropertyProvider
 418         propertyProxy.updateCameraPropertyUp(IOlyCameraProperty.APERTURE)
 419     }
 420
 421     /**
 422      * 　  シャッター速度を１段階下げる
 423      */
 424     private fun changeShutterSpeedDown()
 425     {
 426         val propertyProxy = camera.cameraPropertyProvider
 427         propertyProxy.updateCameraPropertyDown(IOlyCameraProperty.SHUTTER_SPEED)
 428     }
 429
 430     /**
 431      * シャッター速度を１段階あげる
 432      *
 433      */
 434     private fun changeShutterSpeedUp()
 435     {
 436         val propertyProxy = camera.cameraPropertyProvider
 437         propertyProxy.updateCameraPropertyUp(IOlyCameraProperty.SHUTTER_SPEED)
 438     }
 439
 440     /**
 441      * 　  仕上がり・ピクチャーモードを１段階下げる
 442      */
 443     private fun changeColorToneDown()
 444     {
 445         val propertyProxy = camera.cameraPropertyProvider
 446         propertyProxy.updateCameraPropertyDown(IOlyCameraProperty.COLOR_TONE)
 447     }
 448
 449     /**
 450      * 仕上がり・ピクチャーモードを１段階あげる
 451      *
 452      */
 453     private fun changeColorToneUp()
 454     {
 455         val propertyProxy = camera.cameraPropertyProvider
 456         propertyProxy.updateCameraPropertyUp(IOlyCameraProperty.COLOR_TONE)
 457     }
 458
 459     /**
 460      * アートフィルターを１段階さげる
 461      *
 462      */
 463     private fun changeArtFilterDown()
 464     {
 465         val propertyProxy = camera.cameraPropertyProvider
 466         propertyProxy.updateCameraPropertyDown(IOlyCameraProperty.ART_FILTER)
 467     }
 468
 469     /**
 470      * アートフィルターを１段階あげる
 471      *
 472      */
 473     private fun changeArtFilterUp()
 474     {
 475         val propertyProxy = camera.cameraPropertyProvider
 476         propertyProxy.updateCameraPropertyUp(IOlyCameraProperty.ART_FILTER)
 477     }
 478
 479
 480     /**
 481      * 測光方式を１段階さげる
 482      *
 483      */
 484     private fun changeAEModeDown()
 485     {
 486         val propertyProxy = camera.cameraPropertyProvider
 487         propertyProxy.updateCameraPropertyDown(IOlyCameraProperty.AE_MODE)
 488     }
 489
 490     /**
 491      * 測光方式を１段階あげる
 492      *
 493      */
 494     private fun changeAEModeUp()
 495     {
 496         val propertyProxy = camera.cameraPropertyProvider
 497         propertyProxy.updateCameraPropertyUp(IOlyCameraProperty.AE_MODE)
 498     }
 499
 500     /**
 501      * 測光方式を更新する
 502      *
 503      */
 504     private fun changeAEMode(direction: Int)
 505     {
 506         val propertyProxy = camera.cameraPropertyProvider
 507         propertyProxy.changeCameraProperty(IOlyCameraProperty.AE_MODE, direction)
 508     }
 509
 510     /**
 511      * ISO感度を１段階さげる
 512      *
 513      */
 514     private fun changeIsoSensitivityDown()
 515     {
 516         val propertyProxy = camera.cameraPropertyProvider
 517         propertyProxy.updateCameraPropertyDown(IOlyCameraProperty.ISO_SENSITIVITY)
 518     }
 519
 520     /**
 521      * ISO感度を１段階あげる
 522      *
 523      */
 524     private fun changeIsoSensitivityUp()
 525     {
 526         val propertyProxy = camera.cameraPropertyProvider
 527         propertyProxy.updateCameraPropertyUp(IOlyCameraProperty.ISO_SENSITIVITY)
 528     }
 529
 530
 531     /**
 532      * ホワイトバランスを１段階さげる
 533      *
 534      */
 535     private fun changeWhiteBalanceDown()
 536     {
 537         try
 538         {
 539             if (thetaWhiteBalanceIndex > 0)
 540             {
 541                 thetaWhiteBalanceIndex--
 542
 543                 val optionStr = context.resources.getStringArray(R.array.white_balance_value)[thetaWhiteBalanceIndex]
 544                 optionSet.setOptions(optionStr, sessionIdProvider.sessionId.isEmpty())
 545             }
 546         }
 547         catch (e : Exception)
 548         {
 549             e.printStackTrace()
 550         }
 551     }
 552
 553     /**
 554      * ホワイトバランスを１段階あげる
 555      *
 556      */
 557     private fun changeWhiteBalanceUp()
 558     {
 559         try
 560         {
 561             if (thetaWhiteBalanceIndex < MAX_WHITE_BALANCE)
 562             {
 563                 thetaWhiteBalanceIndex++
 564
 565                 val optionStr = context.resources.getStringArray(R.array.white_balance_value)[thetaWhiteBalanceIndex]
 566                 optionSet.setOptions(optionStr, sessionIdProvider.sessionId.isEmpty())
 567             }
 568         }
 569         catch (e : Exception)
 570         {
 571             e.printStackTrace()
 572         }
 573     }
 574
 575     /**
 576      * 動画撮影モードを１段階さげる
 577      *
 578      */
 579     private fun changeMovieQualityModeDown()
 580     {
 581         val propertyProxy = camera.cameraPropertyProvider
 582         propertyProxy.updateCameraPropertyDown(IOlyCameraProperty.QUALITY_MOVIE)
 583     }
 584
 585     /**
 586      * 動画撮影モードを１段階あげる
 587      *
 588      */
 589     private fun changeMovieQualityModeUp()
 590     {
 591         val propertyProxy = camera.cameraPropertyProvider
 592         propertyProxy.updateCameraPropertyUp(IOlyCameraProperty.QUALITY_MOVIE)
 593     }
 594
 595
 596     /**
 597      * 動画撮影モードがショートムービーのときの撮影時間を１段階さげる
 598      *
 599      */
 600     private fun changeShortMovieRecordLengthDown()
 601     {
 602         val propertyProxy = camera.cameraPropertyProvider
 603         propertyProxy.updateCameraPropertyDown(IOlyCameraProperty.SHORT_MOVIE_RECORD_TIME)
 604     }
 605
 606     /**
 607      * 動画撮影モードがショートムービーのときの撮影時間を１段階あげる
 608      *
 609      */
 610     private fun changeShortMovieRecordLengthUp()
 611     {
 612         val propertyProxy = camera.cameraPropertyProvider
 613         propertyProxy.updateCameraPropertyUp(IOlyCameraProperty.SHORT_MOVIE_RECORD_TIME)
 614     }
 615
 616
 617     /**
 618      * 動画撮影モードを１段階さげる
 619      *
 620      */
 621     private fun changeMovieTakeModeDown()
 622     {
 623         val propertyProxy = camera.cameraPropertyProvider
 624         propertyProxy.updateCameraPropertyDown(IOlyCameraProperty.TAKE_MODE_MOVIE)
 625     }
 626
 627     /**
 628      * 動画撮影モードを１段階あげる
 629      *
 630      */
 631     private fun changeMovieTakeModeUp()
 632     {
 633         val propertyProxy = camera.cameraPropertyProvider
 634         propertyProxy.updateCameraPropertyUp(IOlyCameraProperty.TAKE_MODE_MOVIE)
 635     }
 636
 637     /**
 638      * インターバル撮影（１枚）を行う
 639      *
 640      * @param waitSeconds  撮影待ち時間（単位：秒）
 641      */
 642     private fun intervalOneShot(waitSeconds: Int)
 643     {
 644         camera.bracketingShot(IBracketingShotStyle.BRACKET_NONE, 1, waitSeconds)
 645     }
 646
 647     /**
 648      * ブラケット撮影を行う
 649      *
 650      * @param style  撮影スタイル
 651      * @param count  撮影枚数
 652      */
 653     private fun bracketingShot(style: Int, count: Int)
 654     {
 655         camera.bracketingShot(style, count, 0)
 656     }
 657
 658
 659     /**
 660      * 「お気に入り設定」表示画面を開く
 661      *
 662      */
 663     private fun showFavoriteDialog()
 664     {
 665         // お気に入り設定表示画面を開く
 666         statusDrawer.showFavoriteSettingsDialog()
 667     }
 668
 669     /**
 670      * ズームイン・ズームアウト操作を行う
 671      *
 672      * @param direction ズーム操作の方向
 673      */
 674     private fun driveZoomLens(direction: Int): Boolean
 675     {
 676         var isExecute = false
 677         val zoom = camera.zoomLensHolder
 678         if (zoom != null)
 679         {
 680             zoom.updateStatus()
 681             if (zoom.canZoom())
 682             {
 683                 // ズーム操作を行う
 684                 try
 685                 {
 686                     zoom.driveZoomLens(direction)
 687                     isExecute = true
 688                 }
 689                 catch (e: Exception)
 690                 {
 691                     e.printStackTrace()
 692                 }
 693             }
 694         }
 695         return isExecute
 696     }
 697
 698     private fun resetDigitalZoom()
 699     {
 700         val zoom = camera.zoomLensHolder
 701         if (zoom != null)
 702         {
 703             zoom.updateStatus()
 704             zoom.changeDigitalZoomScale(1.0f, false)
 705         }
 706     }
 707
 708     private fun driveDigitalZoom(zoomType: Int): Boolean
 709     {
 710         var isExecute = false
 711         val zoom = camera.zoomLensHolder
 712         if (zoom != null)
 713         {
 714             zoom.updateStatus()
 715             var magnify = zoomType.toFloat()
 716             if (zoomType == 0)
 717             {
 718                 magnify = 1.0f
 719             }
 720             val currentScale = zoom.currentDigitalZoomScale
 721             val targetScale = currentScale + magnify * 0.5f
 722             zoom.changeDigitalZoomScale(targetScale, zoomType == 0)
 723             isExecute = true
 724         }
 725         return isExecute
 726     }
 727
 728     /**
 729      * ライブビューのサイズを指定した倍率に拡大する（拡大中の場合にはもとに戻す。）
 730      *
 731      * @param scale  拡大倍率
 732      * @return  実行した場合true, 実行しなかった場合はfalse
 733      */
 734     private fun changeLiveViewMagnify(scale: Int): Boolean
 735     {
 736         var isExecute = false
 737         val zoom = camera.zoomLensHolder
 738         if (zoom != null)
 739         {
 740             isExecute = zoom.magnifyLiveView(scale)
 741         }
 742         return isExecute
 743     }
 744
 745     /**
 746      * 設定画面を開く
 747      *
 748      */
 749     private fun showSettingsScreen()
 750     {
 751         try
 752         {
 753             Log.v(TAG, " --- showSettingsScreen() ---")
 754         }
 755         catch (e: Exception)
 756         {
 757             e.printStackTrace()
 758         }
 759     }
 760
 761     companion object
 762     {
 763         private val TAG = ThetaFeatureDispatcher::class.java.simpleName
 764
 765         private const val MAX_EXPOSURE_COMPENSATION = 12 // exposureCompensation
 766         private const val MAX_EXPOSURE_PROGRAM = 4 // exposureProgram
 767         private const val MAX_FILTER_SELECTION = 4 // _filter
 768         private const val MAX_WHITE_BALANCE = 11 // whiteBalance
 769
 770     }
 771 }