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