Java 类android.database.DatabaseErrorHandler 实例源码

/**
 * Create a helper object to create, open, and/or manage a database in
 * a specified location.
 * This method always returns very quickly.  The database is not actually
 * created or opened until one of {@link #getWritableDatabase} or
 * {@link #getReadableDatabase} is called.
 *
 * @param context to use to open or create the database
 * @param name of the database file
 * @param storageDirectory to store the database file upon creation; caller must
 * ensure that the specified absolute path is available and can be written to
 * @param factory to use for creating cursor objects, or null for the default
 * @param version number of the database (starting at 1); if the database is older,
 * SQL file(s) contained within the application assets folder will be used to
 * upgrade the database
 */
public SQLiteAssetHelper(Context context, String name, String storageDirectory, CursorFactory factory, int version, DatabaseErrorHandler errorHandler) {
    super(context, name, factory, version, errorHandler);

    if (version < 1) throw new IllegalArgumentException("Version must be >= 1, was " + version);
    if (name == null) throw new IllegalArgumentException("Database name cannot be null");

    mContext = context;
    mName = name;
    mFactory = factory;
    mNewVersion = version;

    mAssetPath = ASSET_DB_PATH + "/" + name;
    if (storageDirectory != null) {
        mDatabasePath = storageDirectory;
    } else {
        mDatabasePath = context.getApplicationInfo().dataDir + "/databases";
    }
    mUpgradePathFormat = ASSET_DB_PATH + "/" + name + "_upgrade_%s-%s.sql";
}

@TargetApi(Build.VERSION_CODES.JELLY_BEAN)
public SQLiteDatabase openOrCreateDatabase(String name, int mode, SQLiteDatabase.CursorFactory factory, DatabaseErrorHandler errorHandler) {
    if (dbMap.containsKey(name)) {
        return dbMap.get(name);
    }
    // 创建数据库
    try {
        String path = DbPathUtils.getDbPath(name);

        ShadowSQLiteDatabase sdb = new ShadowSQLiteDatabase(path, 0, null);
        SQLiteDatabase       db  = new CGLibProxy().proxy(SQLiteDatabase.class, sdb);

        sdb.setMockDatabase(db);

        putSQLiteDatabase(name, db);

        return db;
    } catch (java.sql.SQLException e) {
        throw new android.database.SQLException("", e);
    }
}

/**
 * Create a helper object to create, open, and/or manage a database in
 * a specified location.
 * This method always returns very quickly.  The database is not actually
 * created or opened until one of {@link #getWritableDatabase} or
 * {@link #getReadableDatabase} is called.
 *
 * @param context to use to open or create the database
 * @param name of the database file
 * @param storageDirectory to store the database file upon creation; caller must
 * ensure that the specified absolute path is available and can be written to
 * @param factory to use for creating cursor objects, or null for the default
 * @param version number of the database (starting at 1); if the database is older,
 * SQL file(s) contained within the application assets folder will be used to
 * upgrade the database
 */
public SQLiteAssetHelper(Context context, String name, String storageDirectory, CursorFactory factory, int version, DatabaseErrorHandler errorHandler) {
    super(context, name, factory, version, errorHandler);

    if (version < 1) throw new IllegalArgumentException("Version must be >= 1, was " + version);
    if (name == null) throw new IllegalArgumentException("Database name cannot be null");

    mContext = context;
    mName = name;
    mFactory = factory;
    mNewVersion = version;

    mAssetPath = ASSET_DB_PATH + "/" + name;
    if (storageDirectory != null) {
        mDatabasePath = storageDirectory;
    } else {
        mDatabasePath = context.getApplicationInfo().dataDir + "/databases";
    }
    mUpgradePathFormat = ASSET_DB_PATH + "/" + name + "_upgrade_%s-%s.sql";
}

