wear/src/main/java/net/osdn/gokigen/joggingtimer/stopwatch/WearableActivityController.java

   1 package net.osdn.gokigen.joggingtimer.stopwatch;
   2
   3 import android.Manifest;
   4 import android.annotation.SuppressLint;
   5 import android.content.SharedPreferences;
   6 import android.content.pm.PackageManager;
   7 import android.database.Cursor;
   8 import android.os.Vibrator;
   9 import android.preference.PreferenceManager;
  10 import android.util.Log;
  11 import android.widget.ImageButton;
  12 import android.widget.ListView;
  13 import android.widget.TextView;
  14
  15 import net.osdn.gokigen.joggingtimer.R;
  16 import net.osdn.gokigen.joggingtimer.stopwatch.graphview.LapTimeGraphView;
  17 import net.osdn.gokigen.joggingtimer.stopwatch.listview.ILapTimeHolder;
  18 import net.osdn.gokigen.joggingtimer.stopwatch.listview.LapTimeArrayAdapter;
  19 import net.osdn.gokigen.joggingtimer.stopwatch.listview.LapTimeItems;
  20 import net.osdn.gokigen.joggingtimer.storage.ITimeEntryDatabase;
  21 import net.osdn.gokigen.joggingtimer.storage.ITimeEntryDatabaseCallback;
  22 import net.osdn.gokigen.joggingtimer.storage.TimeEntryDatabaseFactory;
  23 import net.osdn.gokigen.joggingtimer.storage.contract.TimeEntryData;
  24
  25 import java.util.ArrayList;
  26
  27 import static android.content.Context.VIBRATOR_SERVICE;
  28
  29 import androidx.appcompat.app.AppCompatActivity;
  30 import androidx.core.app.ActivityCompat;
  31 import androidx.core.content.ContextCompat;
  32
  33 /**
  34  *
  35  *
  36  *
  37  */
  38 class WearableActivityController implements IWearableActivityControl, ITimeEntryDatabaseCallback, IDataEntry
  39 {
  40     private final String TAG = toString();
  41     private final String PREF_KEY_TIMER_STARTED = "TMR_START";
  42     private final String PREF_KEY_TIMER_INDEXID = "TMR_INDEX";
  43     private final String PREF_KEY_DISPLAY_LAPGRAPHIC = "DISP_LAPGRPH";
  44     private final String PREF_KEY_REFERENCE_TIME_SELECTION = "REF_TIME_SEL";
  45
  46     private SharedPreferences preferences = null;
  47     private final ButtonClickListener clickListener = new ButtonClickListener();
  48     private ITimeEntryDatabase database = null;
  49     private IDatabaseReloadCallback dbCallback = null;
  50     private boolean isReadyDatabase = false;
  51     private boolean pendingLoadReference = false;
  52     private long recordingIndexId = -1;
  53     private ILapTimeHolder lapTimeHolder = null;
  54
  55     private Vibrator vibrator = null;
  56     //private PowerManager powerManager = null;
  57
  58
  59     WearableActivityController() {
  60         Log.v(TAG, "WearableActivityController()");
  61     }
  62
  63     @Override
  64     public void setup(AppCompatActivity activity, IClickCallback callback, IDatabaseReloadCallback dbCallback)
  65     {
  66         this.preferences = PreferenceManager.getDefaultSharedPreferences(activity);
  67         this.dbCallback = dbCallback;
  68         setupPermissions(activity);
  69         setupHardwares(activity);
  70         setupScreen(activity);
  71         //setupDatabase(activity, false); // chhange true if when databaese file should be cleared.
  72         setupListeners(activity, callback);
  73     }
  74
  75     /**
  76      *
  77      *
  78      */
  79     private void setupPermissions(AppCompatActivity activity)
  80     {
  81         if ((ContextCompat.checkSelfPermission(activity, Manifest.permission.VIBRATE) != PackageManager.PERMISSION_GRANTED) ||
  82                 (ContextCompat.checkSelfPermission(activity, Manifest.permission.WAKE_LOCK) != PackageManager.PERMISSION_GRANTED)) {
  83             ActivityCompat.requestPermissions(activity,
  84                     new String[]{
  85                             Manifest.permission.VIBRATE,
  86                             Manifest.permission.WAKE_LOCK,
  87                     },
  88                     100);
  89         }
  90     }
  91
  92     /**
  93      *
  94      *
  95      */
  96     private void setupHardwares(AppCompatActivity activity)
  97     {
  98         // バイブレータをつかまえる
  99         vibrator = (Vibrator) activity.getSystemService(VIBRATOR_SERVICE);
 100
 101         //// パワーマネージャをつかまえる
 102         //powerManager = (PowerManager) activity.getSystemService(POWER_SERVICE);
 103     }
 104
 105     /**
 106      *
 107      *
 108      */
 109     private void setupScreen(AppCompatActivity activity)
 110     {
 111         TextView mTextView = activity.findViewById(R.id.text);
 112         if (mTextView != null)
 113         {
 114             mTextView.setText(R.string.app_name);
 115         }
 116
 117         LapTimeArrayAdapter adapter = new LapTimeArrayAdapter(activity.getApplicationContext(), R.layout.column_laptime);
 118         adapter.clearLapTime();
 119         lapTimeHolder = adapter;
 120         ListView lapTimeArea = activity.findViewById(R.id.laptime_list_area);
 121         lapTimeArea.setAdapter(adapter);
 122     }
 123
 124     /**
 125      * データベースのセットアップ
 126      */
 127     @Override
 128     public void setupDatabase(final AppCompatActivity activity, final boolean isInitialize)
 129     {
 130         database = new TimeEntryDatabaseFactory(activity, this).getEntryDatabase();
 131         Thread thread = new Thread(() -> {
 132             try
 133             {
 134                 if (isInitialize)
 135                 {
 136                     // 既存のデータベースを消去する場合、、、
 137                     TimeEntryDatabaseFactory.deleteDatabase(activity);
 138                 }
 139                 database.prepare();
 140             }
 141             catch (Exception e)
 142             {
 143                 e.printStackTrace();
 144             }
 145         });
 146         thread.start();
 147     }
 148
 149     /**
 150      * リスナのセットアップ
 151      */
 152     private void setupListeners(AppCompatActivity activity, IClickCallback callback)
 153     {
 154         try
 155         {
 156             clickListener.setCallback(callback);
 157             ImageButton btn1 = activity.findViewById(R.id.btn1);
 158             btn1.setOnClickListener(clickListener);
 159             btn1.setOnLongClickListener(clickListener);
 160
 161             ImageButton btn2 = activity.findViewById(R.id.btn2);
 162             btn2.setOnClickListener(clickListener);
 163             btn2.setOnLongClickListener(clickListener);
 164
 165             ImageButton btn3 = activity.findViewById(R.id.btn3);
 166             btn3.setOnClickListener(clickListener);
 167             btn3.setOnLongClickListener(clickListener);
 168
 169             TextView main = activity.findViewById(R.id.main_counter);
 170             main.setOnClickListener(clickListener);
 171             main.setOnLongClickListener(clickListener);
 172
 173             TextView sub1 = activity.findViewById(R.id.sub_counter1);
 174             sub1.setOnClickListener(clickListener);
 175             sub1.setOnLongClickListener(clickListener);
 176
 177             ListView lap = activity.findViewById(R.id.laptime_list_area);
 178             //lap.setOnClickListener(clickListener);
 179             lap.setOnLongClickListener(clickListener);
 180
 181             LapTimeGraphView graphView = activity.findViewById(R.id.graph_area);
 182             graphView.setOnTouchListener(clickListener);
 183             graphView.setOnClickListener(clickListener);
 184             graphView.setOnLongClickListener(clickListener);
 185         }
 186         catch (Exception e)
 187         {
 188             e.printStackTrace();
 189         }
 190     }
 191
 192     /**
 193      *
 194      *
 195      */
 196     private void closeDatabase()
 197     {
 198         Log.v(TAG, "closeDatabase()");
 199         Thread thread = new Thread(() -> {
 200             // DBのクローズ実行
 201             if (isReadyDatabase)
 202             {
 203                 isReadyDatabase = false;
 204                 try
 205                 {
 206                     Log.v(TAG, "closeDatabase() EXECUTE...");
 207                     database.close();
 208                 }
 209                 catch (Exception e)
 210                 {
 211                     e.printStackTrace();
 212                 }
 213             }
 214         });
 215         thread.start();
 216     }
 217
 218     /**
 219      *
 220      *
 221      */
 222     @Override
 223     public void exitApplication(AppCompatActivity activity)
 224     {
 225         Log.v(TAG, "exitApplication()");
 226         closeDatabase();
 227     }
 228
 229     @Override
 230     public void vibrate(final int duration)
 231     {
 232         try
 233         {
 234             if ((vibrator == null) || (!vibrator.hasVibrator()))
 235             {
 236                 return;
 237             }
 238
 239             Thread thread = new Thread(() -> vibrator.vibrate(duration));
 240             thread.start();
 241         }
 242         catch (Exception e)
 243         {
 244             e.printStackTrace();
 245         }
 246     }
 247
 248     @Override
 249     public IDataEntry getDataEntry() {
 250         return (this);
 251     }
 252
 253     @Override
 254     public boolean getDisplayMode()
 255     {
 256         try
 257         {
 258             return (preferences.getBoolean(PREF_KEY_DISPLAY_LAPGRAPHIC, false));
 259         }
 260         catch (Exception e)
 261         {
 262             e.printStackTrace();
 263         }
 264         return (false);
 265     }
 266
 267     @Override
 268     public void timerStarted(boolean isStarted)
 269     {
 270         try
 271         {
 272             SharedPreferences.Editor editor = preferences.edit();
 273             editor.putBoolean(PREF_KEY_TIMER_STARTED, isStarted);
 274             editor.apply();
 275         }
 276         catch (Exception e)
 277         {
 278             e.printStackTrace();
 279         }
 280     }
 281
 282     @Override
 283     public void setDisplayMode(boolean displayLapTime)
 284     {
 285         try
 286         {
 287             SharedPreferences.Editor editor = preferences.edit();
 288             editor.putBoolean(PREF_KEY_DISPLAY_LAPGRAPHIC, displayLapTime);
 289             editor.apply();
 290         }
 291         catch (Exception e)
 292         {
 293             e.printStackTrace();
 294         }
 295     }
 296
 297
 298     @Override
 299     public void addTimeStamp(long count, long lapTime, long diffTime)
 300     {
 301         if (lapTimeHolder != null)
 302         {
 303             lapTimeHolder.addLapTime(new LapTimeItems(count, lapTime, diffTime));
 304         }
 305     }
 306
 307     @Override
 308     public void clearTimeStamp()
 309     {
 310         if (lapTimeHolder != null)
 311         {
 312             lapTimeHolder.clearLapTime();
 313         }
 314     }
 315
 316     @Override
 317     public int getLapTimeCount()
 318     {
 319         int count = 0;
 320         if (lapTimeHolder != null)
 321         {
 322             count = lapTimeHolder.getLapTimeCount();
 323         }
 324         return (count);
 325     }
 326
 327     @Override
 328     public int getReferenceTimerSelection()
 329     {
 330         try
 331         {
 332             return (preferences.getInt(PREF_KEY_REFERENCE_TIME_SELECTION, 0));
 333         }
 334         catch (Exception e)
 335         {
 336             e.printStackTrace();
 337         }
 338         return (0);
 339     }
 340
 341     @Override
 342     public void setReferenceTimerSelection(int id)
 343     {
 344         try
 345         {
 346             SharedPreferences.Editor editor = preferences.edit();
 347             editor.putInt(PREF_KEY_REFERENCE_TIME_SELECTION, id);
 348             editor.apply();
 349         }
 350         catch (Exception e)
 351         {
 352             e.printStackTrace();
 353         }
 354     }
 355
 356     @Override
 357     public void setupReferenceData()
 358     {
 359         try
 360         {
 361             if (isReadyDatabase)
 362             {
 363                 loadReferenceData();
 364                 pendingLoadReference = false;
 365             }
 366             else
 367             {
 368                 pendingLoadReference = true;
 369             }
 370         }
 371         catch (Exception e)
 372         {
 373             e.printStackTrace();
 374         }
 375     }
 376
 377     @SuppressLint("Range")
 378     @Override
 379     public void prepareFinished(boolean isReady)
 380     {
 381         Log.v(TAG, "database prepareFinished() : " + isReady);
 382         isReadyDatabase = isReady;
 383
 384         try
 385         {
 386             boolean isStarted = preferences.getBoolean(PREF_KEY_TIMER_STARTED, false);
 387             recordingIndexId = preferences.getLong(PREF_KEY_TIMER_INDEXID, -1);
 388
 389             Log.v(TAG, "isStarted : " + isStarted + "  indexId : " + recordingIndexId);
 390
 391             // load reference data
 392             if (pendingLoadReference)
 393             {
 394                 loadReferenceData();
 395                 pendingLoadReference = false;
 396             }
 397
 398             // load current lap time list
 399             if ((isStarted) && (recordingIndexId >= 0) && (isReadyDatabase))
 400             {
 401                 ArrayList<Long> list = new ArrayList<>();
 402                 Cursor cursor = database.getAllDetailData(recordingIndexId);
 403                 while (cursor.moveToNext())
 404                 {
 405                     list.add(cursor.getLong(cursor.getColumnIndex(TimeEntryData.EntryData.COLUMN_NAME_TIME_ENTRY)));
 406                 }
 407                 dbCallback.dataIsReloaded(list);
 408             }
 409         }
 410         catch (Exception e)
 411         {
 412             e.printStackTrace();
 413         }
 414     }
 415
 416     @SuppressLint("Range")
 417     private void loadReferenceData()
 418     {
 419         // load reference data
 420         try
 421         {
 422             int id = getReferenceTimerSelection();
 423             ArrayList<Long> refList = null;
 424             Cursor cursor = database.getAllReferenceDetailData(id);
 425             if (cursor != null)
 426             {
 427                 refList = new ArrayList<>();
 428                 while (cursor.moveToNext())
 429                 {
 430                     refList.add(cursor.getLong(cursor.getColumnIndex(TimeEntryData.EntryData.COLUMN_NAME_TIME_ENTRY)));
 431                 }
 432             }
 433             dbCallback.referenceDataIsReloaded(id, refList);
 434         }
 435         catch (Exception e)
 436         {
 437             e.printStackTrace();
 438         }
 439     }
 440
 441     @Override
 442     public void timeEntryFinished(OperationType operationType, boolean result, long indexId, long dataId)
 443     {
 444         Log.v(TAG, "database timeEntryFinished() : " + result + "  [" + indexId + "] " + dataId);
 445     }
 446
 447     @Override
 448     public void modelDataEntryFinished(OperationType operationType, boolean result, long indexId, String title)
 449     {
 450         //
 451     }
 452
 453     @Override
 454     public void dataEntryFinished(OperationType operationType, boolean result, long id, String title)
 455     {
 456         Log.v(TAG, "database dataEntryFinished() : " + result + "  [" + id + "] " + title);
 457         if ((result)&&(operationType == OperationType.CREATED))
 458         {
 459             setIndexId(id);
 460         }
 461     }
 462
 463     private void setIndexId(long id)
 464     {
 465         try
 466         {
 467             recordingIndexId = id;
 468             SharedPreferences.Editor editor = preferences.edit();
 469             editor.putLong(PREF_KEY_TIMER_INDEXID, recordingIndexId);
 470             editor.apply();
 471         }
 472         catch (Exception e)
 473         {
 474             e.printStackTrace();
 475         }
 476     }
 477
 478
 479     @Override
 480     public void createIndex(final String title, final long startTime)
 481     {
 482         final String memo = "";
 483         final int icon = 0;
 484         Log.v(TAG, "createIndex() " + title + " " + startTime);
 485         Thread thread = new Thread(() -> {
 486             if (isReadyDatabase)
 487             {
 488                 try
 489                 {
 490                     database.createIndexData(title, memo, icon, startTime);
 491                 }
 492                 catch (Exception e)
 493                 {
 494                     e.printStackTrace();
 495                 }
 496             }
 497         });
 498         thread.start();
 499     }
 500
 501     @Override
 502     public void appendTimeData(final long elapsedTime)
 503     {
 504         Log.v(TAG, "appendTimeData() " + " " + elapsedTime);
 505         Thread thread = new Thread(() -> {
 506             if (isReadyDatabase)
 507             {
 508                 try
 509                 {
 510                     database.appendTimeData(recordingIndexId, elapsedTime);
 511                 }
 512                 catch (Exception e)
 513                 {
 514                     e.printStackTrace();
 515                 }
 516             }
 517         });
 518         thread.start();
 519     }
 520
 521     @Override
 522     public void finishTimeData(final long startTime, final long endTime)
 523     {
 524         Log.v(TAG, "finishTimeData() " + startTime + " " + endTime);
 525         Thread thread = new Thread(() -> {
 526             if (isReadyDatabase)
 527             {
 528                 try
 529                 {
 530                     database.finishTimeData(recordingIndexId, startTime, endTime);
 531                 }
 532                 catch (Exception e)
 533                 {
 534                     e.printStackTrace();
 535                 }
 536             }
 537         });
 538         thread.start();
 539     }
 540 }