src/api-impl: fix up code style, mainly for code imported from AOSP

used the following (plus manual edits):
`clang-format --style="{BasedOnStyle: LLVM, IndentWidth: 8, UseTab: Always, AllowShortIfStatementsOnASingleLine: false, IndentCaseLabels: true, ColumnLimit: 0}`

src/api-impl/android/database/sqlite/DatabaseErrorHandler.java

@@ -1,5 +1,4 @@
 package android.database.sqlite;
 
 class DatabaseErrorHandler {
-
 }

src/api-impl/android/database/sqlite/SQLiteCursorDriver.java

@@ -24,33 +24,33 @@ import android.database.sqlite.SQLiteDatabase.CursorFactory;
  * by the cursors it creates on significant events in their lifetimes.
  */
 public interface SQLiteCursorDriver {
-    /**
-     * Executes the query returning a Cursor over the result set.
-     * 
-     * @param factory The CursorFactory to use when creating the Cursors, or
-     *         null if standard SQLiteCursors should be returned.
-     * @return a Cursor over the result set
-     */
-    Cursor query(CursorFactory factory, String[] bindArgs);
+	/**
+	 * Executes the query returning a Cursor over the result set.
+	 *
+	 * @param factory The CursorFactory to use when creating the Cursors, or
+	 *         null if standard SQLiteCursors should be returned.
+	 * @return a Cursor over the result set
+	 */
+	Cursor query(CursorFactory factory, String[] bindArgs);
 
-    /**
-     * Called by a SQLiteCursor when it is released.
-     */
-    void cursorDeactivated();
+	/**
+	 * Called by a SQLiteCursor when it is released.
+	 */
+	void cursorDeactivated();
 
-    /**
-     * Called by a SQLiteCursor when it is requeried.
-     */
-    void cursorRequeried(Cursor cursor);
+	/**
+	 * Called by a SQLiteCursor when it is requeried.
+	 */
+	void cursorRequeried(Cursor cursor);
 
-    /**
-     * Called by a SQLiteCursor when it it closed to destroy this object as well.
-     */
-    void cursorClosed();
+	/**
+	 * Called by a SQLiteCursor when it it closed to destroy this object as well.
+	 */
+	void cursorClosed();
 
-    /**
-     * Set new bind arguments. These will take effect in cursorRequeried().
-     * @param bindArgs the new arguments
-     */
-    public void setBindArguments(String[] bindArgs);
+	/**
+	 * Set new bind arguments. These will take effect in cursorRequeried().
+	 * @param bindArgs the new arguments
+	 */
+	public void setBindArguments(String[] bindArgs);
 }

src/api-impl/android/database/sqlite/SQLiteDirectCursorDriver.java

