String dir = getFilesDir().getAbsolutePath() + "/mmkv";
String rootDir = MMKV.initialize(dir, new MMKV.LibLoader() {
    @Override
    public void loadLibrary(String libName) {
        ReLinker.loadLibrary(MyApplication.this, libName);
    }
}, MMKVLogLevel.LevelInfo);
Log.i("MMKV", "mmkv root: " + rootDir);

// set log level
MMKV.setLogLevel(MMKVLogLevel.LevelInfo);

// you can turn off logging
//MMKV.setLogLevel(MMKVLogLevel.LevelNone);

MMKV.registerHandler(this);
MMKV.registerContentChangeNotify(this);

public static String initialize(Context context) {
    String root = context.getFilesDir().getAbsolutePath() + "/mmkv";
    MMKVLogLevel logLevel = BuildConfig.DEBUG ? MMKVLogLevel.LevelDebug : MMKVLogLevel.LevelInfo;
    return initialize(root, null, logLevel);
}

public static String initialize(String rootDir, LibLoader loader, MMKVLogLevel logLevel) {
    if (loader != null) {
        if (BuildConfig.FLAVOR.equals("SharedCpp")) {
            loader.loadLibrary("c++_shared");
        }
        loader.loadLibrary("mmkv");
    } else {
        if (BuildConfig.FLAVOR.equals("SharedCpp")) {
            System.loadLibrary("c++_shared");
        }
        System.loadLibrary("mmkv");
    }
    MMKV.rootDir = rootDir;
    jniInitialize(MMKV.rootDir, logLevel2Int(logLevel));
    return rootDir;
}

public static MMKV mmkvWithID(String mmapID) {
    if (rootDir == null) {
        throw new IllegalStateException("You should Call MMKV.initialize() first.");
    }
    long handle = getMMKVWithID(mmapID, SINGLE_PROCESS_MODE, null, null);
    return new MMKV(handle);
}

public static MMKV mmkvWithID(String mmapID, int mode) {
        if (rootDir == null) {
            throw new IllegalStateException("You should Call MMKV.initialize() first.");
        }

        long handle = getMMKVWithID(mmapID, mode, null, null);
        return new MMKV(handle);
    }

    // cryptKey's length <= 16
    public static MMKV mmkvWithID(String mmapID, int mode, String cryptKey) {
        if (rootDir == null) {
            throw new IllegalStateException("You should Call MMKV.initialize() first.");
        }

        long handle = getMMKVWithID(mmapID, mode, cryptKey, null);
        return new MMKV(handle);
    }

    @Nullable
    public static MMKV mmkvWithID(String mmapID, String relativePath) {
        if (rootDir == null) {
            throw new IllegalStateException("You should Call MMKV.initialize() first.");
        }

        long handle = getMMKVWithID(mmapID, SINGLE_PROCESS_MODE, null, relativePath);
        if (handle == 0) {
            return null;
        }
        return new MMKV(handle);
    }

private native static long getMMKVWithID(String mmapID, int mode, String cryptKey, String relativePath);

db.beginTransaction();
try {
    ...
    db.setTransactionSuccessful();
} finally {
    db.endTransaction();
}

public ConfigDao getConfigDao() {
  if (_configDao != null) {
    return _configDao;
  } else {
    synchronized(this) {
      if(_configDao == null) {
        _configDao = new ConfigDao_Impl(this);
      }
      return _configDao;
    }
  }
}

public SQLiteDatabase getReadableDatabase() {
    synchronized (this) {
        return getDatabaseLocked(false);
    }
}

@SuppressWarnings("unused")
private SQLiteDatabase getDatabaseLocked(boolean writable) {
    if (mDatabase != null) {
        if (!mDatabase.isOpen()) {
            // Darn!  The user closed the database by calling mDatabase.close().
            mDatabase = null;
        } else if (!writable || !mDatabase.isReadOnly()) {
            // The database is already open for business.
            return mDatabase;
        }
    }

    if (mIsInitializing) {
        throw new IllegalStateException("getDatabase called recursively");
    }

    SQLiteDatabase db = mDatabase;
    try {
        mIsInitializing = true;

        if (db != null) {
            if (writable && db.isReadOnly()) {
                db.reopenReadWrite();
            }
        } else if (mName == null) {
            db = SQLiteDatabase.create(null);
        } else {
            int connectionPoolSize = mForcedSingleConnection ? 1 : 0;
            try {
                if (DEBUG_STRICT_READONLY && !writable) {
                    final String path = mContext.getDatabasePath(mName).getPath();
                    db = SQLiteDatabase.openDatabase(path, mPassword, mCipher, mFactory,
                            SQLiteDatabase.OPEN_READONLY, mErrorHandler, connectionPoolSize);
                } else {
                    mNeedMode = true;
                    mMode = mEnableWriteAheadLogging ? Context.MODE_ENABLE_WRITE_AHEAD_LOGGING : 0;
                    db = Context.openOrCreateDatabase(mContext, mName, mPassword, mCipher,
                            mMode, mFactory, mErrorHandler, connectionPoolSize);
                }
            } catch (SQLiteException ex) {
                if (writable) {
                    throw ex;
                }
                Log.e(TAG, "Couldn't open " + mName
                        + " for writing (will try read-only):", ex);
                final String path = mContext.getDatabasePath(mName).getPath();
                db = SQLiteDatabase.openDatabase(path, mPassword, mCipher, mFactory,
                        SQLiteDatabase.OPEN_READONLY, mErrorHandler);
            }
        }

        return getDatabaseLockedLast(db);

    } finally {
        mIsInitializing = false;
        if (db != null && db != mDatabase) {
            db.close();
        }
    }
}

