app/src/main/java/jp/osdn/gokigen/thetaview/MainActivity.kt

   1 package jp.osdn.gokigen.thetaview
   2
   3 import android.Manifest
   4 import android.content.Intent
   5 import android.content.pm.PackageManager
   6 import android.os.Build
   7 import android.os.Bundle
   8 import android.os.VibrationEffect
   9 import android.os.Vibrator
  10 import android.util.Log
  11 import android.view.WindowManager
  12 import android.widget.ImageButton
  13 import android.widget.Toast
  14 import androidx.appcompat.app.AppCompatActivity
  15 import androidx.core.app.ActivityCompat
  16 import androidx.core.content.ContextCompat
  17 import jp.osdn.gokigen.thetaview.camera.ICameraStatusReceiver
  18 import jp.osdn.gokigen.thetaview.camera.theta.status.ThetaCameraStatusWatcher
  19 import jp.osdn.gokigen.thetaview.preference.PreferenceValueInitializer
  20 import jp.osdn.gokigen.thetaview.scene.*
  21
  22 class MainActivity : AppCompatActivity(), IShowInformation, ICameraStatusReceiver, ICameraConnectionStatus
  23 {
  24     private val mainButtonHandler : MainButtonHandler = MainButtonHandler(this, this, this)
  25     private val showMessage : ShowMessage = ShowMessage(this)
  26     private val accessPermission : IScopedStorageAccessPermission? = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) { StorageOperationWithPermission(this) } else { null }
  27     private val sceneChanger : SceneChanger = SceneChanger(this, showMessage, accessPermission, this, this)
  28     private var connectionStatus : ICameraConnectionStatus.CameraConnectionStatus = ICameraConnectionStatus.CameraConnectionStatus.UNKNOWN
  29
  30     override fun onCreate(savedInstanceState: Bundle?)
  31     {
  32         Log.v(TAG, " ----- onCreate() -----")
  33         super.onCreate(savedInstanceState)
  34         mainButtonHandler.setSceneChanger(sceneChanger)
  35
  36         setContentView(R.layout.activity_main)
  37
  38         supportActionBar?.hide()
  39         window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
  40
  41         try
  42         {
  43             PreferenceValueInitializer().initializePreferences(this)
  44         }
  45         catch (e: Exception)
  46         {
  47             e.printStackTrace()
  48         }
  49
  50         if (allPermissionsGranted())
  51         {
  52             checkMediaWritePermission()
  53             sceneChanger.initializeFragment()
  54             mainButtonHandler.initialize()
  55         }
  56         else
  57         {
  58             ActivityCompat.requestPermissions(this, REQUIRED_PERMISSIONS, REQUEST_CODE_PERMISSIONS)
  59         }
  60     }
  61
  62     override fun onDestroy()
  63     {
  64         super.onDestroy()
  65         sceneChanger.finish()
  66     }
  67
  68     private fun allPermissionsGranted() = REQUIRED_PERMISSIONS.all {
  69         ContextCompat.checkSelfPermission(baseContext, it) == PackageManager.PERMISSION_GRANTED
  70     }
  71
  72     private fun checkMediaWritePermission()
  73     {
  74         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R)
  75         {
  76             StorageOperationWithPermission(this).requestStorageAccessFrameworkLocation()
  77         }
  78     }
  79
  80     override fun onRequestPermissionsResult(
  81         requestCode: Int,
  82         permissions: Array<String>,
  83         grantResults: IntArray
  84     )
  85     {
  86         if (requestCode == REQUEST_CODE_PERMISSIONS)
  87         {
  88             if (allPermissionsGranted())
  89             {
  90                 checkMediaWritePermission()
  91                 sceneChanger.initializeFragment()
  92                 mainButtonHandler.initialize()
  93             }
  94             else
  95             {
  96                 Toast.makeText(this, getString(R.string.permission_not_granted), Toast.LENGTH_SHORT).show()
  97                 //Snackbar.make(main_layout,"Permissions not granted by the user.", Snackbar.LENGTH_SHORT).show()
  98                 finish()
  99             }
 100         }
 101     }
 102
 103     override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?)
 104     {
 105         super.onActivityResult(requestCode, resultCode, data)
 106         if (requestCode == REQUEST_CODE_MEDIA_EDIT)
 107         {
 108             accessPermission?.responseAccessPermission(resultCode, data)
 109         }
 110         if (requestCode == REQUEST_CODE_OPEN_DOCUMENT_TREE)
 111         {
 112             accessPermission?.responseStorageAccessFrameworkLocation(resultCode, data)
 113         }
 114     }
 115
 116     companion object
 117     {
 118         private val TAG = MainActivity::class.java.simpleName
 119
 120         private const val REQUEST_CODE_PERMISSIONS = 10
 121         const val REQUEST_CODE_MEDIA_EDIT = 12
 122         const val REQUEST_CODE_OPEN_DOCUMENT_TREE = 20
 123
 124         private val REQUIRED_PERMISSIONS = arrayOf(
 125             Manifest.permission.CAMERA,
 126             Manifest.permission.VIBRATE,
 127             Manifest.permission.INTERNET,
 128             Manifest.permission.ACCESS_NETWORK_STATE,
 129             Manifest.permission.ACCESS_WIFI_STATE,
 130             Manifest.permission.WRITE_EXTERNAL_STORAGE,
 131             Manifest.permission.READ_EXTERNAL_STORAGE
 132         )
 133     }
 134
 135     override fun showToast(rscId: Int, appendMessage: String, duration: Int)
 136     {
 137         try
 138         {
 139             runOnUiThread {
 140                 try
 141                 {
 142                     val message = if (rscId != 0) getString(rscId) + appendMessage else appendMessage
 143                     Toast.makeText(applicationContext, message, duration).show()
 144                 }
 145                 catch (e: java.lang.Exception)
 146                 {
 147                     e.printStackTrace()
 148                 }
 149             }
 150         }
 151         catch (e: Exception)
 152         {
 153             e.printStackTrace()
 154         }
 155     }
 156
 157     override fun vibrate(vibratePattern: IShowInformation.VibratePattern)
 158     {
 159         try
 160         {
 161             // バイブレータをつかまえる
 162             val vibrator = getSystemService(VIBRATOR_SERVICE) as Vibrator
 163             if (!vibrator.hasVibrator())
 164             {
 165                 Log.v(TAG, " not have Vibrator...")
 166                 return
 167             }
 168             @Suppress("DEPRECATION") val thread = Thread {
 169                 try
 170                 {
 171                     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
 172                     {
 173                         vibrator.vibrate(VibrationEffect.createOneShot(10, VibrationEffect.DEFAULT_AMPLITUDE))
 174                     }
 175                     else
 176                     {
 177                         when (vibratePattern)
 178                         {
 179                             IShowInformation.VibratePattern.SIMPLE_SHORT ->  vibrator.vibrate(50)
 180                             IShowInformation.VibratePattern.SIMPLE_LONG ->  vibrator.vibrate(150)
 181                             else -> { }
 182                         }
 183                     }
 184                 }
 185                 catch (e : Exception)
 186                 {
 187                     e.printStackTrace()
 188                 }
 189             }
 190             thread.start()
 191         }
 192         catch (e: java.lang.Exception)
 193         {
 194             e.printStackTrace()
 195         }
 196     }
 197
 198     override fun invalidate()
 199     {
 200         try
 201         {
 202             runOnUiThread {
 203                 //if (liveView != null) {
 204                 //    liveView.invalidate()
 205                 //}
 206             }
 207         }
 208         catch (e: Exception)
 209         {
 210             e.printStackTrace()
 211         }
 212     }
 213
 214     override fun setMessage(area: IShowInformation.Area, color: Int, message: String)
 215     {
 216         Log.v(TAG, ">>> $area[$color] : $message")
 217         try
 218         {
 219             runOnUiThread {
 220                 //
 221                 //
 222             }
 223         }
 224         catch (e: Exception)
 225         {
 226             e.printStackTrace()
 227         }
 228     }
 229
 230     override fun onStatusNotify(message: String?)
 231     {
 232         Log.v(TAG, " onStatusNotify() $message ")
 233         updateConnectionIcon(ICameraConnectionStatus.CameraConnectionStatus.CONNECTING)
 234
 235         try
 236         {
 237             runOnUiThread {
 238                 //if (liveView != null) {
 239                 //    liveView.invalidate()
 240                 //}
 241             }
 242         }
 243         catch (e: Exception)
 244         {
 245             e.printStackTrace()
 246         }
 247     }
 248
 249     override fun onCameraConnected()
 250     {
 251         Log.v(TAG, " onCameraConnected() ")
 252         updateConnectionIcon(ICameraConnectionStatus.CameraConnectionStatus.CONNECTED)
 253
 254         try
 255         {
 256             runOnUiThread {
 257                 //if (liveView != null) {
 258                 //    liveView.invalidate()
 259                 //}
 260             }
 261         }
 262         catch (e: Exception)
 263         {
 264             e.printStackTrace()
 265         }
 266     }
 267
 268     override fun onCameraDisconnected()
 269     {
 270         Log.v(TAG, " onCameraDisconnected() ")
 271         try
 272         {
 273             updateConnectionIcon(ICameraConnectionStatus.CameraConnectionStatus.DISCONNECTED)
 274         }
 275         catch (e: Exception)
 276         {
 277             e.printStackTrace()
 278         }
 279     }
 280
 281     private fun updateConnectionIcon(connectionStatus : ICameraConnectionStatus.CameraConnectionStatus)
 282     {
 283         Log.v(TAG, " onCameraDisconnected() $connectionStatus")
 284         this.connectionStatus = connectionStatus
 285         try
 286         {
 287             runOnUiThread {
 288                 try
 289                 {
 290                     val view : ImageButton = this.findViewById(R.id.button_connect)
 291                     val iconId = when (connectionStatus)
 292                     {
 293                         ICameraConnectionStatus.CameraConnectionStatus.DISCONNECTED -> { R.drawable.ic_baseline_cloud_off_24 }
 294                         ICameraConnectionStatus.CameraConnectionStatus.UNKNOWN -> { R.drawable.ic_baseline_cloud_off_24 }
 295                         ICameraConnectionStatus.CameraConnectionStatus.CONNECTING -> { R.drawable.ic_baseline_cloud_queue_24 }
 296                         ICameraConnectionStatus.CameraConnectionStatus.CONNECTED -> { R.drawable.ic_baseline_cloud_done_24 }
 297                     }
 298                     view.setImageDrawable(ContextCompat.getDrawable(this, iconId))
 299                     view.invalidate()
 300                 }
 301                 catch (e : Exception)
 302                 {
 303                     e.printStackTrace()
 304                 }
 305             }
 306         }
 307         catch (e: Exception)
 308         {
 309             e.printStackTrace()
 310         }
 311     }
 312
 313     override fun onCameraConnectError(msg: String?)
 314     {
 315         Log.v(TAG, " onCameraConnectError() $msg ")
 316     }
 317
 318     override fun getConnectionStatus(): ICameraConnectionStatus.CameraConnectionStatus
 319     {
 320         return (connectionStatus)
 321     }
 322 }