@TargetApi(Build.VERSION_CODES.JELLY_BEAN)
public SQLiteDatabase openOrCreateDatabase(String name, int mode, SQLiteDatabase.CursorFactory factory, DatabaseErrorHandler errorHandler) {
    if (dbMap.containsKey(name)) {
        return dbMap.get(name);
    }
    // 创建数据库
    try {
        String path = staticGetDatabasePath(name).getPath();

        ShadowSQLiteDatabase sdb = new ShadowSQLiteDatabase(path, 0, null);
        SQLiteDatabase       db  = new CGLibProxy().proxy(SQLiteDatabase.class, sdb);

        sdb.setMockDatabase(db);

        putSQLiteDatabase(name, db);

        return db;
    } catch (java.sql.SQLException e) {
        throw new android.database.SQLException("", e);
    }
}

/**
 * Create a helper object to create, open, and/or manage a database in 
 * a specified location.
 * This method always returns very quickly.  The database is not actually
 * created or opened until one of {@link #getWritableDatabase} or
 * {@link #getReadableDatabase} is called.
 *
 * <p>Accepts input param: a concrete instance of {@link DatabaseErrorHandler} to be
 * used to handle corruption when sqlite reports database corruption.</p>
 *
 * @param context          to use to open or create the database
 * @param name             of the database file
 * @param storageDirectory to store the database file upon creation; caller must
 *     ensure that the specified absolute path is available and can be written to  
 * @param factory to use for creating cursor objects, or null for the default
 * @param version number of the database (starting at 1); if the database is older,
 *     SQL file(s) contained within the application assets folder will be used to 
 *     upgrade the database
 * @param errorHandler the {@link DatabaseErrorHandler} to be used when sqlite reports database
 * corruption, or null to use the default error handler.
 */
public SQLiteSDCardHelper(Context context, String name, String storageDirectory, CursorFactory
        factory, int version, DatabaseErrorHandler errorHandler) {
    super(context, name, factory, version);

    if (version < 1) {
        throw new IllegalArgumentException("Version must be >= 1, was " + version);
    }
    if (name == null) {
        throw new IllegalArgumentException("Database name cannot be null");
    }

    mContext = context;
    mName = name;
    mFactory = factory;
    mNewVersion = version;
    mErrorHandler = errorHandler;

    if (storageDirectory != null) {
        mDatabasePath = storageDirectory;
    } else {
        mDatabasePath = context.getApplicationInfo().dataDir + File.separator + DB_PATH;
    }
}

@Override
public  SQLiteDatabase openOrCreateDatabase(String name,
                                                    int mode, SQLiteDatabase.CursorFactory factory,
                                                    @Nullable DatabaseErrorHandler errorHandler)
{
    final String dicDBpath = FlyingFileManager.getMyDicDBFilePath();

    File file = FlyingFileManager.getFile(dicDBpath);

    SQLiteDatabase db =SQLiteDatabase.openOrCreateDatabase(file, null);
    db.setVersion(DicSQLiteOpenHelper.DATABASE_VERSION);

    // SQLiteDatabase result = super.openOrCreateDatabase(name, mode, factory);
    if (Log.isLoggable(DEBUG_CONTEXT, Log.WARN))
    {
        Log.w(DEBUG_CONTEXT,
                "openOrCreateDatabase(" + name + ",,) = " + db.getPath());
    }
    return db;
}

@TargetApi(Build.VERSION_CODES.HONEYCOMB)
@Override
   public SQLiteDatabase openOrCreateDatabase(String name, int mode, CursorFactory factory,
           DatabaseErrorHandler errorHandler) {
    if (!ENBABLE_FILE) {
        return super.openOrCreateDatabase(name, mode, factory, errorHandler);
    }

       File f = validateFilePath(name, true);
       int flags = SQLiteDatabase.CREATE_IF_NECESSARY;
       if ((mode & MODE_ENABLE_WRITE_AHEAD_LOGGING) != 0) {
           flags |= SQLiteDatabase.ENABLE_WRITE_AHEAD_LOGGING;
       }
       SQLiteDatabase db = SQLiteDatabaseCompat.openDatabase(f.getPath(), factory, flags, errorHandler);
       setFilePermissionsFromMode(f.getPath(), mode, 0);
       return db;
   }

