services/core/java/com/android/server/timezone/PackageStatusStorage.java - platform/frameworks/base - Gitiles

 /*
  * Copyright (C) 2017 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.server.timezone;

 import android.content.ContentValues;
 import android.content.Context;
 import android.database.Cursor;
 import android.database.sqlite.SQLiteDatabase;
 import android.database.sqlite.SQLiteOpenHelper;
 import android.util.Slog;

 import java.io.File;

 import static com.android.server.timezone.PackageStatus.CHECK_COMPLETED_FAILURE;
 import static com.android.server.timezone.PackageStatus.CHECK_COMPLETED_SUCCESS;
 import static com.android.server.timezone.PackageStatus.CHECK_STARTED;

 /**
  * Storage logic for accessing/mutating the Android system's persistent state related to time zone
  * update checking. There is expected to be a single instance and all methods synchronized on
  * {@code this} for thread safety.
  */
 final class PackageStatusStorage {

     private static final String TAG = "timezone.PackageStatusStorage";

     private static final String DATABASE_NAME = "timezonepackagestatus.db";
     private static final int DATABASE_VERSION = 1;

     /** The table name. It will have a single row with _id == {@link #SINGLETON_ID} */
     private static final String TABLE = "status";
     private static final String COLUMN_ID = "_id";

     /**
      * Column that stores a monotonically increasing lock ID, used to detect concurrent update
      * issues without on-line locks. Incremented on every write.
      */
     private static final String COLUMN_OPTIMISTIC_LOCK_ID = "optimistic_lock_id";

     /**
      * Column that stores the current "check status" of the time zone update application packages.
      */
     private static final String COLUMN_CHECK_STATUS = "check_status";

     /**
      * Column that stores the version of the time zone rules update application being checked / last
      * checked.
      */
     private static final String COLUMN_UPDATE_APP_VERSION = "update_app_package_version";

     /**
      * Column that stores the version of the time zone rules data application being checked / last
      * checked.
      */
     private static final String COLUMN_DATA_APP_VERSION = "data_app_package_version";

     /**
      * The ID of the one row.
      */
     private static final int SINGLETON_ID = 1;

     private static final int UNKNOWN_PACKAGE_VERSION = -1;

     private final DatabaseHelper mDatabaseHelper;

     PackageStatusStorage(Context context) {
         mDatabaseHelper = new DatabaseHelper(context);
     }

     void deleteDatabaseForTests() {
         SQLiteDatabase.deleteDatabase(mDatabaseHelper.getDatabaseFile());
     }

     /**
      * Obtain the current check status of the application packages. Returns {@code null} the first
      * time it is called, or after {@link #resetCheckState()}.
      */
     PackageStatus getPackageStatus() {
         synchronized (this) {
             try {
                 return getPackageStatusInternal();
             } catch (IllegalArgumentException e) {
                 // This means that data exists in the table but it was bad.
                 Slog.e(TAG, "Package status invalid, resetting and retrying", e);

                 // Reset the storage so it is in a good state again.
                 mDatabaseHelper.recoverFromBadData();
                 return getPackageStatusInternal();
             }
         }
     }

     private PackageStatus getPackageStatusInternal() {
         String[] columns = {
                 COLUMN_CHECK_STATUS, COLUMN_UPDATE_APP_VERSION, COLUMN_DATA_APP_VERSION
         };
         Cursor cursor = mDatabaseHelper.getReadableDatabase()
                 .query(TABLE, columns, COLUMN_ID + " = ?",
                         new String[] { Integer.toString(SINGLETON_ID) },
                         null /* groupBy */, null /* having */, null /* orderBy */);
         if (cursor.getCount() != 1) {
             Slog.e(TAG, "Unable to find package status from package status row. Rows returned: "
                     + cursor.getCount());
             return null;
         }
         cursor.moveToFirst();

         // Determine check status.
         if (cursor.isNull(0)) {
             // This is normal the first time getPackageStatus() is called, or after
             // resetCheckState().
             return null;
         }
         int checkStatus = cursor.getInt(0);

         // Determine package version.
         if (cursor.isNull(1) || cursor.isNull(2)) {
             Slog.e(TAG, "Package version information unexpectedly null");
             return null;
         }
         PackageVersions packageVersions = new PackageVersions(cursor.getInt(1), cursor.getInt(2));

         return new PackageStatus(checkStatus, packageVersions);
     }

     /**
      * Generate a new {@link CheckToken} that can be passed to the time zone rules update
      * application.
      */
     CheckToken generateCheckToken(PackageVersions currentInstalledVersions) {
         if (currentInstalledVersions == null) {
             throw new NullPointerException("currentInstalledVersions == null");
         }

         synchronized (this) {
             Integer optimisticLockId = getCurrentOptimisticLockId();
             if (optimisticLockId == null) {
                 Slog.w(TAG, "Unable to find optimistic lock ID from package status row");

                 // Recover.
                 optimisticLockId = mDatabaseHelper.recoverFromBadData();
             }

             int newOptimisticLockId = optimisticLockId + 1;
             boolean statusRowUpdated = writeStatusRow(
                     optimisticLockId, newOptimisticLockId, CHECK_STARTED, currentInstalledVersions);
             if (!statusRowUpdated) {
                 Slog.e(TAG, "Unable to update status to CHECK_STARTED in package status row."
                         + " synchronization failure?");
                 return null;
             }
             return new CheckToken(newOptimisticLockId, currentInstalledVersions);
         }
     }

     /**
      * Reset the current device state to "unknown".
      */
     void resetCheckState() {
         synchronized(this) {
             Integer optimisticLockId = getCurrentOptimisticLockId();
             if (optimisticLockId == null) {
                 Slog.w(TAG, "resetCheckState: Unable to find optimistic lock ID from package"
                         + " status row");
                 // Attempt to recover the storage state.
                 optimisticLockId = mDatabaseHelper.recoverFromBadData();
             }

             int newOptimisticLockId = optimisticLockId + 1;
             if (!writeStatusRow(optimisticLockId, newOptimisticLockId,
                     null /* status */, null /* packageVersions */)) {
                 Slog.e(TAG, "resetCheckState: Unable to reset package status row,"
                         + " newOptimisticLockId=" + newOptimisticLockId);
             }
         }
     }

     /**
      * Update the current device state if possible. Returns true if the update was successful.
      * {@code false} indicates the storage has been changed since the {@link CheckToken} was
      * generated and the update was discarded.
      */
     boolean markChecked(CheckToken checkToken, boolean succeeded) {
         synchronized (this) {
             int optimisticLockId = checkToken.mOptimisticLockId;
             int newOptimisticLockId = optimisticLockId + 1;
             int status = succeeded ? CHECK_COMPLETED_SUCCESS : CHECK_COMPLETED_FAILURE;
             return writeStatusRow(optimisticLockId, newOptimisticLockId,
                     status, checkToken.mPackageVersions);
         }
     }

     // Caller should be synchronized(this)
     private Integer getCurrentOptimisticLockId() {
         final String[] columns = { COLUMN_OPTIMISTIC_LOCK_ID };
         final String querySelection = COLUMN_ID + " = ?";
         final String[] querySelectionArgs = { Integer.toString(SINGLETON_ID) };

         SQLiteDatabase database = mDatabaseHelper.getReadableDatabase();
         try (Cursor cursor = database.query(TABLE, columns, querySelection, querySelectionArgs,
                 null /* groupBy */, null /* having */, null /* orderBy */)) {
             if (cursor.getCount() != 1) {
                 Slog.w(TAG, cursor.getCount() + " rows returned, expected exactly one.");
                 return null;
             }
             cursor.moveToFirst();
             return cursor.getInt(0);
         }
     }

     // Caller should be synchronized(this)
     private boolean writeStatusRow(int optimisticLockId, int newOptimisticLockId, Integer status,
             PackageVersions packageVersions) {
         if ((status == null) != (packageVersions == null)) {
             throw new IllegalArgumentException(
                     "Provide both status and packageVersions, or neither.");
         }

         SQLiteDatabase database = mDatabaseHelper.getWritableDatabase();
         ContentValues values = new ContentValues();
         values.put(COLUMN_OPTIMISTIC_LOCK_ID, newOptimisticLockId);
         if (status == null) {
             values.putNull(COLUMN_CHECK_STATUS);
             values.put(COLUMN_UPDATE_APP_VERSION, UNKNOWN_PACKAGE_VERSION);
             values.put(COLUMN_DATA_APP_VERSION, UNKNOWN_PACKAGE_VERSION);
         } else {
             values.put(COLUMN_CHECK_STATUS, status);
             values.put(COLUMN_UPDATE_APP_VERSION, packageVersions.mUpdateAppVersion);
             values.put(COLUMN_DATA_APP_VERSION, packageVersions.mDataAppVersion);
         }

         String updateSelection = COLUMN_ID + " = ? AND " + COLUMN_OPTIMISTIC_LOCK_ID + " = ?";
         String[] updateSelectionArgs = {
                 Integer.toString(SINGLETON_ID), Integer.toString(optimisticLockId)
         };
         int count = database.update(TABLE, values, updateSelection, updateSelectionArgs);
         if (count > 1) {
             // This has to be because of corruption: there should only ever be one row.
             Slog.w(TAG, "writeStatusRow: " + count + " rows updated, expected exactly one.");
             // Reset the table.
             mDatabaseHelper.recoverFromBadData();
         }

         // 1 is the success case. 0 rows updated means the row is missing or the optimistic lock ID
         // was not as expected, this could be because of corruption but is most likely due to an
         // optimistic lock failure. Callers can decide on a case-by-case basis.
         return count == 1;
     }

     /** Only used during tests to force an empty table. */
     void deleteRowForTests() {
         mDatabaseHelper.getWritableDatabase().delete(TABLE, null, null);
     }

     /** Only used during tests to force a known table state. */
     public void forceCheckStateForTests(int checkStatus, PackageVersions packageVersions) {
         int optimisticLockId = getCurrentOptimisticLockId();
         writeStatusRow(optimisticLockId, optimisticLockId, checkStatus, packageVersions);
     }

     static class DatabaseHelper extends SQLiteOpenHelper {

         private final Context mContext;

         public DatabaseHelper(Context context) {
             super(context, DATABASE_NAME, null, DATABASE_VERSION);
             mContext = context;
         }

         @Override
         public void onCreate(SQLiteDatabase db) {
             db.execSQL("CREATE TABLE " + TABLE + " (" +
                     "_id INTEGER PRIMARY KEY," +
                     COLUMN_OPTIMISTIC_LOCK_ID + " INTEGER NOT NULL," +
                     COLUMN_CHECK_STATUS + " INTEGER," +
                     COLUMN_UPDATE_APP_VERSION + " INTEGER NOT NULL," +
                     COLUMN_DATA_APP_VERSION + " INTEGER NOT NULL" +
                     ");");
             insertInitialRowState(db);
         }

         @Override
         public void onUpgrade(SQLiteDatabase db, int oldVersion, int currentVersion) {
             // no-op: nothing to upgrade
         }

         /** Recover the initial data row state, returning the new current optimistic lock ID */
         int recoverFromBadData() {
             // Delete the table content.
             SQLiteDatabase writableDatabase = getWritableDatabase();
             writableDatabase.delete(TABLE, null /* whereClause */, null /* whereArgs */);

             // Insert the initial content.
             return insertInitialRowState(writableDatabase);
         }

         /** Insert the initial data row, returning the optimistic lock ID */
         private static int insertInitialRowState(SQLiteDatabase db) {
             // Doesn't matter what it is, but we avoid the obvious starting value each time the row
             // is reset to ensure that old tokens are unlikely to work.
            final int initialOptimisticLockId = (int) System.currentTimeMillis();

             // Insert the one row.
             ContentValues values = new ContentValues();
             values.put(COLUMN_ID, SINGLETON_ID);
             values.put(COLUMN_OPTIMISTIC_LOCK_ID, initialOptimisticLockId);
             values.putNull(COLUMN_CHECK_STATUS);
             values.put(COLUMN_UPDATE_APP_VERSION, UNKNOWN_PACKAGE_VERSION);
             values.put(COLUMN_DATA_APP_VERSION, UNKNOWN_PACKAGE_VERSION);
             long id = db.insert(TABLE, null, values);
             if (id == -1) {
                 Slog.w(TAG, "insertInitialRow: could not insert initial row, id=" + id);
                 return -1;
             }
             return initialOptimisticLockId;
         }

         File getDatabaseFile() {
             return mContext.getDatabasePath(DATABASE_NAME);
         }
     }
 }
	/*
	* Copyright (C) 2017 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.server.timezone;

	import android.content.ContentValues;
	import android.content.Context;
	import android.database.Cursor;
	import android.database.sqlite.SQLiteDatabase;
	import android.database.sqlite.SQLiteOpenHelper;
	import android.util.Slog;

	import java.io.File;

	import static com.android.server.timezone.PackageStatus.CHECK_COMPLETED_FAILURE;
	import static com.android.server.timezone.PackageStatus.CHECK_COMPLETED_SUCCESS;
	import static com.android.server.timezone.PackageStatus.CHECK_STARTED;

	/**
	* Storage logic for accessing/mutating the Android system's persistent state related to time zone
	* update checking. There is expected to be a single instance and all methods synchronized on
	* {@code this} for thread safety.
	*/
	final class PackageStatusStorage {

	private static final String TAG = "timezone.PackageStatusStorage";

	private static final String DATABASE_NAME = "timezonepackagestatus.db";
	private static final int DATABASE_VERSION = 1;

	/** The table name. It will have a single row with _id == {@link #SINGLETON_ID} */
	private static final String TABLE = "status";
	private static final String COLUMN_ID = "_id";

	/**
	* Column that stores a monotonically increasing lock ID, used to detect concurrent update
	* issues without on-line locks. Incremented on every write.
	*/
	private static final String COLUMN_OPTIMISTIC_LOCK_ID = "optimistic_lock_id";

	/**
	* Column that stores the current "check status" of the time zone update application packages.
	*/
	private static final String COLUMN_CHECK_STATUS = "check_status";

	/**
	* Column that stores the version of the time zone rules update application being checked / last
	* checked.
	*/
	private static final String COLUMN_UPDATE_APP_VERSION = "update_app_package_version";

	/**
	* Column that stores the version of the time zone rules data application being checked / last
	* checked.
	*/
	private static final String COLUMN_DATA_APP_VERSION = "data_app_package_version";

	/**
	* The ID of the one row.
	*/
	private static final int SINGLETON_ID = 1;

	private static final int UNKNOWN_PACKAGE_VERSION = -1;

	private final DatabaseHelper mDatabaseHelper;

	PackageStatusStorage(Context context) {
	mDatabaseHelper = new DatabaseHelper(context);
	}

	void deleteDatabaseForTests() {
	SQLiteDatabase.deleteDatabase(mDatabaseHelper.getDatabaseFile());
	}

	/**
	* Obtain the current check status of the application packages. Returns {@code null} the first
	* time it is called, or after {@link #resetCheckState()}.
	*/
	PackageStatus getPackageStatus() {
	synchronized (this) {
	try {
	return getPackageStatusInternal();
	} catch (IllegalArgumentException e) {
	// This means that data exists in the table but it was bad.
	Slog.e(TAG, "Package status invalid, resetting and retrying", e);

	// Reset the storage so it is in a good state again.
	mDatabaseHelper.recoverFromBadData();
	return getPackageStatusInternal();
	}
	}
	}

	private PackageStatus getPackageStatusInternal() {
	String[] columns = {
	COLUMN_CHECK_STATUS, COLUMN_UPDATE_APP_VERSION, COLUMN_DATA_APP_VERSION
	};
	Cursor cursor = mDatabaseHelper.getReadableDatabase()
	.query(TABLE, columns, COLUMN_ID + " = ?",
	new String[] { Integer.toString(SINGLETON_ID) },
	null /* groupBy /, null / having /, null / orderBy */);
	if (cursor.getCount() != 1) {
	Slog.e(TAG, "Unable to find package status from package status row. Rows returned: "
	+ cursor.getCount());
	return null;
	}
	cursor.moveToFirst();

	// Determine check status.
	if (cursor.isNull(0)) {
	// This is normal the first time getPackageStatus() is called, or after
	// resetCheckState().
	return null;
	}
	int checkStatus = cursor.getInt(0);

	// Determine package version.
	if (cursor.isNull(1) \|\| cursor.isNull(2)) {
	Slog.e(TAG, "Package version information unexpectedly null");
	return null;
	}
	PackageVersions packageVersions = new PackageVersions(cursor.getInt(1), cursor.getInt(2));

	return new PackageStatus(checkStatus, packageVersions);
	}

	/**
	* Generate a new {@link CheckToken} that can be passed to the time zone rules update
	* application.
	*/
	CheckToken generateCheckToken(PackageVersions currentInstalledVersions) {
	if (currentInstalledVersions == null) {
	throw new NullPointerException("currentInstalledVersions == null");
	}

	synchronized (this) {
	Integer optimisticLockId = getCurrentOptimisticLockId();
	if (optimisticLockId == null) {
	Slog.w(TAG, "Unable to find optimistic lock ID from package status row");

	// Recover.
	optimisticLockId = mDatabaseHelper.recoverFromBadData();
	}

	int newOptimisticLockId = optimisticLockId + 1;
	boolean statusRowUpdated = writeStatusRow(
	optimisticLockId, newOptimisticLockId, CHECK_STARTED, currentInstalledVersions);
	if (!statusRowUpdated) {
	Slog.e(TAG, "Unable to update status to CHECK_STARTED in package status row."
	+ " synchronization failure?");
	return null;
	}
	return new CheckToken(newOptimisticLockId, currentInstalledVersions);
	}
	}

	/**
	* Reset the current device state to "unknown".
	*/
	void resetCheckState() {
	synchronized(this) {
	Integer optimisticLockId = getCurrentOptimisticLockId();
	if (optimisticLockId == null) {
	Slog.w(TAG, "resetCheckState: Unable to find optimistic lock ID from package"
	+ " status row");
	// Attempt to recover the storage state.
	optimisticLockId = mDatabaseHelper.recoverFromBadData();
	}

	int newOptimisticLockId = optimisticLockId + 1;
	if (!writeStatusRow(optimisticLockId, newOptimisticLockId,
	null /* status /, null / packageVersions */)) {
	Slog.e(TAG, "resetCheckState: Unable to reset package status row,"
	+ " newOptimisticLockId=" + newOptimisticLockId);
	}
	}
	}

	/**
	* Update the current device state if possible. Returns true if the update was successful.
	* {@code false} indicates the storage has been changed since the {@link CheckToken} was
	* generated and the update was discarded.
	*/
	boolean markChecked(CheckToken checkToken, boolean succeeded) {
	synchronized (this) {
	int optimisticLockId = checkToken.mOptimisticLockId;
	int newOptimisticLockId = optimisticLockId + 1;
	int status = succeeded ? CHECK_COMPLETED_SUCCESS : CHECK_COMPLETED_FAILURE;
	return writeStatusRow(optimisticLockId, newOptimisticLockId,
	status, checkToken.mPackageVersions);
	}
	}

	// Caller should be synchronized(this)
	private Integer getCurrentOptimisticLockId() {
	final String[] columns = { COLUMN_OPTIMISTIC_LOCK_ID };
	final String querySelection = COLUMN_ID + " = ?";
	final String[] querySelectionArgs = { Integer.toString(SINGLETON_ID) };

	SQLiteDatabase database = mDatabaseHelper.getReadableDatabase();
	try (Cursor cursor = database.query(TABLE, columns, querySelection, querySelectionArgs,
	null /* groupBy /, null / having /, null / orderBy */)) {
	if (cursor.getCount() != 1) {
	Slog.w(TAG, cursor.getCount() + " rows returned, expected exactly one.");
	return null;
	}
	cursor.moveToFirst();
	return cursor.getInt(0);
	}
	}

	// Caller should be synchronized(this)
	private boolean writeStatusRow(int optimisticLockId, int newOptimisticLockId, Integer status,
	PackageVersions packageVersions) {
	if ((status == null) != (packageVersions == null)) {
	throw new IllegalArgumentException(
	"Provide both status and packageVersions, or neither.");
	}

	SQLiteDatabase database = mDatabaseHelper.getWritableDatabase();
	ContentValues values = new ContentValues();
	values.put(COLUMN_OPTIMISTIC_LOCK_ID, newOptimisticLockId);
	if (status == null) {
	values.putNull(COLUMN_CHECK_STATUS);
	values.put(COLUMN_UPDATE_APP_VERSION, UNKNOWN_PACKAGE_VERSION);
	values.put(COLUMN_DATA_APP_VERSION, UNKNOWN_PACKAGE_VERSION);
	} else {
	values.put(COLUMN_CHECK_STATUS, status);
	values.put(COLUMN_UPDATE_APP_VERSION, packageVersions.mUpdateAppVersion);
	values.put(COLUMN_DATA_APP_VERSION, packageVersions.mDataAppVersion);
	}

	String updateSelection = COLUMN_ID + " = ? AND " + COLUMN_OPTIMISTIC_LOCK_ID + " = ?";
	String[] updateSelectionArgs = {
	Integer.toString(SINGLETON_ID), Integer.toString(optimisticLockId)
	};
	int count = database.update(TABLE, values, updateSelection, updateSelectionArgs);
	if (count > 1) {
	// This has to be because of corruption: there should only ever be one row.
	Slog.w(TAG, "writeStatusRow: " + count + " rows updated, expected exactly one.");
	// Reset the table.
	mDatabaseHelper.recoverFromBadData();
	}

	// 1 is the success case. 0 rows updated means the row is missing or the optimistic lock ID
	// was not as expected, this could be because of corruption but is most likely due to an
	// optimistic lock failure. Callers can decide on a case-by-case basis.
	return count == 1;
	}

	/** Only used during tests to force an empty table. */
	void deleteRowForTests() {
	mDatabaseHelper.getWritableDatabase().delete(TABLE, null, null);
	}

	/** Only used during tests to force a known table state. */
	public void forceCheckStateForTests(int checkStatus, PackageVersions packageVersions) {
	int optimisticLockId = getCurrentOptimisticLockId();
	writeStatusRow(optimisticLockId, optimisticLockId, checkStatus, packageVersions);
	}

	static class DatabaseHelper extends SQLiteOpenHelper {

	private final Context mContext;

	public DatabaseHelper(Context context) {
	super(context, DATABASE_NAME, null, DATABASE_VERSION);
	mContext = context;
	}

	@Override
	public void onCreate(SQLiteDatabase db) {
	db.execSQL("CREATE TABLE " + TABLE + " (" +
	"_id INTEGER PRIMARY KEY," +
	COLUMN_OPTIMISTIC_LOCK_ID + " INTEGER NOT NULL," +
	COLUMN_CHECK_STATUS + " INTEGER," +
	COLUMN_UPDATE_APP_VERSION + " INTEGER NOT NULL," +
	COLUMN_DATA_APP_VERSION + " INTEGER NOT NULL" +
	");");
	insertInitialRowState(db);
	}

	@Override
	public void onUpgrade(SQLiteDatabase db, int oldVersion, int currentVersion) {
	// no-op: nothing to upgrade
	}

	/** Recover the initial data row state, returning the new current optimistic lock ID */
	int recoverFromBadData() {
	// Delete the table content.
	SQLiteDatabase writableDatabase = getWritableDatabase();
	writableDatabase.delete(TABLE, null /* whereClause /, null / whereArgs */);

	// Insert the initial content.
	return insertInitialRowState(writableDatabase);
	}

	/** Insert the initial data row, returning the optimistic lock ID */
	private static int insertInitialRowState(SQLiteDatabase db) {
	// Doesn't matter what it is, but we avoid the obvious starting value each time the row
	// is reset to ensure that old tokens are unlikely to work.
	final int initialOptimisticLockId = (int) System.currentTimeMillis();

	// Insert the one row.
	ContentValues values = new ContentValues();
	values.put(COLUMN_ID, SINGLETON_ID);
	values.put(COLUMN_OPTIMISTIC_LOCK_ID, initialOptimisticLockId);
	values.putNull(COLUMN_CHECK_STATUS);
	values.put(COLUMN_UPDATE_APP_VERSION, UNKNOWN_PACKAGE_VERSION);
	values.put(COLUMN_DATA_APP_VERSION, UNKNOWN_PACKAGE_VERSION);
	long id = db.insert(TABLE, null, values);
	if (id == -1) {
	Slog.w(TAG, "insertInitialRow: could not insert initial row, id=" + id);
	return -1;
	}
	return initialOptimisticLockId;
	}

	File getDatabaseFile() {
	return mContext.getDatabasePath(DATABASE_NAME);
	}
	}
	}