@@ -22,62 +22,62 @@ import android.os.CancellationSignal;
 
 /**
  * A cursor driver that uses the given query directly.
- * 
+ *
  * @hide
  */
 public final class SQLiteDirectCursorDriver implements SQLiteCursorDriver {
-    private final SQLiteDatabase mDatabase;
-    private final String mEditTable; 
-    private final String mSql;
-    private final CancellationSignal mCancellationSignal;
-    private SQLiteQuery mQuery;
+	private final SQLiteDatabase mDatabase;
+	private final String mEditTable;
+	private final String mSql;
+	private final CancellationSignal mCancellationSignal;
+	private SQLiteQuery mQuery;
 
-    public SQLiteDirectCursorDriver(SQLiteDatabase db, String sql, String editTable,
-            CancellationSignal cancellationSignal) {
-        mDatabase = db;
-        mEditTable = editTable;
-        mSql = sql;
-        mCancellationSignal = cancellationSignal;
-    }
+	public SQLiteDirectCursorDriver(SQLiteDatabase db, String sql, String editTable,
+					CancellationSignal cancellationSignal) {
+		mDatabase = db;
+		mEditTable = editTable;
+		mSql = sql;
+		mCancellationSignal = cancellationSignal;
+	}
 
-    public Cursor query(CursorFactory factory, String[] selectionArgs) {
-        final SQLiteQuery query = new SQLiteQuery(mDatabase, mSql, mCancellationSignal);
-        final Cursor cursor;
-        try {
-            query.bindAllArgsAsStrings(selectionArgs);
+	public Cursor query(CursorFactory factory, String[] selectionArgs) {
+		final SQLiteQuery query = new SQLiteQuery(mDatabase, mSql, mCancellationSignal);
+		final Cursor cursor;
+		try {
+			query.bindAllArgsAsStrings(selectionArgs);
 
-            if (factory == null) {
-                cursor = new SQLiteCursor(this, mEditTable, query);
-            } else {
-                cursor = factory.newCursor(mDatabase, this, mEditTable, query);
-            }
-        } catch (RuntimeException ex) {
-//            query.close();
-            throw ex;
-        }
+			if (factory == null) {
+				cursor = new SQLiteCursor(this, mEditTable, query);
+			} else {
+				cursor = factory.newCursor(mDatabase, this, mEditTable, query);
+			}
+		} catch (RuntimeException ex) {
+			//            query.close();
+			throw ex;
+		}
 
-        mQuery = query;
-        return cursor;
-    }
+		mQuery = query;
+		return cursor;
+	}
 
-    public void cursorClosed() {
-        // Do nothing
-    }
+	public void cursorClosed() {
+		// Do nothing
+	}
 
-    public void setBindArguments(String[] bindArgs) {
-        mQuery.bindAllArgsAsStrings(bindArgs);
-    }
+	public void setBindArguments(String[] bindArgs) {
+		mQuery.bindAllArgsAsStrings(bindArgs);
+	}
 
-    public void cursorDeactivated() {
-        // Do nothing
-    }
+	public void cursorDeactivated() {
+		// Do nothing
+	}
 
-    public void cursorRequeried(Cursor cursor) {
-        // Do nothing
-    }
+	public void cursorRequeried(Cursor cursor) {
+		// Do nothing
+	}
 
-    @Override
-    public String toString() {
-        return "SQLiteDirectCursorDriver: " + mSql;
-    }
+	@Override
+	public String toString() {
+		return "SQLiteDirectCursorDriver: " + mSql;
+	}
 }

src/api-impl/android/database/sqlite/SQLiteException.java

@@ -1,5 +1,4 @@
 package android.database.sqlite;
 
 public class SQLiteException extends Exception {
-
 }

src/api-impl/android/database/sqlite/SQLiteOpenHelper.java