/**
 * Create a helper object to create, open, and/or manage a database in
 * a specified location.
 * This method always returns very quickly.  The database is not actually
 * created or opened until one of {@link #getWritableDatabase} or
 * {@link #getReadableDatabase} is called.
 *
 * @param context to use to open or create the database
 * @param name of the database file
 * @param storageDirectory to store the database file upon creation; caller must
 * ensure that the specified absolute path is available and can be written to
 * @param factory to use for creating cursor objects, or null for the default
 * @param version number of the database (starting at 1); if the database is older,
 * SQL file(s) contained within the application assets folder will be used to
 * upgrade the database
 */
public SQLiteAssetHelper(Context context, String name, String storageDirectory, CursorFactory factory, int version, DatabaseErrorHandler errorHandler) {
    super(context, name, factory, version, errorHandler);

    if (version < 1) throw new IllegalArgumentException("Version must be >= 1, was " + version);
    if (name == null) throw new IllegalArgumentException("Database name cannot be null");

    mContext = context;
    mName = name;
    mFactory = factory;
    mNewVersion = version;

    mAssetPath = ASSET_DB_PATH + "/" + name;
    if (storageDirectory != null) {
        mDatabasePath = storageDirectory;
    } else {
        mDatabasePath = context.getApplicationInfo().dataDir + "/databases";
    }
    mUpgradePathFormat = ASSET_DB_PATH + "/" + name + "_upgrade_%s-%s.sql";
}

public SQLHelper(String _dbFilePath, DatabaseErrorHandler errHandler) {
    this.mCurDBFilePath = _dbFilePath;
    try {
        _db = SQLiteDatabase.openDatabase(mCurDBFilePath, null, 0, errHandler);
        isDataBase = true;
    } catch (Exception e) {
        isDataBase = false;
    }
}

public ShadowSQLiteOpenHelper(SQLiteOpenHelper realOpenHelper, Context context, String name, SQLiteDatabase.CursorFactory factory, int version,
                              DatabaseErrorHandler errorHandler) {
    if (version < 1) {
        throw new IllegalArgumentException("Version must be >= 1, was " + version);
    }

    mRealOpenHelper = realOpenHelper;
    mContext = context;
    mName = name;
    mFactory = factory;
    mNewVersion = version;
    mErrorHandler = errorHandler;
}

public SQLiteOpenHelper(Context context, String name, SQLiteDatabase.CursorFactory factory, int version, DatabaseErrorHandler errorHandler) {
    if (version < 1) {
        throw new IllegalArgumentException("Version must be >= 1, was " + version);
    }

    shadowSQLiteOpenHelper = new ShadowSQLiteOpenHelper(this, context, name, factory, version, errorHandler);
}

public ShadowSQLiteOpenHelper(SQLiteOpenHelper realOpenHelper, Context context, String name, SQLiteDatabase.CursorFactory factory, int version,
                              DatabaseErrorHandler errorHandler) {
    if (version < 1) {
        throw new IllegalArgumentException("Version must be >= 1, was " + version);
    }

    mRealOpenHelper = realOpenHelper;
    mContext = context;
    mName = name;
    mFactory = factory;
    mNewVersion = version;
    mErrorHandler = errorHandler;
}

public SQLiteOpenHelper(Context context, String name, SQLiteDatabase.CursorFactory factory, int version, DatabaseErrorHandler errorHandler) {
    if (version < 1) {
        throw new IllegalArgumentException("Version must be >= 1, was " + version);
    }

    shadowSQLiteOpenHelper = new ShadowSQLiteOpenHelper(this, context, name, factory, version, errorHandler);
}

public DeleteOnDowngradeSQLiteOpenHelper(Context context, String name, CursorFactory factory, int version,
        DatabaseErrorHandler errorHandler) {
    super(context, name, factory, version, errorHandler);
    mDatabaseFile = context.getDatabasePath(name);
}

public DBOpenHelper(Context context){
    this(context, DBNAME, null, VERSION, new DatabaseErrorHandler() {
        @Override
        public void onCorruption(SQLiteDatabase dbObj) {
            LogUtil.d("DBError","error occur");
        }
    });
}