private SQLiteDatabase getDatabaseLockedLast(SQLiteDatabase db) {
    onConfigure(db);

    final int version = db.getVersion();
    if (version != mNewVersion) {
        if (db.isReadOnly()) {
            throw new SQLiteException("Can't upgrade read-only database from version " +
                    db.getVersion() + " to " + mNewVersion + ": " + mName);
        }

        db.beginTransaction();
        try {
            if (version == 0) {
                onCreate(db);
            } else {
                if (version > mNewVersion) {
                    onDowngrade(db, version, mNewVersion);
                } else {
                    onUpgrade(db, version, mNewVersion);
                }
            }
            db.setVersion(mNewVersion);
            db.setTransactionSuccessful();
        } finally {
            db.endTransaction();
        }
    }

    onOpen(db);

    if (db.isReadOnly()) {
        Log.w(TAG, "Opened " + mName + " in read-only mode");
    }

    mDatabase = db;
    return db;
}

private final RoomDatabase __db;

@Override
public void insert(final Config arg0) {
  __db.assertNotSuspendingTransaction();
  __db.beginTransaction();
  try {
    __insertionAdapterOfConfig.insert(arg0); // 实际上就是SupportSQLiteStatement的操作，这里略去实现代码
    __db.setTransactionSuccessful();
  } finally {
    __db.endTransaction();
  }
}

@Deprecated
public void beginTransaction() {
    assertNotMainThread();
    SupportSQLiteDatabase database = mOpenHelper.getWritableDatabase();
    mInvalidationTracker.syncTriggers(database);
    database.beginTransaction();
}

void syncTriggers(SupportSQLiteDatabase database) {
    if (database.inTransaction()) {
        // we won't run this inside another transaction.
        return;
    }
    try {
        // This method runs in a while loop because while changes are synced to db, another
        // runnable may be skipped. If we cause it to skip, we need to do its work.
        while (true) {
            Lock closeLock = mDatabase.getCloseLock();
            closeLock.lock();
            try {
                // there is a potential race condition where another mSyncTriggers runnable
                // can start running right after we get the tables list to sync.
                final int[] tablesToSync = mObservedTableTracker.getTablesToSync();
                if (tablesToSync == null) {
                    return;
                }
                final int limit = tablesToSync.length;
                database.beginTransaction();
                try {
                    for (int tableId = 0; tableId < limit; tableId++) {
                        switch (tablesToSync[tableId]) {
                            case ObservedTableTracker.ADD:
                                startTrackingTable(database, tableId);
                                break;
                            case ObservedTableTracker.REMOVE:
                                stopTrackingTable(database, tableId);
                                break;
                        }
                    }
                    database.setTransactionSuccessful();
                } finally {
                    database.endTransaction();
                }
                mObservedTableTracker.onSyncCompleted();
            } finally {
                closeLock.unlock();
            }
        }
    } catch (IllegalStateException | SQLiteException exception) {
        // may happen if db is closed. just log.
        Log.e(Room.LOG_TAG, "Cannot run invalidation tracker. Is the db closed?",
                exception);
    }
}

@Override
protected InvalidationTracker createInvalidationTracker() {
  final HashMap<String, String> _shadowTablesMap = new HashMap<String, String>(0);
  HashMap<String, Set<String>> _viewTables = new HashMap<String, Set<String>>(0);
  return new InvalidationTracker(this, _shadowTablesMap, _viewTables, "config");
}

