wear/src/main/java/net/osdn/gokigen/joggingtimer/storage/TimeEntryDatabase.java

   1 package net.osdn.gokigen.joggingtimer.storage;
   2
   3 import android.content.ContentValues;
   4 import android.content.Context;
   5 import android.database.Cursor;
   6 import android.database.sqlite.SQLiteDatabase;
   7 import android.util.Log;
   8
   9 import net.osdn.gokigen.joggingtimer.storage.contract.TimeEntryData;
  10 import net.osdn.gokigen.joggingtimer.storage.contract.TimeEntryIndex;
  11
  12 import static android.provider.BaseColumns._ID;
  13
  14 import androidx.annotation.NonNull;
  15
  16 /**
  17  *
  18  *
  19  *
  20  */
  21 class TimeEntryDatabase implements ITimeEntryDatabase
  22 {
  23     private final String TAG = toString();
  24     private final TimeEntryDataOpenHelper dbHelper;
  25     private final ITimeEntryDatabaseCallback callback;
  26     private static final int REFERENCE_ICON_ID = 2;
  27     private static final int MODEL_DATA_ICON_ID = 4;
  28     private static final int DEFAULT_ICON_ID = 0;
  29
  30     private SQLiteDatabase db = null;
  31     //private SQLiteDatabase writeDb = null;
  32     //private SQLiteDatabase readDb = null;
  33
  34     TimeEntryDatabase(Context context, @NonNull ITimeEntryDatabaseCallback callback)
  35     {
  36         dbHelper = new TimeEntryDataOpenHelper(context);
  37         this.callback = callback;
  38     }
  39
  40     @Override
  41     public void prepare()
  42     {
  43         Log.v(TAG, "prepareToWrite() ");
  44         boolean ret = false;
  45         try
  46         {
  47             // Gets the data repository in write mode
  48             db = dbHelper.getWritableDatabase();
  49             ret = true;
  50         }
  51         catch (Exception e)
  52         {
  53             e.printStackTrace();
  54
  55             db = null;
  56         }
  57         callback.prepareFinished(ret);
  58     }
  59
  60     @Override
  61     public void close()
  62     {
  63         Log.v(TAG, "close()");
  64         try
  65         {
  66             db.close();
  67             db = null;
  68         }
  69         catch (Exception e)
  70         {
  71             e.printStackTrace();
  72         }
  73     }
  74
  75     @Override
  76     public Cursor getAllIndexData()
  77     {
  78         return (db.rawQuery("SELECT * FROM " + TimeEntryIndex.EntryIndex.TABLE_NAME + " ORDER BY " + TimeEntryIndex.EntryIndex.COLUMN_NAME_START_TIME + " DESC", null));
  79     }
  80
  81     @Override
  82     public Cursor getAllDetailData(long indexId)
  83     {
  84         return (db.rawQuery("SELECT * FROM " + TimeEntryData.EntryData.TABLE_NAME + " WHERE " + TimeEntryData.EntryData.COLUMN_NAME_INDEX_ID + " = " + indexId + " ORDER BY " + TimeEntryData.EntryData.COLUMN_NAME_TIME_ENTRY, null));
  85     }
  86
  87     @Override
  88     public Cursor getAllReferenceDetailData()
  89     {
  90         if (db == null)
  91         {
  92             return (null);
  93         }
  94         String queryString = "SELECT * FROM " + TimeEntryIndex.EntryIndex.TABLE_NAME + " INNER JOIN " + TimeEntryData.EntryData.TABLE_NAME +
  95                 " ON " + TimeEntryIndex.EntryIndex.TABLE_NAME + "." + TimeEntryIndex.EntryIndex._ID + " = " + TimeEntryData.EntryData.TABLE_NAME+ "." + TimeEntryData.EntryData.COLUMN_NAME_INDEX_ID +
  96                 " WHERE " + TimeEntryIndex.EntryIndex.TABLE_NAME+ "." + TimeEntryIndex.EntryIndex.COLUMN_NAME_ICON_ID + " = " + REFERENCE_ICON_ID +
  97                 " ORDER BY " + TimeEntryData.EntryData.TABLE_NAME+ "." + TimeEntryData.EntryData.COLUMN_NAME_TIME_ENTRY;
  98         //Log.v(TAG, "Query : " + queryString);
  99         return (db.rawQuery(queryString, null));
 100     }
 101
 102     @Override
 103     public Cursor getIndexdata(long indexId)
 104     {
 105         return (db.rawQuery("SELECT * FROM " + TimeEntryIndex.EntryIndex.TABLE_NAME + " WHERE " + TimeEntryIndex.EntryIndex._ID + " = " + indexId + " ORDER BY " + TimeEntryIndex.EntryIndex.COLUMN_NAME_START_TIME, null));
 106     }
 107
 108     @Override
 109     public void deleteTimeEntryData(long indexId)
 110     {
 111         int delRecord = db.delete(TimeEntryData.EntryData.TABLE_NAME, TimeEntryData.EntryData.COLUMN_NAME_INDEX_ID + " = " + indexId, null);
 112         int delIndex = db.delete(TimeEntryIndex.EntryIndex.TABLE_NAME, _ID + " = " + indexId, null);
 113
 114         Log.v(TAG, "deleteTimeEntryData()  index : " + indexId + "Recs. [" + delIndex + "] (" + delRecord + ")");
 115     }
 116
 117     /**
 118      *
 119      *
 120      */
 121     @Override
 122     public void updateIndexData(long indexId, String title, int icon)
 123     {
 124         try
 125         {
 126             if ((title != null)&&(!title.isEmpty()))
 127             {
 128                 ContentValues titleValues = new ContentValues();
 129                 titleValues.put(TimeEntryIndex.EntryIndex.COLUMN_NAME_TITLE, title);
 130                 db.update(TimeEntryIndex.EntryIndex.TABLE_NAME, titleValues, _ID + " = " + indexId, null);
 131             }
 132
 133             ContentValues iconValues = new ContentValues();
 134             iconValues.put(TimeEntryIndex.EntryIndex.COLUMN_NAME_ICON_ID, icon);
 135             db.update(TimeEntryIndex.EntryIndex.TABLE_NAME, iconValues, _ID + " = " + indexId, null);
 136         }
 137         catch (Exception e)
 138         {
 139             e.printStackTrace();
 140         }
 141     }
 142
 143     /**
 144      *
 145      *
 146      */
 147     @Override
 148     public void setReferenceIndexData(long indexId)
 149     {
 150         try
 151         {
 152             ContentValues clearValues = new ContentValues();
 153             clearValues.put(TimeEntryIndex.EntryIndex.COLUMN_NAME_ICON_ID, DEFAULT_ICON_ID);
 154             db.update(TimeEntryIndex.EntryIndex.TABLE_NAME, clearValues, TimeEntryIndex.EntryIndex.COLUMN_NAME_ICON_ID + " = " + REFERENCE_ICON_ID, null);
 155
 156             ContentValues referenceValues = new ContentValues();
 157             referenceValues.put(TimeEntryIndex.EntryIndex.COLUMN_NAME_ICON_ID, REFERENCE_ICON_ID);
 158             db.update(TimeEntryIndex.EntryIndex.TABLE_NAME, referenceValues, _ID + " = " + indexId, null);
 159         }
 160         catch (Exception e)
 161         {
 162             e.printStackTrace();
 163         }
 164     }
 165
 166     @Override
 167     public void createIndexData(String title, String memo, int icon, long startTime)
 168     {
 169         long indexId = createIndexDataImpl(true, title, memo, icon, startTime, 0);
 170         Log.v(TAG, "createIndexData() [" + title +"] " + memo + " " + icon + " " + startTime + " idx: " + indexId);
 171     }
 172
 173     private long createIndexDataImpl(boolean isCallback, String title, String memo, int icon, long startTime, long duration)
 174     {
 175         long indexId = -1;
 176         try
 177         {
 178             boolean ret = false;
 179             ContentValues valuesIndex = new ContentValues();
 180             valuesIndex.put(TimeEntryIndex.EntryIndex.COLUMN_NAME_TITLE, title);
 181             valuesIndex.put(TimeEntryIndex.EntryIndex.COLUMN_NAME_MEMO, memo);
 182             valuesIndex.put(TimeEntryIndex.EntryIndex.COLUMN_NAME_ICON_ID, icon);
 183             valuesIndex.put(TimeEntryIndex.EntryIndex.COLUMN_NAME_START_TIME, startTime);
 184             valuesIndex.put(TimeEntryIndex.EntryIndex.COLUMN_NAME_TIME_DURATION, duration);
 185             indexId = db.insert(TimeEntryIndex.EntryIndex.TABLE_NAME, null, valuesIndex);
 186             if (indexId != -1)
 187             {
 188                 ret = true;
 189             }
 190             if (isCallback)
 191             {
 192                 callback.dataEntryFinished(ITimeEntryDatabaseCallback.OperationType.CREATED, ret, indexId, title);
 193             }
 194         }
 195         catch (Exception e)
 196         {
 197             e.printStackTrace();
 198         }
 199         appendTimeDataImpl(true, indexId, startTime, DEFAULT_RECORD_TYPE);
 200         return (indexId);
 201     }
 202
 203     @Override
 204     public void appendTimeData(long indexId, long lapTime)
 205     {
 206         Log.v(TAG, "appendTimeData()  " +  lapTime);
 207         appendTimeDataImpl(true, indexId, lapTime, DEFAULT_RECORD_TYPE);
 208     }
 209
 210     /**
 211      *
 212      *
 213      */
 214     private void appendTimeDataImpl(boolean isCallback, long indexId, long lapTime, long recordType)
 215     {
 216         try
 217         {
 218             boolean ret = false;
 219             ContentValues valuesData = new ContentValues();
 220             valuesData.put(TimeEntryData.EntryData.COLUMN_NAME_INDEX_ID, indexId);
 221             valuesData.put(TimeEntryData.EntryData.COLUMN_NAME_TIME_ENTRY, lapTime);
 222             valuesData.put(TimeEntryData.EntryData.COLUMN_NAME_OTHER_ID, 0);
 223             valuesData.put(TimeEntryData.EntryData.COLUMN_NAME_GPS_ID, 0);
 224             valuesData.put(TimeEntryData.EntryData.COLUMN_NAME_MEMO_ID, 0);
 225             valuesData.put(TimeEntryData.EntryData.COLUMN_NAME_ICON_ID, 0);
 226             valuesData.put(TimeEntryData.EntryData.COLUMN_NAME_RECORD_TYPE, recordType);
 227             long dataId = db.insert(TimeEntryData.EntryData.TABLE_NAME, null, valuesData);
 228             if (dataId != -1)
 229             {
 230                 ret = true;
 231             }
 232             if (isCallback)
 233             {
 234                 callback.timeEntryFinished(ITimeEntryDatabaseCallback.OperationType.APPENDED, ret, indexId, dataId);
 235             }
 236         }
 237         catch (Exception e)
 238         {
 239             e.printStackTrace();
 240         }
 241
 242     }
 243
 244     /**
 245      *
 246      *
 247      */
 248     @Override
 249     public void finishTimeData(long indexId, long startTime, long endTime)
 250     {
 251         Log.v(TAG, "finishTimeData()  " +  endTime);
 252         try
 253         {
 254             boolean ret = false;
 255             appendTimeData(indexId, endTime);
 256             long elapsedTime = endTime - startTime;
 257             if (elapsedTime < 0)
 258             {
 259                 elapsedTime = 0;
 260             }
 261             ContentValues valuesIndex = new ContentValues();
 262             valuesIndex.put(TimeEntryIndex.EntryIndex.COLUMN_NAME_TIME_DURATION, elapsedTime);
 263             int rows = db.update(TimeEntryIndex.EntryIndex.TABLE_NAME, valuesIndex, "_id=" + indexId, null);
 264             if (rows > 0)
 265             {
 266                 ret = true;
 267             }
 268             callback.dataEntryFinished(ITimeEntryDatabaseCallback.OperationType.FINISHED, ret, indexId, "");
 269         }
 270         catch (Exception e)
 271         {
 272             e.printStackTrace();
 273         }
 274     }
 275
 276     /**
 277      *
 278      *
 279      */
 280     @Override
 281     public long createTimeEntryModelData(int lap, long totalTime, @NonNull String memo)
 282     {
 283         long diffTime = totalTime / (long) lap;
 284         String title = " " + lap + " LAPs Model";
 285         Log.v(TAG, "ENTRY : '" + lap + " " + title + "' mills : " + "(" + diffTime + ") " + memo);
 286
 287         try
 288         {
 289             long lapTime = 0;
 290             long indexId = createIndexDataImpl(false, title, memo, MODEL_DATA_ICON_ID, lapTime, totalTime);
 291             for (int index = 0; index < lap; index++)
 292             {
 293                 lapTime = lapTime + diffTime;
 294                 appendTimeDataImpl(false, indexId, lapTime, EDITABLE_RECORD_TYPE);
 295             }
 296             callback.modelDataEntryFinished(ITimeEntryDatabaseCallback.OperationType.FINISHED, true, indexId, title);
 297             return (indexId);
 298        }
 299         catch (Exception e)
 300         {
 301             e.printStackTrace();
 302         }
 303         callback.modelDataEntryFinished(ITimeEntryDatabaseCallback.OperationType.FINISHED, false, -1, title);
 304         return (-1);
 305     }
 306
 307     /**
 308      *
 309      *
 310      */
 311     @Override
 312     public int  updateTimeEntryData(long detailId, long totalTime)
 313     {
 314         int rows = 0;
 315         Log.v(TAG, "updateTimeEntryData (" + detailId + ") : " + totalTime);
 316         try
 317         {
 318             ContentValues timeValue = new ContentValues();
 319             timeValue.put(TimeEntryData.EntryData.COLUMN_NAME_TIME_ENTRY, totalTime);
 320            rows =  db.update(TimeEntryData.EntryData.TABLE_NAME, timeValue, _ID + " = " + detailId, null);
 321         }
 322         catch (Exception e)
 323         {
 324             e.printStackTrace();
 325         }
 326         return (rows);
 327      }
 328
 329 /*
 330     public boolean prepareToRead()
 331     {
 332         Log.v(TAG, "prepareToRead() ");
 333         boolean ret = false;
 334         try
 335         {
 336             // Gets the data repository in read mode
 337             readDb = dbHelper.getReadableDatabase();
 338             ret = true;
 339         }
 340         catch (Exception e)
 341         {
 342             e.printStackTrace();
 343         }
 344         return (ret);
 345     }
 346
 347     public boolean prepareToWrite()
 348     {
 349         Log.v(TAG, "prepareToWrite() ");
 350         boolean ret = false;
 351         try
 352         {
 353             // Gets the data repository in write mode
 354             writeDb = dbHelper.getWritableDatabase();
 355             ret = true;
 356         }
 357         catch (Exception e)
 358         {
 359             e.printStackTrace();
 360         }
 361         return (ret);
 362     }
 363 */
 364
 365 }