public SQLiteDatabase openOrCreateDatabase(final String name, final int mode,
        final SQLiteDatabase.CursorFactory factory, final DatabaseErrorHandler errorHandler) {
    verifyMethodCalledFromDelegate(
            "openOrCreateDatabase(String, Integer, SQLiteDatabase.CursorFactory, DatabaseErrorHandler)");
    return ((CallFun4<SQLiteDatabase, String, Integer, SQLiteDatabase.CursorFactory, DatabaseErrorHandler>) mSuperListeners
            .pop()).call(name, mode, factory, errorHandler);
}

SQLiteDatabase openOrCreateDatabase(
        final CallFun4<SQLiteDatabase, String, Integer, SQLiteDatabase.CursorFactory, DatabaseErrorHandler> superCall,
        final String name, final int mode, final SQLiteDatabase.CursorFactory factory,
        final DatabaseErrorHandler errorHandler) {
    synchronized (mSuperListeners) {
        mSuperListeners.push(superCall);
        return openOrCreateDatabase(name, mode, factory, errorHandler);
    }
}

@Override
public SQLiteDatabase openOrCreateDatabase(String name, int mode, SQLiteDatabase.CursorFactory factory, DatabaseErrorHandler errorHandler) {
    if (!mInPluginApk) {
        return super.openOrCreateDatabase(name, mode, factory, errorHandler);
    } else {
        return that.openOrCreateDatabase(name, mode, factory, errorHandler);
    }
}

Configuration(@NonNull Context context, @Nullable String name,
              @Nullable SQLiteDatabase.CursorFactory factory,
              int version, @Nullable DatabaseErrorHandler errorHandler,
              @NonNull Callback callback) {
    this.context = context;
    this.name = name;
    this.factory = factory;
    this.version = version;
    this.callback = callback;
    this.errorHandler = errorHandler;
}

public DatabaseHelper(Context context, CursorFactory c){
    super(context, DATABASE_NAME, c, DB_VERSION, new DatabaseErrorHandler(){
        public void onCorruption(SQLiteDatabase dbObj) {
            Log.e("DBH.java", "Corruption detected: " + dbObj.getPath());
            Log.e("DBH.java", "Closing Database");
            dbObj.close();
        }
    });
}

public CustomSQLBriteOpenHelper(Context context, String name,
        SQLiteDatabase.CursorFactory factory,
        int version, String migrationTestDir, DatabaseErrorHandler errorHandler) {
    super(context, name, factory, version, errorHandler);
    this.version = version;
    this.context = context;
    this.migrationTestDir = migrationTestDir;
}

@SuppressWarnings("PMD.AvoidSynchronizedAtMethodLevel")
public synchronized static BriteDatabase get(Context context, String name,
        SQLiteDatabase.CursorFactory factory, int version, String migrationDir,
        DatabaseErrorHandler errorHandler) {
    if (briteDatabase == null) {
        CustomSQLBriteOpenHelper sqlBriteOpenHelper = new CustomSQLBriteOpenHelper(context, name, factory,
                version, migrationDir, errorHandler);
        SqlBrite sqlBrite = new SqlBrite.Builder().build();
        briteDatabase = sqlBrite.wrapDatabaseHelper(sqlBriteOpenHelper, Schedulers.io());
    }
    return briteDatabase;
}

@TargetApi(Build.VERSION_CODES.HONEYCOMB)
public BaseSQLiteOpenHelper(
        Context context,
        String name,
        SQLiteDatabase.CursorFactory factory,
        int version,
        DatabaseErrorHandler errorHandler) {

    super(context.getApplicationContext(), name, factory, version, errorHandler);

    this.appContext = context.getApplicationContext();
    this.dbName = name;
}

@TargetApi(Build.VERSION_CODES.HONEYCOMB)
private KeySQLiteOpenHelper(Context context, String name, CursorFactory factory, int version,
        DatabaseErrorHandler errorHandler) {
    super(context, name, factory, version, errorHandler);
    mContext = context;
    mOpenHelperCallbacks = new KeySQLiteOpenHelperCallbacks();
}

@TargetApi(Build.VERSION_CODES.HONEYCOMB)
public DatabaseHelper(
        Context context,
        File dbFullName,
        SQLiteDatabase.CursorFactory factory,
        int version,
        DatabaseErrorHandler errorHandler)
{
    super(
            new DatabaseContext(context, dbFullName.getParentFile()), dbFullName.getName(),
            factory, version, errorHandler);
}