@SuppressWarnings("WeakerAccess")
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP_PREFIX)
public InvalidationTracker(RoomDatabase database, Map<String, String> shadowTablesMap,
        Map<String, Set<String>> viewTables, String... tableNames) {
    mDatabase = database;
    mObservedTableTracker = new ObservedTableTracker(tableNames.length);
    mTableIdLookup = new ArrayMap<>();
    mViewTables = viewTables;
    mInvalidationLiveDataContainer = new InvalidationLiveDataContainer(mDatabase);
    final int size = tableNames.length;
    mTableNames = new String[size];
    for (int id = 0; id < size; id++) {
        final String tableName = tableNames[id].toLowerCase(Locale.US);
        mTableIdLookup.put(tableName, id);
        String shadowTableName = shadowTablesMap.get(tableNames[id]);
        if (shadowTableName != null) {
            mTableNames[id] = shadowTableName.toLowerCase(Locale.US);
        } else {
            mTableNames[id] = tableName;
        }
    }
    // Adjust table id lookup for those tables whose shadow table is another already mapped
    // table (e.g. external content fts tables).
    for (Map.Entry<String, String> shadowTableEntry : shadowTablesMap.entrySet()) {
        String shadowTableName = shadowTableEntry.getValue().toLowerCase(Locale.US);
        if (mTableIdLookup.containsKey(shadowTableName)) {
            String tableName = shadowTableEntry.getKey().toLowerCase(Locale.US);
            mTableIdLookup.put(tableName, mTableIdLookup.get(shadowTableName));
        }
    }
}

void internalInit(SupportSQLiteDatabase database) {
    synchronized (this) {
        if (mInitialized) {
            Log.e(Room.LOG_TAG, "Invalidation tracker is initialized twice :/.");
            return;
        }

        // These actions are not in a transaction because temp_store is not allowed to be
        // performed on a transaction, and recursive_triggers is not affected by transactions.
        database.execSQL("PRAGMA temp_store = MEMORY;");
        database.execSQL("PRAGMA recursive_triggers='ON';");
        database.execSQL(CREATE_TRACKING_TABLE_SQL);
        syncTriggers(database);
        mCleanupStatement = database.compileStatement(RESET_UPDATED_TABLES_SQL);
        mInitialized = true;
    }
}

void syncTriggers(SupportSQLiteDatabase database) {
    if (database.inTransaction()) {
        // we won't run this inside another transaction.
        return;
    }
    try {
        // This method runs in a while loop because while changes are synced to db, another
        // runnable may be skipped. If we cause it to skip, we need to do its work.
        while (true) {
            Lock closeLock = mDatabase.getCloseLock();
            closeLock.lock();
            try {
                // there is a potential race condition where another mSyncTriggers runnable
                // can start running right after we get the tables list to sync.
                final int[] tablesToSync = mObservedTableTracker.getTablesToSync();  // #1
                if (tablesToSync == null) {
                    return;
                }
                final int limit = tablesToSync.length;
                database.beginTransaction();
                try {
                    for (int tableId = 0; tableId < limit; tableId++) {
                        switch (tablesToSync[tableId]) {
                            case ObservedTableTracker.ADD:
                                startTrackingTable(database, tableId);
                                break;
                            case ObservedTableTracker.REMOVE:
                                stopTrackingTable(database, tableId);
                                break;
                        }
                    }
                    database.setTransactionSuccessful();
                } finally {
                    database.endTransaction();
                }
                mObservedTableTracker.onSyncCompleted();
            } finally {
                closeLock.unlock();
            }
        }
    } catch (IllegalStateException | SQLiteException exception) {
        // may happen if db is closed. just log.
        Log.e(Room.LOG_TAG, "Cannot run invalidation tracker. Is the db closed?",
                exception);
    }
}

@Nullable
int[] getTablesToSync() {
    synchronized (this) {
        if (!mNeedsSync || mPendingSync) {
            return null;
        }
        final int tableCount = mTableObservers.length;
        for (int i = 0; i < tableCount; i++) {
            final boolean newState = mTableObservers[i] > 0;
            if (newState != mTriggerStates[i]) {
                mTriggerStateChanges[i] = newState ? ADD : REMOVE;
            } else {
                mTriggerStateChanges[i] = NO_OP;
            }
            mTriggerStates[i] = newState;
        }
        mPendingSync = true;
        mNeedsSync = false;
        return mTriggerStateChanges;
    }
}

final boolean newState = mTableObservers[i] > 0;
if (newState != mTriggerStates[i]) {
    mTriggerStateChanges[i] = newState ? ADD : REMOVE;
} else {
    mTriggerStateChanges[i] = NO_OP;
}

