Q: About SQLite 3, is it required to read after write? In an Android application, concerning SQLITE3,
Is it required to read after write or we can just count on a successful transaction ? 
Update to show the function to insert data:
    // Insert a post into the database
    public void addM0(Store_M0_DataClass mStore_M0_DataClass)
    {
       // Create and/or open the database for writing
        SQLiteDatabase db = getWritableDatabase();



        // It's a good idea to wrap our insert in a transaction. This helps with performance and ensures
        // consistency of the database.
        db.beginTransaction();
        try
        {
            // The user might already exist in the database (i.e. the same user created multiple posts).

            ContentValues values = new ContentValues();
            values.put(KEY_M0_ID, mStore_M0_DataClass.getM0_ID());
            values.put(KEY_M0_IMAGE1, mStore_M0_DataClass.getM0_Image1());
            values.put(KEY_M0_IMAGE2, mStore_M0_DataClass.getM0_Image2());
            values.put(KEY_M0_ENABLE, mStore_M0_DataClass.getM0_Enable());

            db.insertOrThrow(TABLE_M0, null, values);

            db.setTransactionSuccessful();
        }
        catch (Exception e)
        {
        }
        finally
        {
            db.endTransaction();
        }
    }


A: An insert or any single action is automatically enclosed in a transaction, as such there is no benefit in wrapping it in a transaction. However, if you were doing multiple inserts in a loop then beginning a transaction prior to the loop, setting it as successful, if successful, after the loop, and ending the transaction after the loop it would have a benefit.
There is also little need to use insertOrThrow unless you want to trap an exception, as the insert method is effectively INSERT OR IGNORE and the result is the rowid of the inserted row, which will be 1 or greater (in most normal use cases).


*

*rowid is a special, normally hidden column, frequently aliased using by using a column defined using specifically column_name INTEGER PRIMARY KEY or column_name INTEGER PRIMARY KEY AUTOINCREMENT Rowid Tables


*

*(noting that AUTOINCREMENT is generally not required and has overheads) SQLite Autoincrement
As such using :-
public long addM0(Store_M0_DataClass mStore_M0_DataClass)
{
   // Create and/or open the database for writing
    SQLiteDatabase db = getWritableDatabase();

    ContentValues values = new ContentValues();
    values.put(KEY_M0_ID, mStore_M0_DataClass.getM0_ID());
    values.put(KEY_M0_IMAGE1, mStore_M0_DataClass.getM0_Image1());
    values.put(KEY_M0_IMAGE2, mStore_M0_DataClass.getM0_Image2());
    values.put(KEY_M0_ENABLE, mStore_M0_DataClass.getM0_Enable());
    return db.insert(TABLE_M0, null, values);
}

However, if you wanted to store multiple Store_M0_DataClass objects then you could have :-
public int addManyMo(Store_M0_DataClass[] mStore_M0_DataClasses) {
    int rv = 0;
    SQLiteDatabase db = this.getWritableDatabase();
    db.beginTransaction();// <<<<<<<<<< wrap all inserts in a transaction
    for (Store_M0_DataClass m0: mStore_M0_DataClasses) {
        if(addM0(m0) > 0) {
            rv++;
        }
    }
    // Assumes OK if any inserts have worked, not if none have worked
    if (rv > 0) {
        db.setTransactionSuccessful(); 
    }
    db.endTransaction();
    return rv; // Retruns the number of rows inserted
}

As for :-

Is it required to read after write or we can just count on a
  successful transaction ?

A transaction being successful commits what was in the transaction. Comitting is effectively writing the data to disk so there is no need to do anything after a commit.


*

*with WAL (Write Ahead logging) the data is written to the WAL file rather than the database (and also the shm file). However when accessing the database if the WAL has data it is effectively read as being part of the database. The WAL data is written to the database when the WAL is checkpionted.

