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         if (db == null)
  90         {
  91             return (null);
  92         }
  93         String queryString = "SELECT * FROM " + TimeEntryIndex.EntryIndex.TABLE_NAME + " INNER JOIN " + TimeEntryData.EntryData.TABLE_NAME +
  94                 " ON " + TimeEntryIndex.EntryIndex.TABLE_NAME + "." + TimeEntryIndex.EntryIndex._ID + " = " + TimeEntryData.EntryData.TABLE_NAME+ "." + TimeEntryData.EntryData.COLUMN_NAME_INDEX_ID +
  95                 " WHERE " + TimeEntryIndex.EntryIndex.TABLE_NAME+ "." + TimeEntryIndex.EntryIndex.COLUMN_NAME_ICON_ID + " = " + REFERENCE_ICON_ID +
  96                 " ORDER BY " + TimeEntryData.EntryData.TABLE_NAME+ "." + TimeEntryData.EntryData.COLUMN_NAME_TIME_ENTRY;
  97         //Log.v(TAG, "Query : " + queryString);
  98         return (db.rawQuery(queryString, null));
  99     }
 100
 101     @Override
 102     public Cursor getIndexdata(long indexId)
 103     {
 104         return (db.rawQuery("SELECT * FROM " + TimeEntryIndex.EntryIndex.TABLE_NAME + " WHERE " + TimeEntryIndex.EntryIndex._ID + " = " + indexId + " ORDER BY " + TimeEntryIndex.EntryIndex.COLUMN_NAME_START_TIME, null));
 105     }
 106
 107     @Override
 108     public void deleteTimeEntryData(long indexId)
 109     {
 110         int delRecord = db.delete(TimeEntryData.EntryData.TABLE_NAME, TimeEntryData.EntryData.COLUMN_NAME_INDEX_ID + " = " + indexId, null);
 111         int delIndex = db.delete(TimeEntryIndex.EntryIndex.TABLE_NAME, _ID + " = " + indexId, null);
 112
 113         Log.v(TAG, "deleteTimeEntryData()  index : " + indexId + "Recs. [" + delIndex + "] (" + delRecord + ")");
 114     }
 115
 116     /**
 117      *
 118      *
 119      */
 120     @Override
 121     public void updateIndexData(long indexId, String title, int icon)
 122     {
 123         try
 124         {
 125             if ((title != null)&&(!title.isEmpty()))
 126             {
 127                 ContentValues titleValues = new ContentValues();
 128                 titleValues.put(TimeEntryIndex.EntryIndex.COLUMN_NAME_TITLE, title);
 129                 db.update(TimeEntryIndex.EntryIndex.TABLE_NAME, titleValues, _ID + " = " + indexId, null);
 130             }
 131
 132             ContentValues iconValues = new ContentValues();
 133             iconValues.put(TimeEntryIndex.EntryIndex.COLUMN_NAME_ICON_ID, icon);
 134             db.update(TimeEntryIndex.EntryIndex.TABLE_NAME, iconValues, _ID + " = " + indexId, null);
 135         }
 136         catch (Exception e)
 137         {
 138             e.printStackTrace();
 139         }
 140     }
 141
 142     /**
 143      *
 144      *
 145      */
 146     @Override
 147     public void setReferenceIndexData(long indexId)
 148     {
 149         try
 150         {
 151             ContentValues clearValues = new ContentValues();
 152             clearValues.put(TimeEntryIndex.EntryIndex.COLUMN_NAME_ICON_ID, DEFAULT_ICON_ID);
 153             db.update(TimeEntryIndex.EntryIndex.TABLE_NAME, clearValues, TimeEntryIndex.EntryIndex.COLUMN_NAME_ICON_ID + " = " + REFERENCE_ICON_ID, null);
 154
 155             ContentValues referenceValues = new ContentValues();
 156             referenceValues.put(TimeEntryIndex.EntryIndex.COLUMN_NAME_ICON_ID, REFERENCE_ICON_ID);
 157             db.update(TimeEntryIndex.EntryIndex.TABLE_NAME, referenceValues, _ID + " = " + indexId, null);
 158         }
 159         catch (Exception e)
 160         {
 161             e.printStackTrace();
 162         }
 163     }
 164
 165     @Override
 166     public void createIndexData(String title, String memo, int icon, long startTime)
 167     {
 168         long indexId = createIndexDataImpl(true, title, memo, icon, startTime, 0);
 169         Log.v(TAG, "createIndexData() [" + title +"] " + memo + " " + icon + " " + startTime + " idx: " + indexId);
 170     }
 171
 172     private long createIndexDataImpl(boolean isCallback, String title, String memo, int icon, long startTime, long duration)
 173     {
 174         long indexId = -1;
 175         try
 176         {
 177             boolean ret = false;
 178             ContentValues valuesIndex = new ContentValues();
 179             valuesIndex.put(TimeEntryIndex.EntryIndex.COLUMN_NAME_TITLE, title);
 180             valuesIndex.put(TimeEntryIndex.EntryIndex.COLUMN_NAME_MEMO, memo);
 181             valuesIndex.put(TimeEntryIndex.EntryIndex.COLUMN_NAME_ICON_ID, icon);
 182             valuesIndex.put(TimeEntryIndex.EntryIndex.COLUMN_NAME_START_TIME, startTime);
 183             valuesIndex.put(TimeEntryIndex.EntryIndex.COLUMN_NAME_TIME_DURATION, duration);
 184             indexId = db.insert(TimeEntryIndex.EntryIndex.TABLE_NAME, null, valuesIndex);
 185             if (indexId != -1)
 186             {
 187                 ret = true;
 188             }
 189             if (isCallback)
 190             {
 191                 callback.dataEntryFinished(ITimeEntryDatabaseCallback.OperationType.CREATED, ret, indexId, title);
 192             }
 193         }
 194         catch (Exception e)
 195         {
 196             e.printStackTrace();
 197         }
 198         appendTimeDataImpl(true, indexId, startTime, DEFAULT_RECORD_TYPE);
 199         return (indexId);
 200     }
 201
 202     @Override
 203     public void appendTimeData(long indexId, long lapTime)
 204     {
 205         Log.v(TAG, "appendTimeData()  " +  lapTime);
 206         appendTimeDataImpl(true, indexId, lapTime, DEFAULT_RECORD_TYPE);
 207     }
 208
 209     /**
 210      *
 211      *
 212      */
 213     private void appendTimeDataImpl(boolean isCallback, long indexId, long lapTime, long recordType)
 214     {
 215         try
 216         {
 217             boolean ret = false;
 218             ContentValues valuesData = new ContentValues();
 219             valuesData.put(TimeEntryData.EntryData.COLUMN_NAME_INDEX_ID, indexId);
 220             valuesData.put(TimeEntryData.EntryData.COLUMN_NAME_TIME_ENTRY, lapTime);
 221             valuesData.put(TimeEntryData.EntryData.COLUMN_NAME_OTHER_ID, 0);
 222             valuesData.put(TimeEntryData.EntryData.COLUMN_NAME_GPS_ID, 0);
 223             valuesData.put(TimeEntryData.EntryData.COLUMN_NAME_MEMO_ID, 0);
 224             valuesData.put(TimeEntryData.EntryData.COLUMN_NAME_ICON_ID, 0);
 225             valuesData.put(TimeEntryData.EntryData.COLUMN_NAME_RECORD_TYPE, recordType);
 226             long dataId = db.insert(TimeEntryData.EntryData.TABLE_NAME, null, valuesData);
 227             if (dataId != -1)
 228             {
 229                 ret = true;
 230             }
 231             if (isCallback)
 232             {
 233                 callback.timeEntryFinished(ITimeEntryDatabaseCallback.OperationType.APPENDED, ret, indexId, dataId);
 234             }
 235         }
 236         catch (Exception e)
 237         {
 238             e.printStackTrace();
 239         }
 240
 241     }
 242
 243     /**
 244      *
 245      *
 246      */
 247     @Override
 248     public void finishTimeData(long indexId, long startTime, long endTime)
 249     {
 250         Log.v(TAG, "finishTimeData()  " +  endTime);
 251         try
 252         {
 253             boolean ret = false;
 254             appendTimeData(indexId, endTime);
 255             long elapsedTime = endTime - startTime;
 256             if (elapsedTime < 0)
 257             {
 258                 elapsedTime = 0;
 259             }
 260             ContentValues valuesIndex = new ContentValues();
 261             valuesIndex.put(TimeEntryIndex.EntryIndex.COLUMN_NAME_TIME_DURATION, elapsedTime);
 262             int rows = db.update(TimeEntryIndex.EntryIndex.TABLE_NAME, valuesIndex, "_id=" + indexId, null);
 263             if (rows > 0)
 264             {
 265                 ret = true;
 266             }
 267             callback.dataEntryFinished(ITimeEntryDatabaseCallback.OperationType.FINISHED, ret, indexId, "");
 268         }
 269         catch (Exception e)
 270         {
 271             e.printStackTrace();
 272         }
 273     }
 274
 275     /**
 276      *
 277      *
 278      */
 279     @Override
 280     public long createTimeEntryModelData(int lap, long totalTime, @NonNull String memo)
 281     {
 282         long diffTime = totalTime / (long) lap;
 283         String title = " " + lap + " LAPs Model";
 284         Log.v(TAG, "ENTRY : '" + lap + " " + title + "' mills : " + "(" + diffTime + ") " + memo);
 285
 286         try
 287         {
 288             long lapTime = 0;
 289             long indexId = createIndexDataImpl(false, title, memo, MODEL_DATA_ICON_ID, lapTime, totalTime);
 290             for (int index = 0; index < lap; index++)
 291             {
 292                 lapTime = lapTime + diffTime;
 293                 appendTimeDataImpl(false, indexId, lapTime, EDITABLE_RECORD_TYPE);
 294             }
 295             callback.modelDataEntryFinished(ITimeEntryDatabaseCallback.OperationType.FINISHED, true, indexId, title);
 296             return (indexId);
 297        }
 298         catch (Exception e)
 299         {
 300             e.printStackTrace();
 301         }
 302         callback.modelDataEntryFinished(ITimeEntryDatabaseCallback.OperationType.FINISHED, false, -1, title);
 303         return (-1);
 304     }
 305
 306     /**
 307      *
 308      *
 309      */
 310     @Override
 311     public int  updateTimeEntryData(long detailId, long totalTime)
 312     {
 313         int rows = 0;
 314         Log.v(TAG, "updateTimeEntryData (" + detailId + ") : " + totalTime);
 315         try
 316         {
 317             ContentValues timeValue = new ContentValues();
 318             timeValue.put(TimeEntryData.EntryData.COLUMN_NAME_TIME_ENTRY, totalTime);
 319            rows =  db.update(TimeEntryData.EntryData.TABLE_NAME, timeValue, _ID + " = " + detailId, null);
 320         }
 321         catch (Exception e)
 322         {
 323             e.printStackTrace();
 324         }
 325         return (rows);
 326      }
 327
 328 /*
 329     public boolean prepareToRead()
 330     {
 331         Log.v(TAG, "prepareToRead() ");
 332         boolean ret = false;
 333         try
 334         {
 335             // Gets the data repository in read mode
 336             readDb = dbHelper.getReadableDatabase();
 337             ret = true;
 338         }
 339         catch (Exception e)
 340         {
 341             e.printStackTrace();
 342         }
 343         return (ret);
 344     }
 345
 346     public boolean prepareToWrite()
 347     {
 348         Log.v(TAG, "prepareToWrite() ");
 349         boolean ret = false;
 350         try
 351         {
 352             // Gets the data repository in write mode
 353             writeDb = dbHelper.getWritableDatabase();
 354             ret = true;
 355         }
 356         catch (Exception e)
 357         {
 358             e.printStackTrace();
 359         }
 360         return (ret);
 361     }
 362 */
 363
 364 }