@SuppressLint("RestrictedApi")
@WorkerThread
public void addObserver(@NonNull Observer observer) {
    final String[] tableNames = resolveViews(observer.mTables);
    int[] tableIds = new int[tableNames.length];
    final int size = tableNames.length;

    for (int i = 0; i < size; i++) {
        Integer tableId = mTableIdLookup.get(tableNames[i].toLowerCase(Locale.US));
        if (tableId == null) {
            throw new IllegalArgumentException("There is no table with name " + tableNames[i]);
        }
        tableIds[i] = tableId;
    }
    ObserverWrapper wrapper = new ObserverWrapper(observer, tableIds, tableNames);
    ObserverWrapper currentObserver;
    synchronized (mObserverMap) {
        currentObserver = mObserverMap.putIfAbsent(observer, wrapper);
    }
    if (currentObserver == null && mObservedTableTracker.onAdded(tableIds)) {
        syncTriggers();
    }
}

boolean onAdded(int... tableIds) {
    boolean needTriggerSync = false;
    synchronized (this) {
        for (int tableId : tableIds) {
            final long prevObserverCount = mTableObservers[tableId];
            mTableObservers[tableId] = prevObserverCount + 1;
            if (prevObserverCount == 0) {
                mNeedsSync = true;
                needTriggerSync = true;
            }
        }
    }
    return needTriggerSync;
}

private void startTrackingTable(SupportSQLiteDatabase writableDb, int tableId) {
    writableDb.execSQL(
            "INSERT OR IGNORE INTO " + UPDATE_TABLE_NAME + " VALUES(" + tableId + ", 0)");
    final String tableName = mTableNames[tableId];
    StringBuilder stringBuilder = new StringBuilder();
    for (String trigger : TRIGGERS) {
        stringBuilder.setLength(0);
        stringBuilder.append("CREATE TEMP TRIGGER IF NOT EXISTS ");
        appendTriggerName(stringBuilder, tableName, trigger);
        stringBuilder.append(" AFTER ")
                .append(trigger)
                .append(" ON `")
                .append(tableName)
                .append("` BEGIN UPDATE ")
                .append(UPDATE_TABLE_NAME)
                .append(" SET ").append(INVALIDATED_COLUMN_NAME).append(" = 1")
                .append(" WHERE ").append(TABLE_ID_COLUMN_NAME).append(" = ").append(tableId)
                .append(" AND ").append(INVALIDATED_COLUMN_NAME).append(" = 0")
                .append("; END");
        writableDb.execSQL(stringBuilder.toString());
    }
}

Runnable mRefreshRunnable = new Runnable() {
    @Override
    public void run() {
        final Lock closeLock = mDatabase.getCloseLock();
        Set<Integer> invalidatedTableIds = null;
        try {
            closeLock.lock();

            if (!ensureInitialization()) {
                return;
            }

            if (!mPendingRefresh.compareAndSet(true, false)) {
                // no pending refresh
                // 防止重入
                return;
            }

            if (mDatabase.inTransaction()) {
                // current thread is in a transaction. when it ends, it will invoke
                // refreshRunnable again. mPendingRefresh is left as false on purpose
                // so that the last transaction can flip it on again.
                return;
            }

            if (mDatabase.mWriteAheadLoggingEnabled) { // #1
                // This transaction has to be on the underlying DB rather than the RoomDatabase
                // in order to avoid a recursive loop after endTransaction.
                SupportSQLiteDatabase db = mDatabase.getOpenHelper().getWritableDatabase();
                db.beginTransaction();
                try {
                    invalidatedTableIds = checkUpdatedTable();
                    db.setTransactionSuccessful();
                } finally {
                    db.endTransaction();
                }
            } else {
                invalidatedTableIds = checkUpdatedTable();
            }
        } catch (IllegalStateException | SQLiteException exception) {
            // may happen if db is closed. just log.
            Log.e(Room.LOG_TAG, "Cannot run invalidation tracker. Is the db closed?",
                    exception);
        } finally {
            closeLock.unlock();
        }
        if (invalidatedTableIds != null && !invalidatedTableIds.isEmpty()) {
            synchronized (mObserverMap) {
                for (Map.Entry<Observer, ObserverWrapper> entry : mObserverMap) {
                    entry.getValue().notifyByTableInvalidStatus(invalidatedTableIds); // #2
                }
            }
        }
    }

    private Set<Integer> checkUpdatedTable() {
        ArraySet<Integer> invalidatedTableIds = new ArraySet<>();
        Cursor cursor = mDatabase.query(new SimpleSQLiteQuery(SELECT_UPDATED_TABLES_SQL));  // #3
        //noinspection TryFinallyCanBeTryWithResources

        // 通过cursor读到 invalidatedTableIds，略去
        if (!invalidatedTableIds.isEmpty()) {
            mCleanupStatement.executeUpdateDelete(); // 有数据更新，重置下invalidated标志位
        }
        return invalidatedTableIds;
    }
};