@@ -4,29 +4,30 @@ import android.content.Context;
 import android.database.sqlite.SQLiteDatabase.CursorFactory;
 
 public abstract class SQLiteOpenHelper {
-    public SQLiteOpenHelper(Context context, String name, CursorFactory factory, int version) {
-        this(context, name, factory, version, null);
-    }
+	public SQLiteOpenHelper(Context context, String name, CursorFactory factory, int version) {
+		this(context, name, factory, version, null);
+	}
 
-    public SQLiteOpenHelper(Context context, String name, CursorFactory factory, int version, DatabaseErrorHandler errorHandler) {
-        if (version < 1) throw new IllegalArgumentException("Version must be >= 1, was " + version);
+	public SQLiteOpenHelper(Context context, String name, CursorFactory factory, int version, DatabaseErrorHandler errorHandler) {
+		if (version < 1)
+			throw new IllegalArgumentException("Version must be >= 1, was " + version);
 
-/*        mContext = context;
-        mName = name;
-        mFactory = factory;
-        mNewVersion = version;
-        mErrorHandler = errorHandler;*/
-    }
+		/*        mContext = context;
+			mName = name;
+			mFactory = factory;
+			mNewVersion = version;
+			mErrorHandler = errorHandler;*/
+	}
 
-	public void close () {}
+	public void close() {}
 
-    public SQLiteDatabase getWritableDatabase() {
-        synchronized (this) {
-            return getDatabaseLocked(true);
-        }
-    }
+	public SQLiteDatabase getWritableDatabase() {
+		synchronized (this) {
+			return getDatabaseLocked(true);
+		}
+	}
 
-    private SQLiteDatabase getDatabaseLocked(boolean writable) {
+	private SQLiteDatabase getDatabaseLocked(boolean writable) {
 		return SQLiteDatabase.create(null); // return an empty database, surely the app can handle that
 		/*
         if (mDatabase != null) {

src/api-impl/android/database/sqlite/SQLiteProgram.java

@@ -16,9 +16,8 @@
 
 package android.database.sqlite;
 
-//import android.database.DatabaseUtils;
+// import android.database.DatabaseUtils;
 import android.os.CancellationSignal;
-
 import java.util.Arrays;
 
 class SQLiteSession {}
@@ -30,19 +29,19 @@ class SQLiteSession {}
  * </p>
  */
 public abstract class SQLiteProgram /*extends SQLiteClosable*/ {
-    private static final String[] EMPTY_STRING_ARRAY = new String[0];
+	private static final String[] EMPTY_STRING_ARRAY = new String[0];
 
-    private final SQLiteDatabase mDatabase;
-    private final String mSql;
-    private final boolean mReadOnly = false;
-    private final String[] mColumnNames = {"YYY"};
-    private final int mNumParameters = -1;
-    private final Object[] mBindArgs = {};
+	private final SQLiteDatabase mDatabase;
+	private final String mSql;
+	private final boolean mReadOnly = false;
+	private final String[] mColumnNames = {"YYY"};
+	private final int mNumParameters = -1;
+	private final Object[] mBindArgs = {};
 
-    SQLiteProgram(SQLiteDatabase db, String sql, Object[] bindArgs,
-            CancellationSignal cancellationSignalForPrepare) {
-        mDatabase = db;
-        mSql = sql.trim();
+	SQLiteProgram(SQLiteDatabase db, String sql, Object[] bindArgs,
+		      CancellationSignal cancellationSignalForPrepare) {
+		mDatabase = db;
+		mSql = sql.trim();
 /*
         int n = DatabaseUtils.getSqlStatementType(mSql);
         switch (n) {
@@ -82,139 +81,144 @@ public abstract class SQLiteProgram /*extends SQLiteClosable*/ {
         }
     */}
 
-    final SQLiteDatabase getDatabase() {
-        return mDatabase;
-    }
+final SQLiteDatabase getDatabase() {
+	return mDatabase;
+}
 
-    final String getSql() {
-        return mSql;
-    }
+final String getSql() {
+	return mSql;
+}
 
-    final Object[] getBindArgs() {
-        return mBindArgs;
-    }
+final Object[] getBindArgs() {
+	return mBindArgs;
+}
 
-    final String[] getColumnNames() {
-        return mColumnNames;
-    }
+final String[] getColumnNames() {
+	return mColumnNames;
+}
 
-    /** @hide */
-    protected final SQLiteSession getSession() {
-        return null;/*mDatabase.getThreadSession();*/
-    }
+/**
+ * @hide
+ */
+protected final SQLiteSession getSession() {
+	return null; /*mDatabase.getThreadSession();*/
+}
 
-    /** @hide */
-    protected final int getConnectionFlags() {
-        return -1;/*mDatabase.getThreadDefaultConnectionFlags(mReadOnly);*/
-    }
+/**
+ * @hide
+ */
+protected final int getConnectionFlags() {
+	return -1; /*mDatabase.getThreadDefaultConnectionFlags(mReadOnly);*/
+}
 
-    /** @hide */
-    protected final void onCorruption() {
-//        mDatabase.onCorruption();
-    }
+/**
+ * @hide
+ */
+protected final void onCorruption() {
+	//        mDatabase.onCorruption();
+}
 
-    /**
-     * Unimplemented.
-     * @deprecated This method is deprecated and must not be used.
-     */
-    @Deprecated
-    public final int getUniqueId() {
-        return -1;
-    }
+/**
+ * Unimplemented.
+ * @deprecated This method is deprecated and must not be used.
+ */
+@Deprecated
+public final int getUniqueId() {
+	return -1;
+}
 
-    /**
-     * Bind a NULL value to this statement. The value remains bound until
-     * {@link #clearBindings} is called.
-     *
-     * @param index The 1-based index to the parameter to bind null to
-     */
-    public void bindNull(int index) {
-        bind(index, null);
-    }
+/**
+ * Bind a NULL value to this statement. The value remains bound until
+ * {@link #clearBindings} is called.
+ *
+ * @param index The 1-based index to the parameter to bind null to
+ */
+public void bindNull(int index) {
+	bind(index, null);
+}
 
-    /**
-     * Bind a long value to this statement. The value remains bound until
-     * {@link #clearBindings} is called.
-     *addToBindArgs
-     * @param index The 1-based index to the parameter to bind
-     * @param value The value to bind
-     */
-    public void bindLong(int index, long value) {
-        bind(index, value);
-    }
+/**
+ * Bind a long value to this statement. The value remains bound until
+ * {@link #clearBindings} is called.
+ *addToBindArgs
+ * @param index The 1-based index to the parameter to bind
+ * @param value The value to bind
+ */
+public void bindLong(int index, long value) {
+	bind(index, value);
+}
 
-    /**
-     * Bind a double value to this statement. The value remains bound until
-     * {@link #clearBindings} is called.
-     *
-     * @param index The 1-based index to the parameter to bind
-     * @param value The value to bind
-     */
-    public void bindDouble(int index, double value) {
-        bind(index, value);
-    }
+/**
+ * Bind a double value to this statement. The value remains bound until
+ * {@link #clearBindings} is called.
+ *
+ * @param index The 1-based index to the parameter to bind
+ * @param value The value to bind
+ */
+public void bindDouble(int index, double value) {
+	bind(index, value);
+}
 
-    /**
-     * Bind a String value to this statement. The value remains bound until
-     * {@link #clearBindings} is called.
-     *
-     * @param index The 1-based index to the parameter to bind
-     * @param value The value to bind, must not be null
-     */
-    public void bindString(int index, String value) {
-        if (value == null) {
-            throw new IllegalArgumentException("the bind value at index " + index + " is null");
-        }
-        bind(index, value);
-    }
+/**
+ * Bind a String value to this statement. The value remains bound until
+ * {@link #clearBindings} is called.
+ *
+ * @param index The 1-based index to the parameter to bind
+ * @param value The value to bind, must not be null
+ */
+public void bindString(int index, String value) {
+	if (value == null) {
+		throw new IllegalArgumentException("the bind value at index " + index + " is null");
+	}
+	bind(index, value);
+}
 
-    /**
-     * Bind a byte array value to this statement. The value remains bound until
-     * {@link #clearBindings} is called.
-     *
-     * @param index The 1-based index to the parameter to bind
-     * @param value The value to bind, must not be null
-     */
-    public void bindBlob(int index, byte[] value) {
-        if (value == null) {
-            throw new IllegalArgumentException("the bind value at index " + index + " is null");
-        }
-        bind(index, value);
-    }
+/**
+ * Bind a byte array value to this statement. The value remains bound until
+ * {@link #clearBindings} is called.
+ *
+ * @param index The 1-based index to the parameter to bind
+ * @param value The value to bind, must not be null
+ */
+public void bindBlob(int index, byte[] value) {
+	if (value == null) {
+		throw new IllegalArgumentException("the bind value at index " + index + " is null");
+	}
+	bind(index, value);
+}
 
-    /**
-     * Clears all existing bindings. Unset bindings are treated as NULL.
-     */
-    public void clearBindings() {
-        if (mBindArgs != null) {
-            Arrays.fill(mBindArgs, null);
-        }
-    }
+/**
+ * Clears all existing bindings. Unset bindings are treated as NULL.
+ */
+public void clearBindings() {
+	if (mBindArgs != null) {
+		Arrays.fill(mBindArgs, null);
+	}
+}
 
-    /**
-     * Given an array of String bindArgs, this method binds all of them in one single call.
-     *
-     * @param bindArgs the String array of bind args, none of which must be null.
-     */
-    public void bindAllArgsAsStrings(String[] bindArgs) {
-        if (bindArgs != null) {
-            for (int i = bindArgs.length; i != 0; i--) {
-                bindString(i, bindArgs[i - 1]);
-            }
-        }
-    }
+/**
+ * Given an array of String bindArgs, this method binds all of them in one single call.
+ *
+ * @param bindArgs the String array of bind args, none of which must be null.
+ */
+public void bindAllArgsAsStrings(String[] bindArgs) {
+	if (bindArgs != null) {
+		for (int i = bindArgs.length; i != 0; i--) {
+			bindString(i, bindArgs[i - 1]);
+		}
+	}
+}
 
 //    @Override
-    protected void onAllReferencesReleased() {
-        clearBindings();
-    }
-
-    private void bind(int index, Object value) {
-        if (index < 1 || index > mNumParameters) {
-            throw new IllegalArgumentException("Cannot bind argument at index "
-                    + index + " because the index is out of range.  "
-                    + "The statement has " + mNumParameters + " parameters.");
-        }
-        mBindArgs[index - 1] = value;
-    }
+protected void onAllReferencesReleased() {
+	clearBindings();
+}
+
+private void bind(int index, Object value) {
+	if (index < 1 || index > mNumParameters) {
+		throw new IllegalArgumentException("Cannot bind argument at index " + index + " because the index is out of range.  "
+						   + "The statement has " + mNumParameters + " parameters.");
+	}
+	mBindArgs[index - 1] = value;
+}
 }

src/api-impl/android/database/sqlite/SQLiteQuery.java

@@ -16,9 +16,9 @@
 
 package android.database.sqlite;
 
-//import android.database.CursorWindow;
+// import android.database.CursorWindow;
 import android.os.CancellationSignal;
-//import android.os.OperationCanceledException;
+// import android.os.OperationCanceledException;
 import android.util.Log;
 
 class CursorWindow {}
@@ -31,56 +31,58 @@ class CursorWindow {}
  * </p>
  */
 public final class SQLiteQuery extends SQLiteProgram {
-    private static final String TAG = "SQLiteQuery";
+	private static final String TAG = "SQLiteQuery";
 
-    private final CancellationSignal mCancellationSignal;
+	private final CancellationSignal mCancellationSignal;
 
-    SQLiteQuery(SQLiteDatabase db, String query, CancellationSignal cancellationSignal) {
-        super(db, query, null, cancellationSignal);
+	SQLiteQuery(SQLiteDatabase db, String query, CancellationSignal cancellationSignal) {
+		super(db, query, null, cancellationSignal);
 
-        mCancellationSignal = cancellationSignal;
-    }
+		mCancellationSignal = cancellationSignal;
+	}
 
-    /**
-     * Reads rows into a buffer.
-     *
-     * @param window The window to fill into
-     * @param startPos The start position for filling the window.
-     * @param requiredPos The position of a row that MUST be in the window.
-     * If it won't fit, then the query should discard part of what it filled.
-     * @param countAllRows True to count all rows that the query would
-     * return regardless of whether they fit in the window.
-     * @return Number of rows that were enumerated.  Might not be all rows
-     * unless countAllRows is true.
-     *
-     * @throws SQLiteException if an error occurs.
-     * @throws OperationCanceledException if the operation was canceled.
-     */
-    int fillWindow(CursorWindow window, int startPos, int requiredPos, boolean countAllRows) {/*
-        acquireReference();
-        try {
-            window.acquireReference();
-            try {
-                int numRows = getSession().executeForCursorWindow(getSql(), getBindArgs(),
-                        window, startPos, requiredPos, countAllRows, getConnectionFlags(),
-                        mCancellationSignal);
-                return numRows;
-            } catch (SQLiteDatabaseCorruptException ex) {
-                onCorruption();
-                throw ex;
-            } catch (SQLiteException ex) {
-                Log.e(TAG, "exception: " + ex.getMessage() + "; query: " + getSql());
-                throw ex;
-            } finally {
-                window.releaseReference();
-            }
-        } finally {
-            releaseReference();
-        }
-    */return -1;}
+	/**
+	 * Reads rows into a buffer.
+	 *
+	 * @param window The window to fill into
+	 * @param startPos The start position for filling the window.
+	 * @param requiredPos The position of a row that MUST be in the window.
+	 * If it won't fit, then the query should discard part of what it filled.
+	 * @param countAllRows True to count all rows that the query would
+	 * return regardless of whether they fit in the window.
+	 * @return Number of rows that were enumerated.  Might not be all rows
+	 * unless countAllRows is true.
+	 *
+	 * @throws SQLiteException if an error occurs.
+	 * @throws OperationCanceledException if the operation was canceled.
+	 */
+	int fillWindow(CursorWindow window, int startPos, int requiredPos, boolean countAllRows) { /*
+	     acquireReference();
+	     try {
+		 window.acquireReference();
+		 try {
+		     int numRows = getSession().executeForCursorWindow(getSql(), getBindArgs(),
+			     window, startPos, requiredPos, countAllRows, getConnectionFlags(),
+			     mCancellationSignal);
+		     return numRows;
+		 } catch (SQLiteDatabaseCorruptException ex) {
+		     onCorruption();
+		     throw ex;
+		 } catch (SQLiteException ex) {
+		     Log.e(TAG, "exception: " + ex.getMessage() + "; query: " + getSql());
+		     throw ex;
+		 } finally {
+		     window.releaseReference();
+		 }
+	     } finally {
+		 releaseReference();
+	     }
+	 */
+		return -1;
+	}
 
-    @Override
-    public String toString() {
-        return "SQLiteQuery: "/* + getSql()*/;
-    }
+	@Override
+	public String toString() {
+		return "SQLiteQuery: " /* + getSql()*/;
+	}
 }