DataStorage

Using the External Storage

Checking media availability
Before you do any work with the external storage, you should always call
getExternalStorageState() to check whether the media is available.
The media might be mounted to a computer, missing, read-only, or in some other state.
For example, here are a couple methods you can use to check the availability:

  /* Checks if external storage is available for read and write */
  public boolean isExternalStorageWritable() {
    String state = Environment.getExternalStorageState();
    if (Environment.MEDIA_MOUNTED.equals(state)) {
        return true;
    }
    return false;
  }

  /* Checks if external storage is available to at least read */
  public boolean isExternalStorageReadable() {
    String state = Environment.getExternalStorageState();
    if (Environment.MEDIA_MOUNTED.equals(state) ||
        Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)) {
        return true;
    }
    return false;
  }

Saving files that can be shared with other apps

  public File getAlbumStorageDir(String albumName) {
    // Get the directory for the user's public pictures directory.
    File file = new File(Environment.getExternalStoragePublicDirectory(
            Environment.DIRECTORY_PICTURES), albumName);
    if (!file.mkdirs()) {
        Log.e(LOG_TAG, "Directory not created");
    }
    return file;
  }

Saving files that are app-private

If you are handling files that are not intended for other apps to use (such as graphic textures or sound effects used by only your app), you should use a private storage directory on the external storage by calling getExternalFilesDir().

Saving cache files

To open a File that represents the external storage directory where you should save cache files, call getExternalCacheDir(). If the user uninstalls your application, these files will be automatically deleted.

Similar to ContextCompat.getExternalFilesDirs(), mentioned above, you can also access a cache directory on a secondary external storage (if available) by calling ContextCompat.getExternalCacheDirs().

Using Databases

public class DictionaryOpenHelper extends SQLiteOpenHelper {

  private static final int DATABASE_VERSION = 2;
  private static final String DICTIONARY_TABLE_NAME = "dictionary";
  private static final String DICTIONARY_TABLE_CREATE =
              "CREATE TABLE " + DICTIONARY_TABLE_NAME + " (" +
              KEY_WORD + " TEXT, " +
              KEY_DEFINITION + " TEXT);";

  DictionaryOpenHelper(Context context) {
      super(context, DATABASE_NAME, null, DATABASE_VERSION);
  }

  @Override
  public void onCreate(SQLiteDatabase db) {
      db.execSQL(DICTIONARY_TABLE_CREATE);
  }
}

You can then get an instance of your SQLiteOpenHelper implementation using the constructor you've defined. To write to and read from the database, call getWritableDatabase() and getReadableDatabase(), respectively. These both return a SQLiteDatabase object that represents the database and provides methods for SQLite operations.

i take a sample app from google,which named todo-app,help us to understand using SQLite and it use the mvp framework,

1. we look about the Dbhelper there are some important method,onCreate(),onUpgrade(),onDowngrade(),the last one litte using,and the class should extends SQLiteOpenHelper.

public class TasksDbHelper extends SQLiteOpenHelper {
  public static final int DATABASE_VERSION = 1;

  public static final String DATABASE_NAME = "Tasks.db";

  private static final String TEXT_TYPE = " TEXT";

  private static final String BOOLEAN_TYPE = " INTEGER";

  private static final String COMMA_SEP = ",";

  private static final String SQL_CREATE_ENTRIES =
          "CREATE TABLE " + TasksPersistenceContract.TaskEntry.TABLE_NAME + " (" +
                  TasksPersistenceContract.TaskEntry._ID + TEXT_TYPE + " PRIMARY KEY," +
                  TasksPersistenceContract.TaskEntry.COLUMN_NAME_ENTRY_ID + TEXT_TYPE + COMMA_SEP +
                  TasksPersistenceContract.TaskEntry.COLUMN_NAME_TITLE + TEXT_TYPE + COMMA_SEP +
                  TasksPersistenceContract.TaskEntry.COLUMN_NAME_DESCRIPTION + TEXT_TYPE + COMMA_SEP +
                  TasksPersistenceContract.TaskEntry.COLUMN_NAME_COMPLETED + BOOLEAN_TYPE +
          " )";

  public TasksDbHelper(Context context) {
      super(context, DATABASE_NAME, null, DATABASE_VERSION);
  }

  public void onCreate(SQLiteDatabase db) {
      db.execSQL(SQL_CREATE_ENTRIES);
  }

  public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
      // Not required as at version 1
  }

  public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {
      // Not required as at version 1
  }
}

2. when we upgrade our database,we should perfect onUpgrade()method,by using switch oldVersion,we can do some other things also by db.execSQL.Here we can see much more in Guolin's
   first line coding.

3. then we can use some particular methods to operation database
   insert,delete,update,query,etc
   there is the class that google's engineer use to operate database

Note: this is a singleton and we are opening the database once and not closing it. The framework
cleans up the resources when the application closes so we don't need to close the db.

• constructor method

public class TasksLocalDataSource implements TasksDataSource {

  private static TasksLocalDataSource INSTANCE;

  private TasksDbHelper mDbHelper;

  private SQLiteDatabase mDb;

  // Prevent direct instantiation.
  private TasksLocalDataSource(@NonNull Context context) {
     checkNotNull(context);
     mDbHelper = new TasksDbHelper(context);
     mDb = mDbHelper.getWritableDatabase();
   }
   public static TasksLocalDataSource getInstance(@NonNull Context context) {
      if (INSTANCE == null) {
          INSTANCE = new TasksLocalDataSource(context);
      }
      return INSTANCE;
    }
  }

• findall method