void notifyByTableInvalidStatus(Set<Integer> invalidatedTablesIds) {
    Set<String> invalidatedTables = null;
    final int size = mTableIds.length;
    for (int index = 0; index < size; index++) {
        final int tableId = mTableIds[index];
        if (invalidatedTablesIds.contains(tableId)) {
            if (size == 1) {
                // Optimization for a single-table observer
                invalidatedTables = mSingleTableSet;
            } else {
                if (invalidatedTables == null) {
                    invalidatedTables = new ArraySet<>(size);
                }
                invalidatedTables.add(mTableNames[index]);
            }
        }
    }
    if (invalidatedTables != null) {
        mObserver.onInvalidated(invalidatedTables);
    }
}

@SuppressLint({"RestrictedApi"})
RoomTrackingLiveData(RoomDatabase database, InvalidationLiveDataContainer container, boolean inTransaction, Callable<T> computeFunction, String[] tableNames) {
    // ...
    this.mObserver = new Observer(tableNames) {
        public void onInvalidated(@NonNull Set<String> tables) {
            ArchTaskExecutor.getInstance().executeOnMainThread(RoomTrackingLiveData.this.mInvalidationRunnable); // #1
        }
    };
}

final Runnable mInvalidationRunnable = new Runnable() {
    @MainThread
    public void run() {
        boolean isActive = RoomTrackingLiveData.this.hasActiveObservers();
        if (RoomTrackingLiveData.this.mInvalid.compareAndSet(false, true) && isActive) {
            RoomTrackingLiveData.this.getQueryExecutor().execute(RoomTrackingLiveData.this.mRefreshRunnable); // #2
        }

    }
};

final Runnable mRefreshRunnable = new Runnable() {
@WorkerThread
public void run() {
    if (RoomTrackingLiveData.this.mRegisteredObserver.compareAndSet(false, true)) {
        RoomTrackingLiveData.this.mDatabase.getInvalidationTracker().addWeakObserver(RoomTrackingLiveData.this.mObserver);
    }

    boolean computed;
    do {
        computed = false;
        if (RoomTrackingLiveData.this.mComputing.compareAndSet(false, true)) {
            try {
                Object value = null;

                while(RoomTrackingLiveData.this.mInvalid.compareAndSet(true, false)) {
                    computed = true;

                    try {
                        value = RoomTrackingLiveData.this.mComputeFunction.call();
                    } catch (Exception var7) {
                        throw new RuntimeException("Exception while computing database live data.", var7);
                    }
                }

                if (computed) {
                    RoomTrackingLiveData.this.postValue(value); // #3
                }
            } finally {
                RoomTrackingLiveData.this.mComputing.set(false);
            }
        }
    } while(computed && RoomTrackingLiveData.this.mInvalid.get());

}
};

@SuppressWarnings("WeakerAccess")
public void refreshVersionsAsync() {
    // TODO we should consider doing this sync instead of async.
    if (mPendingRefresh.compareAndSet(false, true)) {
        mDatabase.getQueryExecutor().execute(mRefreshRunnable);
    }
}

@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP_PREFIX)
@WorkerThread
public void refreshVersionsSync() {
    syncTriggers();
    mRefreshRunnable.run();
}

public void onItemSelected(AdapterView<?> parent, View view,
        int position, long id) {
    ListView listView = getListView();
    Log.d(TAG, "onItemSelected gave us " + view.toString());
    Button b = (Button) view.findViewById(R.id.button);
    EditText et = (EditText) view.findViewById(R.id.editor);
    if (b != null || et != null) {
        // Use afterDescendants to keep ListView from getting focus
        listView.setDescendantFocusability(ViewGroup.FOCUS_AFTER_DESCENDANTS);
        if(et!=null) et.requestFocus();
        else if(b!=null) b.requestFocus();
    } else {
        if (!listView.isFocused()) {
            // Use beforeDescendants so that previous selections don't re-take focus
            listView.setDescendantFocusability(ViewGroup.FOCUS_BEFORE_DESCENDANTS);
            listView.requestFocus();
        }
    }

}

String text = guessLikeBean.getTitle()+"(精)";
mTvTitle.setText(text);
int ellipsisCount = mTvTitle.getLayout().getEllipsisCount(mTvTitle.getLineCount() - 1);
if (ellipsisCount > 0) {
    text = text.substring(0, text.length() - ellipsisCount - 1) + "…(精)";
}
SpannableString imageString = new SpannableString(text);
...