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