@Override
  public List<Task> getTasks() {
      List<Task> tasks = new ArrayList<Task>();
      try {

          String[] projection = {
                  TaskEntry.COLUMN_NAME_ENTRY_ID,
                  TaskEntry.COLUMN_NAME_TITLE,
                  TaskEntry.COLUMN_NAME_DESCRIPTION,
                  TaskEntry.COLUMN_NAME_COMPLETED
          };

          Cursor c = mDb.query(
                  TaskEntry.TABLE_NAME, projection, null, null, null, null, null);

          if (c != null && c.getCount() > 0) {
              while (c.moveToNext()) {
                  String itemId = c
                          .getString(c.getColumnIndexOrThrow(TaskEntry.COLUMN_NAME_ENTRY_ID));
                  String title = c
                          .getString(c.getColumnIndexOrThrow(TaskEntry.COLUMN_NAME_TITLE));
                  String description =
                          c.getString(c.getColumnIndexOrThrow(TaskEntry.COLUMN_NAME_DESCRIPTION));
                  boolean completed =
                          c.getInt(c.getColumnIndexOrThrow(TaskEntry.COLUMN_NAME_COMPLETED)) == 1;
                  Task task = new Task(title, description, itemId, completed);
                  tasks.add(task);
              }
          }
          if (c != null) {
              c.close();
          }

      } catch (IllegalStateException e) {
          // Send to analytics, log etc
      }
      return tasks;
  }

• findById method

@Override
  public Task getTask(@NonNull String taskId) {
      try {
          String[] projection = {
                  TaskEntry.COLUMN_NAME_ENTRY_ID,
                  TaskEntry.COLUMN_NAME_TITLE,
                  TaskEntry.COLUMN_NAME_DESCRIPTION,
                  TaskEntry.COLUMN_NAME_COMPLETED
          };

          String selection = TaskEntry.COLUMN_NAME_ENTRY_ID + " LIKE ?";
          String[] selectionArgs = {taskId};

          Cursor c = mDb.query(
                  TaskEntry.TABLE_NAME, projection, selection, selectionArgs, null, null, null);

          Task task = null;

          if (c != null && c.getCount() > 0) {
              c.moveToFirst();
              String itemId = c
                      .getString(c.getColumnIndexOrThrow(TaskEntry.COLUMN_NAME_ENTRY_ID));
              String title = c.getString(c.getColumnIndexOrThrow(TaskEntry.COLUMN_NAME_TITLE));
              String description =
                      c.getString(c.getColumnIndexOrThrow(TaskEntry.COLUMN_NAME_DESCRIPTION));
              boolean completed =
                      c.getInt(c.getColumnIndexOrThrow(TaskEntry.COLUMN_NAME_COMPLETED)) == 1;
              task = new Task(title, description, itemId, completed);
          }
          if (c != null) {
              c.close();
          }

          return task;
      } catch (IllegalStateException e) {
          // Send to analytics, log etc
      }
      return null;
  }

• insert method

@Override
 public void saveTask(@NonNull Task task) {
     try {
         checkNotNull(task);

         ContentValues values = new ContentValues();
         values.put(TaskEntry.COLUMN_NAME_ENTRY_ID, task.getId());
         values.put(TaskEntry.COLUMN_NAME_TITLE, task.getTitle());
         values.put(TaskEntry.COLUMN_NAME_DESCRIPTION, task.getDescription());
         values.put(TaskEntry.COLUMN_NAME_COMPLETED, task.isCompleted());

         mDb.insert(TaskEntry.TABLE_NAME, null, values);
     } catch (IllegalStateException e) {
         // Send to analytics, log etc
     }
 }

• update some paramaeter method

@Override
  public void completeTask(@NonNull Task task) {
      try {
          ContentValues values = new ContentValues();
          values.put(TaskEntry.COLUMN_NAME_COMPLETED, true);

          String selection = TaskEntry.COLUMN_NAME_ENTRY_ID + " LIKE ?";
          String[] selectionArgs = {task.getId()};

          mDb.update(TaskEntry.TABLE_NAME, values, selection, selectionArgs);
      } catch (IllegalStateException e) {
          // Send to analytics, log etc
      }

  }

  @Override
  public void activateTask(@NonNull Task task) {
      try {
          ContentValues values = new ContentValues();
          values.put(TaskEntry.COLUMN_NAME_COMPLETED, false);

          String selection = TaskEntry.COLUMN_NAME_ENTRY_ID + " LIKE ?";
          String[] selectionArgs = {task.getId()};

          mDb.update(TaskEntry.TABLE_NAME, values, selection, selectionArgs);
      } catch (IllegalStateException e) {
          // Send to analytics, log etc
      }
  }

• delete by paramaeter method

@Override
 public void clearCompletedTasks() {
     try {
         String selection = TaskEntry.COLUMN_NAME_COMPLETED + " LIKE ?";
         String[] selectionArgs = {"1"};

         mDb.delete(TaskEntry.TABLE_NAME, selection, selectionArgs);
     } catch (IllegalStateException e) {
         // Send to analytics, log etc
     }
 }

• delete by id method

@Override
  public void deleteTask(@NonNull String taskId) {
      try {
          String selection = TaskEntry.COLUMN_NAME_ENTRY_ID + " LIKE ?";
          String[] selectionArgs = {taskId};

          mDb.delete(TaskEntry.TABLE_NAME, selection, selectionArgs);
      } catch (IllegalStateException e) {
          // Send to analytics, log etc
      }
  }

• delete all method

@Override
  public void deleteTask(@NonNull String taskId) {
      try {
          String selection = TaskEntry.COLUMN_NAME_ENTRY_ID + " LIKE ?";
          String[] selectionArgs = {taskId};

          mDb.delete(TaskEntry.TABLE_NAME, selection, selectionArgs);
      } catch (IllegalStateException e) {
          // Send to analytics, log etc
      }
  }