wear/src/main/java/net/osdn/gokigen/joggingtimer/recorddetail/RecordDetailSetup.kt

   1 package net.osdn.gokigen.joggingtimer.recorddetail
   2
   3 import android.annotation.SuppressLint
   4 import android.content.Intent
   5 import android.provider.BaseColumns
   6 import android.util.Log
   7 import androidx.appcompat.app.AppCompatActivity
   8 import net.osdn.gokigen.joggingtimer.R
   9 import net.osdn.gokigen.joggingtimer.storage.ITimeEntryDatabase
  10 import net.osdn.gokigen.joggingtimer.storage.ITimeEntryDatabaseCallback
  11 import net.osdn.gokigen.joggingtimer.storage.ITimeEntryDatabaseCallback.OperationType
  12 import net.osdn.gokigen.joggingtimer.storage.TimeEntryDatabaseFactory
  13 import net.osdn.gokigen.joggingtimer.storage.contract.TimeEntryData
  14 import net.osdn.gokigen.joggingtimer.storage.contract.TimeEntryIndex.EntryIndex
  15 import net.osdn.gokigen.joggingtimer.utilities.CreateModelData
  16 import net.osdn.gokigen.joggingtimer.utilities.CreateModelData.IEditedModelDataCallback
  17 import net.osdn.gokigen.joggingtimer.utilities.CreateModelDataDialog
  18 import net.osdn.gokigen.joggingtimer.utilities.TimeStringConvert
  19
  20
  21 class RecordDetailSetup internal constructor(
  22     private val activity: AppCompatActivity,
  23     private val indexId: Long,
  24     private val callback: IDatabaseReadyNotify,
  25     private val operation: IRecordOperation?,
  26     private val editCallback: IEditedModelDataCallback
  27 ) : ITimeEntryDatabaseCallback, IDetailEditor
  28 {
  29     private var database: ITimeEntryDatabase? = null
  30     fun setup()
  31     {
  32         Log.v(TAG, "setup()")
  33         database = TimeEntryDatabaseFactory(activity, this).entryDatabase
  34         val thread = Thread {
  35             try
  36             {
  37                 database?.prepare()
  38             }
  39             catch (e: Exception)
  40             {
  41                 e.printStackTrace()
  42             }
  43         }
  44         thread.start()
  45     }
  46
  47     override fun prepareFinished(isReady: Boolean)
  48     {
  49         if (!isReady)
  50         {
  51             callback.databaseSetupFinished(false)
  52             return
  53         }
  54         val editor: IDetailEditor = this
  55         val thread = Thread {
  56             var ret = false
  57             try
  58             {
  59                 operation?.clearRecord()
  60                 val cursor = database?.getAllDetailData(indexId)
  61                 var index = 0
  62                 var startTime: Long = 0
  63                 var previousLapTime: Long = 0
  64                 var morePreviousTime: Long = 0
  65                 while (cursor?.moveToNext() == true)
  66                 {
  67                     val dataIdIndex = cursor.getColumnIndex(BaseColumns._ID)
  68                     val dataId = cursor.getLong(dataIdIndex)
  69
  70                     val indexIdIndex = cursor.getColumnIndex(TimeEntryData.EntryData.COLUMN_NAME_INDEX_ID)
  71                     val indexId = cursor.getLong(indexIdIndex)
  72
  73                     val entryTimeIndex = cursor.getColumnIndex(TimeEntryData.EntryData.COLUMN_NAME_TIME_ENTRY)
  74                     val entryTime = cursor.getLong(entryTimeIndex)
  75
  76                     val recordTypeIndex = cursor.getColumnIndex(TimeEntryData.EntryData.COLUMN_NAME_RECORD_TYPE)
  77                     val recordType = cursor.getInt(recordTypeIndex)
  78                     if (index == 0)
  79                     {
  80                         // first record
  81                         startTime = entryTime
  82                         previousLapTime = entryTime
  83                         morePreviousTime = entryTime
  84                     }
  85                     else
  86                     {
  87                         val lapTime = entryTime - previousLapTime
  88                         val overallTime = entryTime - startTime
  89                         val differenceTime =
  90                             lapTime - (previousLapTime - morePreviousTime)
  91                         operation?.addRecord(
  92                             DetailRecord(
  93                                 indexId,
  94                                 dataId,
  95                                 recordType,
  96                                 index,
  97                                 lapTime,
  98                                 overallTime,
  99                                 differenceTime,
 100                                 editor
 101                             )
 102                         )
 103                         morePreviousTime = previousLapTime
 104                         previousLapTime = entryTime
 105                     }
 106                     index++
 107                 }
 108                 activity.runOnUiThread { operation?.dataSetChangeFinished() }
 109                 ret = true
 110             }
 111             catch (e: Exception)
 112             {
 113                 e.printStackTrace()
 114             }
 115             callback.databaseSetupFinished(ret)
 116         }
 117         thread.start()
 118     }
 119
 120     fun setEditIndexData(title: String, icon: Int)
 121     {
 122         val data = EditIndexData(title, icon)
 123         val thread = Thread {
 124             database?.updateIndexData(indexId, data.title(), data.icon())
 125             callback.updatedIndexData(false)
 126         }
 127         thread.start()
 128     }
 129
 130     fun getEditIndexData(): EditIndexData?
 131     {
 132         var title = ""
 133         var iconId: Int = R.drawable.ic_android_black_24dp
 134         try
 135         {
 136             val cursor = database?.getIndexdata(indexId)
 137             while (cursor?.moveToNext() == true)
 138             {
 139                 val titleIndex = cursor.getColumnIndex(EntryIndex.COLUMN_NAME_TITLE)
 140                 title = cursor.getString(titleIndex)
 141
 142                 val iconIdIndex = cursor.getColumnIndex(EntryIndex.COLUMN_NAME_ICON_ID)
 143                 iconId = cursor.getInt(iconIdIndex)
 144             }
 145             return EditIndexData(title, iconId)
 146         }
 147         catch (e: java.lang.Exception)
 148         {
 149             e.printStackTrace()
 150         }
 151         return (null)
 152     }
 153
 154     fun setReferenceData(id: Int)
 155     {
 156         val thread = Thread {
 157             database?.setReferenceIndexData(id, indexId)
 158             callback.updatedIndexData(true)
 159         }
 160         thread.start()
 161     }
 162
 163     override fun dataEntryFinished(operationType: OperationType, result: Boolean, id: Long, title: String) { }
 164     override fun timeEntryFinished(operationType: OperationType, result: Boolean, indexId: Long, dataId: Long) { }
 165     override fun modelDataEntryFinished(operationType: OperationType, result: Boolean, indexId: Long, title: String)
 166     {
 167         Log.v(TAG, "modelDataEntryFinished : $result $title $indexId")
 168     }
 169
 170     fun closeDatabase()
 171     {
 172         try
 173         {
 174             database?.close()
 175         }
 176         catch (e: Exception)
 177         {
 178             e.printStackTrace()
 179         }
 180     }
 181
 182     /**
 183      * IDetailEditor.editDetailData()
 184      */
 185     override fun editDetailData(indexId: Long, dataId: Long, count: Int, defaultMillis: Long)
 186     {
 187         activity.runOnUiThread {
 188             val dialog2 = CreateModelDataDialog.newInstance(
 189                 false,
 190                 activity.getString(R.string.information_modify_time),
 191                 count,
 192                 CreateModelData(
 193                     database,
 194                     editCallback, null, indexId, dataId
 195                 ),
 196                 defaultMillis
 197             )
 198             dialog2.showNow(activity.supportFragmentManager, "dialog2")
 199         }
 200     }
 201
 202     fun updateDatabaseRecord(adapter: RecordDetailAdapter)
 203     {
 204         try
 205         {
 206             val count = adapter.itemCount
 207             if (count > 1)
 208             {
 209                 for (index in 0 until count)
 210                 {
 211                     val record = adapter.getRecord(index)
 212                     val id = record.dataId
 213                     val time = record.totalTime
 214                     database!!.updateTimeEntryData(id, time)
 215                 }
 216             }
 217         }
 218         catch (e: Exception)
 219         {
 220             e.printStackTrace()
 221         }
 222     }
 223
 224     /**
 225      * 現在のデータを共有する
 226      *
 227      */
 228     fun shareTheData(adapter: RecordDetailAdapter?)
 229     {
 230         Log.v(TAG, "shareTheData()")
 231         if (adapter == null || adapter.itemCount <= 0 )
 232         {
 233             // データがない場合は、何もしない
 234             Log.v(TAG, "DATA IS NONE, NOT EXPORTED")
 235             return
 236         }
 237         shareDetailIntent(adapter)
 238     }
 239
 240     @SuppressLint("Range")
 241     private fun shareDetailIntent(adapter: RecordDetailAdapter)
 242     {
 243         var title = ""
 244         val dataCount = adapter.itemCount
 245         val dataToExport = StringBuilder()
 246         dataToExport.append("; ")
 247         dataToExport.append(activity.getString(R.string.app_name))
 248         dataToExport.append("\r\n")
 249         try
 250         {
 251             val cursor = database?.getIndexdata(indexId)
 252             while (cursor?.moveToNext() == true) {
 253                 dataToExport.append("; ")
 254                 title = cursor.getString(cursor.getColumnIndex(EntryIndex.COLUMN_NAME_TITLE))
 255                 dataToExport.append(title)
 256                 dataToExport.append(",")
 257                 dataToExport.append(
 258                     TimeStringConvert.getTimeString(
 259                         cursor.getLong(
 260                             cursor.getColumnIndex(
 261                                 EntryIndex.COLUMN_NAME_TIME_DURATION
 262                             )
 263                         )
 264                     )
 265                 )
 266                 dataToExport.append(",")
 267                 dataToExport.append(cursor.getLong(cursor.getColumnIndex(EntryIndex.COLUMN_NAME_START_TIME)))
 268                 dataToExport.append(",")
 269                 dataToExport.append(cursor.getString(cursor.getColumnIndex(EntryIndex.COLUMN_NAME_MEMO)))
 270                 dataToExport.append(",")
 271                 dataToExport.append("\r\n")
 272             }
 273         }
 274         catch (e: Exception)
 275         {
 276             e.printStackTrace()
 277             dataToExport.append("\r\n")
 278         }
 279         dataToExport.append("; \r\n")
 280         dataToExport.append("; LapCount,LapTime,TotalTime,LapTime(ms),TotalTime(ms),;\r\n")
 281         for (index in 0 until dataCount)
 282         {
 283             try
 284             {
 285                 val record = adapter.getRecord(index)
 286                 dataToExport.append(record.lapCount)
 287                 dataToExport.append(",")
 288                 dataToExport.append(record.title)
 289                 dataToExport.append(",")
 290                 dataToExport.append(record.overallTime)
 291                 dataToExport.append(",")
 292                 dataToExport.append(record.lapTime)
 293                 dataToExport.append(",")
 294                 dataToExport.append(record.totalTime)
 295                 dataToExport.append(",")
 296                 dataToExport.append(";")
 297             }
 298             catch (e: Exception)
 299             {
 300                 e.printStackTrace()
 301                 dataToExport.append(";;\r\n")
 302                 break
 303             }
 304             dataToExport.append("\r\n")
 305         }
 306
 307         // Intent発行(ACTION_SEND)
 308         try
 309         {
 310             val sendIntent = Intent().apply {
 311                 action = Intent.ACTION_SEND  // NoteIntents.ACTION_CREATE_NOTE
 312                 type = "text/plain"
 313                 putExtra(Intent.EXTRA_SUBJECT, title)
 314                 putExtra(Intent.EXTRA_TEXT, dataToExport.toString())
 315             }
 316             //val shareIntent = Intent.createChooser(sendIntent, null)
 317             //activity.startActivity(shareIntent)
 318             activity.startActivity(sendIntent)
 319             Log.v(TAG, "<<< SEND INTENT >>> : $title")
 320         }
 321         catch (e: Exception)
 322         {
 323             e.printStackTrace()
 324         }
 325     }
 326
 327     class EditIndexData(val title: String, val icon: Int)
 328     {
 329         fun title(): String
 330         {
 331             return (title)
 332         }
 333
 334         fun icon(): Int
 335         {
 336             return (icon)
 337         }
 338     }
 339
 340     internal interface IDatabaseReadyNotify
 341     {
 342         fun databaseSetupFinished(result: Boolean)
 343         fun updatedIndexData(isIconOnly: Boolean)
 344     }
 345
 346     companion object {
 347         private val TAG = RecordDetailSetup::class.java.simpleName
 348     }
 349 }