@TargetApi(Build.VERSION_CODES.HONEYCOMB)
@Override
public SQLiteDatabase openOrCreateDatabase(
        String name,
        int mode,
        SQLiteDatabase.CursorFactory factory,
        DatabaseErrorHandler errorHandler)
{
    return SQLiteDatabase.openOrCreateDatabase(
            getDatabasePath(name).getAbsolutePath(), factory, errorHandler);
}

@TargetApi(Build.VERSION_CODES.HONEYCOMB)
public DBHelper(Context context, String name, CursorFactory factory,
        int version, DatabaseErrorHandler errorHandler) {
    super(context, name, factory, version, errorHandler);

    this.context = context;
}

@TargetApi(Build.VERSION_CODES.HONEYCOMB)
public DataDBHelper(Context context, String name, CursorFactory factory,
        int version, DatabaseErrorHandler errorHandler) {
    super(context, name, factory, version, errorHandler);

    this.context = context;
}

@TargetApi(Build.VERSION_CODES.HONEYCOMB)
public MailDBHelper(Context context, String name, CursorFactory factory,
        int version, DatabaseErrorHandler errorHandler) {
    super(context, name, factory, version, errorHandler);

    this.context = context;
}

@TargetApi(Build.VERSION_CODES.HONEYCOMB)
public BCDBHelper(Context context, String name, CursorFactory factory,
        int version, DatabaseErrorHandler errorHandler) {
    super(context, name, factory, version, errorHandler);

    this.context = context;
}

public SQLiteHelper(Context context, String name, SQLiteDatabase.CursorFactory factory, int version, DatabaseErrorHandler errorHandler) {
    super(context, name, factory, version, errorHandler);
}

AssetSQLiteOpenHelper(Context context, String name,
                      SQLiteDatabase.CursorFactory factory, int version,
                      DatabaseErrorHandler errorHandler,
                      Callback callback) {
    mDelegate = createDelegate(context, name, factory, version, errorHandler, callback);
}

OpenHelper(Context context, String name,
           SQLiteDatabase.CursorFactory factory, int version,
           DatabaseErrorHandler errorHandler) {
    super(context, name, null, factory, version, errorHandler);
}

@Override
public SQLiteDatabase openOrCreateDatabase(
        String name, int mode, CursorFactory factory, DatabaseErrorHandler errorHandler) {
    return super.openOrCreateDatabase(
            name, mode | Context.MODE_NO_LOCALIZED_COLLATORS, factory, errorHandler);
}

@Override
public SQLiteDatabase openOrCreateDatabase(String name, int mode, SQLiteDatabase.CursorFactory factory, DatabaseErrorHandler errorHandler) {
    return null;
}

@RequiresApi(HONEYCOMB) @Override public SQLiteDatabase openOrCreateDatabase(String name, int mode, SQLiteDatabase.CursorFactory factory,
        DatabaseErrorHandler errorHandler) {
    return mBase.openOrCreateDatabase(name, mode, factory, errorHandler);
}

public SelectionDbHelper(Context context, String name, SQLiteDatabase.CursorFactory factory, int version, DatabaseErrorHandler errorHandler) {
    super(context, name, factory, version, errorHandler);
}

public SQLData(Context context, String name, SQLiteDatabase.CursorFactory factory, int version, DatabaseErrorHandler errorHandler) {
    super(context, name, factory, version, errorHandler);
}

@Deprecated
private ShadowSQLiteDatabase(String path, int openFlags, CursorFactory cursorFactory, DatabaseErrorHandler errorHandler) {
    mCursorFactory = cursorFactory;
    mErrorHandler = errorHandler != null ? errorHandler : new DefaultDatabaseErrorHandler();
    mConfigurationLocked = new SQLiteDatabaseConfiguration(path, openFlags);
}

/**
 * Equivalent to openDatabase(path, factory, CREATE_IF_NECESSARY, errorHandler).
 */
public static ShadowSQLiteDatabase openOrCreateDatabase(String path, CursorFactory factory, DatabaseErrorHandler errorHandler) {
    return openDatabase(path, factory, CREATE_IF_NECESSARY, errorHandler);
}