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