src/com/cooliris/picasa/PicasaContentProvider.java - platform/packages/apps/Gallery3D - Git at Google

 /*
  * Copyright (C) 2009 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.cooliris.picasa;

 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;

 import android.accounts.Account;
 import android.accounts.AccountManager;
 import android.content.ContentResolver;
 import android.content.Context;
 import android.content.SyncResult;
 import android.content.pm.ProviderInfo;
 import android.database.Cursor;
 import android.database.sqlite.SQLiteDatabase;
 import android.database.sqlite.SQLiteOpenHelper;
 import android.database.sqlite.SQLiteDatabase.CursorFactory;
 import android.net.Uri;
 import android.util.Log;

 public final class PicasaContentProvider extends TableContentProvider {
     public static final String AUTHORITY = "com.cooliris.picasa.contentprovider";
     public static final Uri BASE_URI = Uri.parse("content://" + AUTHORITY);
     public static final Uri PHOTOS_URI = Uri.withAppendedPath(BASE_URI, "photos");
     public static final Uri ALBUMS_URI = Uri.withAppendedPath(BASE_URI, "albums");

     private static final String TAG = "PicasaContentProvider";
     private static final String[] ID_EDITED_PROJECTION = { "_id", "date_edited" };
     private static final String[] ID_EDITED_INDEX_PROJECTION = { "_id", "date_edited", "display_index" };
     private static final String WHERE_ACCOUNT = "sync_account=?";
     private static final String WHERE_ALBUM_ID = "album_id=?";

     private final PhotoEntry mPhotoInstance = new PhotoEntry();
     private final AlbumEntry mAlbumInstance = new AlbumEntry();
     private SyncContext mSyncContext = null;
     private Account mActiveAccount;

     @Override
     public void attachInfo(Context context, ProviderInfo info) {
         // Initialize the provider and set the database.
         super.attachInfo(context, info);
         setDatabase(new Database(context, Database.DATABASE_NAME));

         // Add mappings for each of the exposed tables.
         addMapping(AUTHORITY, "photos", "vnd.cooliris.picasa.photo", PhotoEntry.SCHEMA);
         addMapping(AUTHORITY, "albums", "vnd.cooliris.picasa.album", AlbumEntry.SCHEMA);

         // Create the sync context.
         try {
             mSyncContext = new SyncContext();
         } catch (Exception e) {
             // The database wasn't created successfully, we create a memory backed database.
             setDatabase(new Database(context, null));
         }
     }

     public static final class Database extends SQLiteOpenHelper {
         public static final String DATABASE_NAME = "picasa.db";
         public static final int DATABASE_VERSION = 83;

         public Database(Context context, String name) {
             super(context, name, null, DATABASE_VERSION);
         }

         @Override
         public void onCreate(SQLiteDatabase db) {
             PhotoEntry.SCHEMA.createTables(db);
             AlbumEntry.SCHEMA.createTables(db);
             UserEntry.SCHEMA.createTables(db);
         }

         @Override
         public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
             // No new versions yet, if we are asked to upgrade we just reset
             // everything.
             PhotoEntry.SCHEMA.dropTables(db);
             AlbumEntry.SCHEMA.dropTables(db);
             UserEntry.SCHEMA.dropTables(db);
             onCreate(db);
         }
     }

     @Override
     public int delete(Uri uri, String selection, String[] selectionArgs) {
         // Ensure that the URI is well-formed. We currently do not allow WHERE
         // clauses.
         List<String> path = uri.getPathSegments();
         if (path.size() != 2 || !uri.getAuthority().equals(AUTHORITY) || selection != null) {
             return 0;
         }

         // Get the sync context.
         SyncContext context = mSyncContext;

         // Determine if the URI refers to an album or photo.
         String type = path.get(0);
         long id = Long.parseLong(path.get(1));
         SQLiteDatabase db = context.db;
         if (type.equals("photos")) {
             // Retrieve the photo from the database to get the edit URI.
             PhotoEntry photo = mPhotoInstance;
             if (PhotoEntry.SCHEMA.queryWithId(db, id, photo)) {
                 // Send a DELETE request to the API.
                 if (context.login(photo.syncAccount)) {
                     if (context.api.deleteEntry(photo.editUri) == PicasaApi.RESULT_OK) {
                         deletePhoto(db, id);
                         context.photosChanged = true;
                         return 1;
                     }
                 }
             }
         } else if (type.equals("albums")) {
             // Retrieve the album from the database to get the edit URI.
             AlbumEntry album = mAlbumInstance;
             if (AlbumEntry.SCHEMA.queryWithId(db, id, album)) {
                 // Send a DELETE request to the API.
                 if (context.login(album.syncAccount)) {
                     if (context.api.deleteEntry(album.editUri) == PicasaApi.RESULT_OK) {
                         deleteAlbum(db, id);
                         context.albumsChanged = true;
                         return 1;
                     }
                 }
             }
         }
         context.finish();
         return 0;
     }

     public void reloadAccounts() {
         mSyncContext.reloadAccounts();
     }

     public void setActiveSyncAccount(Account account) {
         mActiveAccount = account;
     }

     public void syncUsers(SyncResult syncResult) {
         syncUsers(mSyncContext, syncResult);
     }

     public void syncUsersAndAlbums(final boolean syncAlbumPhotos, SyncResult syncResult) {
         SyncContext context = mSyncContext;

         // Synchronize users authenticated on the device.
         UserEntry[] users = syncUsers(context, syncResult);

         // Synchronize albums for each user.
         String activeUsername = null;
         if (mActiveAccount != null) {
             activeUsername = PicasaApi.canonicalizeUsername(mActiveAccount.name);
         }
         boolean didSyncActiveUserName = false;
         for (int i = 0, numUsers = users.length; i != numUsers; ++i) {
             if (activeUsername != null && !context.accounts[i].user.equals(activeUsername))
                 continue;
             if (!ContentResolver.getSyncAutomatically(context.accounts[i].account, AUTHORITY))
                 continue;
             didSyncActiveUserName = true;
             context.api.setAuth(context.accounts[i]);
             syncUserAlbums(context, users[i], syncResult);
             if (syncAlbumPhotos) {
                 syncUserPhotos(context, users[i].account, syncResult);
             } else {
                 // // Always sync added albums.
                 // for (Long albumId : context.albumsAdded) {
                 // syncAlbumPhotos(albumId, false);
                 // }
             }
         }
         if (!didSyncActiveUserName) {
             ++syncResult.stats.numAuthExceptions;
         }
         context.finish();
     }

     public void syncAlbumPhotos(final long albumId, final boolean forceRefresh, SyncResult syncResult) {
         SyncContext context = mSyncContext;
         AlbumEntry album = new AlbumEntry();
         if (AlbumEntry.SCHEMA.queryWithId(context.db, albumId, album)) {
             if ((album.photosDirty || forceRefresh) && context.login(album.syncAccount)) {
                 if (isSyncEnabled(album.syncAccount, context)) {
                     syncAlbumPhotos(context, album.syncAccount, album, syncResult);
                 }
             }
         }
         context.finish();
     }

     public static boolean isSyncEnabled(String accountName, SyncContext context) {
         if (context.accounts == null) {
             context.reloadAccounts();
         }
         PicasaApi.AuthAccount[] accounts = context.accounts;
         int numAccounts = accounts.length;
         for (int i = 0; i < numAccounts; ++i) {
             PicasaApi.AuthAccount account = accounts[i];
             if (account.user.equals(accountName)) {
                 return ContentResolver.getSyncAutomatically(account.account, AUTHORITY);
             }
         }
         return true;
     }

     private UserEntry[] syncUsers(SyncContext context, SyncResult syncResult) {
         // Get authorized accounts.
         context.reloadAccounts();
         PicasaApi.AuthAccount[] accounts = context.accounts;
         int numUsers = accounts.length;
         UserEntry[] users = new UserEntry[numUsers];

         // Scan existing accounts.
         EntrySchema schema = UserEntry.SCHEMA;
         SQLiteDatabase db = context.db;
         Cursor cursor = schema.queryAll(db);
         if (cursor.moveToFirst()) {
             do {
                 // Read the current account.
                 UserEntry entry = new UserEntry();
                 schema.cursorToObject(cursor, entry);

                 // Find the corresponding account, or delete the row if it does
                 // not exist.
                 int i;
                 for (i = 0; i != numUsers; ++i) {
                     if (accounts[i].user.equals(entry.account)) {
                         users[i] = entry;
                         break;
                     }
                 }
                 if (i == numUsers) {
                     Log.e(TAG, "Deleting user " + entry.account);
                     entry.albumsEtag = null;
                     deleteUser(db, entry.account);
                 }
             } while (cursor.moveToNext());
         } else {
             // Log.i(TAG, "No users in database yet");
         }
         cursor.close();

         // Add new accounts and synchronize user albums if recursive.
         for (int i = 0; i != numUsers; ++i) {
             UserEntry entry = users[i];
             PicasaApi.AuthAccount account = accounts[i];
             if (entry == null) {
                 entry = new UserEntry();
                 entry.account = account.user;
                 users[i] = entry;
                 Log.e(TAG, "Inserting user " + entry.account);
             }
         }
         return users;
     }

     private void syncUserAlbums(final SyncContext context, final UserEntry user, final SyncResult syncResult) {
         // Query existing album entry (id, dateEdited) sorted by ID.
         final SQLiteDatabase db = context.db;
         Cursor cursor = db.query(AlbumEntry.SCHEMA.getTableName(), ID_EDITED_PROJECTION, WHERE_ACCOUNT,
                 new String[] { user.account }, null, null, AlbumEntry.Columns.DATE_EDITED);
         int localCount = cursor.getCount();

         // Build a sorted index with existing entry timestamps.
         final EntryMetadata local[] = new EntryMetadata[localCount];
         for (int i = 0; i != localCount; ++i) {
             cursor.moveToPosition(i); // TODO: throw exception here if returns
                                       // false?
             local[i] = new EntryMetadata(cursor.getLong(0), cursor.getLong(1), 0);
         }
         cursor.close();
         Arrays.sort(local);

         // Merge the truth from the API into the local database.
         final EntrySchema albumSchema = AlbumEntry.SCHEMA;
         final EntryMetadata key = new EntryMetadata();
         final AccountManager accountManager = AccountManager.get(getContext());
         int result = context.api.getAlbums(accountManager, syncResult, user, new GDataParser.EntryHandler() {
             public void handleEntry(Entry entry) {
                 AlbumEntry album = (AlbumEntry) entry;
                 long albumId = album.id;
                 key.id = albumId;
                 int index = Arrays.binarySearch(local, key);
                 EntryMetadata metadata = index >= 0 ? local[index] : null;
                 if (metadata == null || metadata.dateEdited < album.dateEdited) {
                     // Insert / update.
                     Log.i(TAG, "insert / update album " + album.title);
                     album.syncAccount = user.account;
                     album.photosDirty = true;
                     albumSchema.insertOrReplace(db, album);
                     if (metadata == null) {
                         context.albumsAdded.add(albumId);
                     }
                     ++syncResult.stats.numUpdates;
                 } else {
                     // Up-to-date.
                     // Log.i(TAG, "up-to-date album " + album.title);
                 }

                 // Mark item as surviving so it is not deleted.
                 if (metadata != null) {
                     metadata.survived = true;
                 }
             }
         });

         // Return if not modified or on error.
         switch (result) {
         case PicasaApi.RESULT_ERROR:
             ++syncResult.stats.numParseExceptions;
         case PicasaApi.RESULT_NOT_MODIFIED:
             return;
         }

         // Update the user entry with the new ETag.
         UserEntry.SCHEMA.insertOrReplace(db, user);

         // Delete all entries not present in the API response.
         for (int i = 0; i != localCount; ++i) {
             EntryMetadata metadata = local[i];
             if (!metadata.survived) {
                 deleteAlbum(db, metadata.id);
                 ++syncResult.stats.numDeletes;
                 Log.i(TAG, "delete album " + metadata.id);
             }
         }

         // Note that albums changed.
         context.albumsChanged = true;
     }

     private void syncUserPhotos(SyncContext context, String account, SyncResult syncResult) {
         // Synchronize albums with out-of-date photos.
         SQLiteDatabase db = context.db;
         Cursor cursor = db.query(AlbumEntry.SCHEMA.getTableName(), Entry.ID_PROJECTION, "sync_account=? AND photos_dirty=1",
                 new String[] { account }, null, null, null);
         AlbumEntry album = new AlbumEntry();
         for (int i = 0, count = cursor.getCount(); i != count; ++i) {
             cursor.moveToPosition(i);
             if (AlbumEntry.SCHEMA.queryWithId(db, cursor.getLong(0), album)) {
                 syncAlbumPhotos(context, account, album, syncResult);
             }

             // Abort if interrupted.
             if (Thread.interrupted()) {
                 ++syncResult.stats.numIoExceptions;
                 Log.e(TAG, "syncUserPhotos interrupted");
             }
         }
         cursor.close();
     }

     private void syncAlbumPhotos(SyncContext context, final String account, AlbumEntry album, final SyncResult syncResult) {
         Log.i(TAG, "Syncing Picasa album: " + album.title);
         // Query existing album entry (id, dateEdited) sorted by ID.
         final SQLiteDatabase db = context.db;
         long albumId = album.id;
         String[] albumIdArgs = { Long.toString(albumId) };
         Cursor cursor = db.query(PhotoEntry.SCHEMA.getTableName(), ID_EDITED_INDEX_PROJECTION, WHERE_ALBUM_ID, albumIdArgs, null,
                 null, "date_edited");
         int localCount = cursor.getCount();

         // Build a sorted index with existing entry timestamps and display
         // indexes.
         final EntryMetadata local[] = new EntryMetadata[localCount];
         final EntryMetadata key = new EntryMetadata();
         for (int i = 0; i != localCount; ++i) {
             cursor.moveToPosition(i); // TODO: throw exception here if returns
                                       // false?
             local[i] = new EntryMetadata(cursor.getLong(0), cursor.getLong(1), cursor.getInt(2));
         }
         cursor.close();
         Arrays.sort(local);

         // Merge the truth from the API into the local database.
         final EntrySchema photoSchema = PhotoEntry.SCHEMA;
         final int[] displayIndex = { 0 };
         final AccountManager accountManager = AccountManager.get(getContext());
         int result = context.api.getAlbumPhotos(accountManager, syncResult, album, new GDataParser.EntryHandler() {
             public void handleEntry(Entry entry) {
                 PhotoEntry photo = (PhotoEntry) entry;
                 long photoId = photo.id;
                 int newDisplayIndex = displayIndex[0];
                 key.id = photoId;
                 int index = Arrays.binarySearch(local, key);
                 EntryMetadata metadata = index >= 0 ? local[index] : null;
                 if (metadata == null || metadata.dateEdited < photo.dateEdited || metadata.displayIndex != newDisplayIndex) {

                     // Insert / update.
                     // Log.i(TAG, "insert / update photo " + photo.title);
                     photo.syncAccount = account;
                     photo.displayIndex = newDisplayIndex;
                     photoSchema.insertOrReplace(db, photo);
                     ++syncResult.stats.numUpdates;
                 } else {
                     // Up-to-date.
                     // Log.i(TAG, "up-to-date photo " + photo.title);
                 }

                 // Mark item as surviving so it is not deleted.
                 if (metadata != null) {
                     metadata.survived = true;
                 }

                 // Increment the display index.
                 displayIndex[0] = newDisplayIndex + 1;
             }
         });

         // Return if not modified or on error.
         switch (result) {
         case PicasaApi.RESULT_ERROR:
             ++syncResult.stats.numParseExceptions;
             Log.e(TAG, "syncAlbumPhotos error");
         case PicasaApi.RESULT_NOT_MODIFIED:
             // Log.e(TAG, "result not modified");
             return;
         }

         // Delete all entries not present in the API response.
         for (int i = 0; i != localCount; ++i) {
             EntryMetadata metadata = local[i];
             if (!metadata.survived) {
                 deletePhoto(db, metadata.id);
                 ++syncResult.stats.numDeletes;
                 // Log.i(TAG, "delete photo " + metadata.id);
             }
         }

         // Mark album as no longer dirty and store the new ETag.
         album.photosDirty = false;
         AlbumEntry.SCHEMA.insertOrReplace(db, album);
         // Log.i(TAG, "Clearing dirty bit on album " + albumId);

         // Mark that photos changed.
         // context.photosChanged = true;
         getContext().getContentResolver().notifyChange(ALBUMS_URI, null, false);
         getContext().getContentResolver().notifyChange(PHOTOS_URI, null, false);
     }

     private void deleteUser(SQLiteDatabase db, String account) {
         Log.w(TAG, "deleteUser(" + account + ")");

         // Select albums owned by the user.
         String albumTableName = AlbumEntry.SCHEMA.getTableName();
         String[] whereArgs = { account };
         Cursor cursor = db.query(AlbumEntry.SCHEMA.getTableName(), Entry.ID_PROJECTION, WHERE_ACCOUNT, whereArgs, null, null, null);

         // Delete contained photos for each album.
         if (cursor.moveToFirst()) {
             do {
                 deleteAlbumPhotos(db, cursor.getLong(0));
             } while (cursor.moveToNext());
         }
         cursor.close();

         // Delete all albums.
         db.delete(albumTableName, WHERE_ACCOUNT, whereArgs);

         // Delete the user entry.
         db.delete(UserEntry.SCHEMA.getTableName(), "account=?", whereArgs);
     }

     private void deleteAlbum(SQLiteDatabase db, long albumId) {
         // Delete contained photos.
         deleteAlbumPhotos(db, albumId);

         // Delete the album.
         AlbumEntry.SCHEMA.deleteWithId(db, albumId);
     }

     private void deleteAlbumPhotos(SQLiteDatabase db, long albumId) {
         Log.v(TAG, "deleteAlbumPhotos(" + albumId + ")");
         String photoTableName = PhotoEntry.SCHEMA.getTableName();
         String[] whereArgs = { Long.toString(albumId) };
         Cursor cursor = db.query(photoTableName, Entry.ID_PROJECTION, WHERE_ALBUM_ID, whereArgs, null, null, null);

         // Delete cache entry for each photo.
         if (cursor.moveToFirst()) {
             do {
                 deletePhotoCache(cursor.getLong(0));
             } while (cursor.moveToNext());
         }
         cursor.close();

         // Delete all photos.
         db.delete(photoTableName, WHERE_ALBUM_ID, whereArgs);
     }

     private void deletePhoto(SQLiteDatabase db, long photoId) {
         PhotoEntry.SCHEMA.deleteWithId(db, photoId);
         deletePhotoCache(photoId);
     }

     private void deletePhotoCache(long photoId) {
         // TODO: implement it.
     }

     private final class SyncContext {
         // List of all authenticated user accounts.
         public PicasaApi.AuthAccount[] accounts;

         // A connection to the Picasa API for a specific user account. Initially
         // null.
         public PicasaApi api = new PicasaApi(getContext().getContentResolver());

         // A handle to the Picasa databse.
         public SQLiteDatabase db;

         // List of album IDs that were added during the sync.
         public final ArrayList<Long> albumsAdded = new ArrayList<Long>();

         // Set to true if albums were changed.
         public boolean albumsChanged = false;

         // Set to true if photos were changed.
         public boolean photosChanged = false;

         public SyncContext() {
             db = mDatabase.getWritableDatabase();
         }

         public void reloadAccounts() {
             accounts = PicasaApi.getAuthenticatedAccounts(getContext());
         }

         public void finish() {
             // Send notifications if needed and reset state.
             ContentResolver cr = getContext().getContentResolver();
             if (albumsChanged) {
                 cr.notifyChange(ALBUMS_URI, null, false);
             }
             if (photosChanged) {
                 cr.notifyChange(PHOTOS_URI, null, false);
             }
             albumsChanged = false;
             photosChanged = false;
         }

         public boolean login(String user) {
             if (accounts == null) {
                 reloadAccounts();
             }
             final PicasaApi.AuthAccount[] authAccounts = accounts;
             for (PicasaApi.AuthAccount auth : authAccounts) {
                 if (auth.user.equals(user)) {
                     api.setAuth(auth);
                     return true;
                 }
             }
             return false;
         }
     }

     /**
      * Minimal metadata gathered during sync.
      */
     private static final class EntryMetadata implements Comparable<EntryMetadata> {
         public long id;
         public long dateEdited;
         public int displayIndex;
         public boolean survived = false;

         public EntryMetadata() {
         }

         public EntryMetadata(long id, long dateEdited, int displayIndex) {
             this.id = id;
             this.dateEdited = dateEdited;
             this.displayIndex = displayIndex;
         }

         public int compareTo(EntryMetadata other) {
             return Long.signum(id - other.id);
         }

     }
 }
	/*
	* Copyright (C) 2009 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.cooliris.picasa;

	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.List;

	import android.accounts.Account;
	import android.accounts.AccountManager;
	import android.content.ContentResolver;
	import android.content.Context;
	import android.content.SyncResult;
	import android.content.pm.ProviderInfo;
	import android.database.Cursor;
	import android.database.sqlite.SQLiteDatabase;
	import android.database.sqlite.SQLiteOpenHelper;
	import android.database.sqlite.SQLiteDatabase.CursorFactory;
	import android.net.Uri;
	import android.util.Log;

	public final class PicasaContentProvider extends TableContentProvider {
	public static final String AUTHORITY = "com.cooliris.picasa.contentprovider";
	public static final Uri BASE_URI = Uri.parse("content://" + AUTHORITY);
	public static final Uri PHOTOS_URI = Uri.withAppendedPath(BASE_URI, "photos");
	public static final Uri ALBUMS_URI = Uri.withAppendedPath(BASE_URI, "albums");

	private static final String TAG = "PicasaContentProvider";
	private static final String[] ID_EDITED_PROJECTION = { "_id", "date_edited" };
	private static final String[] ID_EDITED_INDEX_PROJECTION = { "_id", "date_edited", "display_index" };
	private static final String WHERE_ACCOUNT = "sync_account=?";
	private static final String WHERE_ALBUM_ID = "album_id=?";

	private final PhotoEntry mPhotoInstance = new PhotoEntry();
	private final AlbumEntry mAlbumInstance = new AlbumEntry();
	private SyncContext mSyncContext = null;
	private Account mActiveAccount;

	@Override
	public void attachInfo(Context context, ProviderInfo info) {
	// Initialize the provider and set the database.
	super.attachInfo(context, info);
	setDatabase(new Database(context, Database.DATABASE_NAME));

	// Add mappings for each of the exposed tables.
	addMapping(AUTHORITY, "photos", "vnd.cooliris.picasa.photo", PhotoEntry.SCHEMA);
	addMapping(AUTHORITY, "albums", "vnd.cooliris.picasa.album", AlbumEntry.SCHEMA);

	// Create the sync context.
	try {
	mSyncContext = new SyncContext();
	} catch (Exception e) {
	// The database wasn't created successfully, we create a memory backed database.
	setDatabase(new Database(context, null));
	}
	}

	public static final class Database extends SQLiteOpenHelper {
	public static final String DATABASE_NAME = "picasa.db";
	public static final int DATABASE_VERSION = 83;

	public Database(Context context, String name) {
	super(context, name, null, DATABASE_VERSION);
	}

	@Override
	public void onCreate(SQLiteDatabase db) {
	PhotoEntry.SCHEMA.createTables(db);
	AlbumEntry.SCHEMA.createTables(db);
	UserEntry.SCHEMA.createTables(db);
	}

	@Override
	public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
	// No new versions yet, if we are asked to upgrade we just reset
	// everything.
	PhotoEntry.SCHEMA.dropTables(db);
	AlbumEntry.SCHEMA.dropTables(db);
	UserEntry.SCHEMA.dropTables(db);
	onCreate(db);
	}
	}

	@Override
	public int delete(Uri uri, String selection, String[] selectionArgs) {
	// Ensure that the URI is well-formed. We currently do not allow WHERE
	// clauses.
	List<String> path = uri.getPathSegments();
	if (path.size() != 2 \|\| !uri.getAuthority().equals(AUTHORITY) \|\| selection != null) {
	return 0;
	}

	// Get the sync context.
	SyncContext context = mSyncContext;

	// Determine if the URI refers to an album or photo.
	String type = path.get(0);
	long id = Long.parseLong(path.get(1));
	SQLiteDatabase db = context.db;
	if (type.equals("photos")) {
	// Retrieve the photo from the database to get the edit URI.
	PhotoEntry photo = mPhotoInstance;
	if (PhotoEntry.SCHEMA.queryWithId(db, id, photo)) {
	// Send a DELETE request to the API.
	if (context.login(photo.syncAccount)) {
	if (context.api.deleteEntry(photo.editUri) == PicasaApi.RESULT_OK) {
	deletePhoto(db, id);
	context.photosChanged = true;
	return 1;
	}
	}
	}
	} else if (type.equals("albums")) {
	// Retrieve the album from the database to get the edit URI.
	AlbumEntry album = mAlbumInstance;
	if (AlbumEntry.SCHEMA.queryWithId(db, id, album)) {
	// Send a DELETE request to the API.
	if (context.login(album.syncAccount)) {
	if (context.api.deleteEntry(album.editUri) == PicasaApi.RESULT_OK) {
	deleteAlbum(db, id);
	context.albumsChanged = true;
	return 1;
	}
	}
	}
	}
	context.finish();
	return 0;
	}

	public void reloadAccounts() {
	mSyncContext.reloadAccounts();
	}

	public void setActiveSyncAccount(Account account) {
	mActiveAccount = account;
	}

	public void syncUsers(SyncResult syncResult) {
	syncUsers(mSyncContext, syncResult);
	}

	public void syncUsersAndAlbums(final boolean syncAlbumPhotos, SyncResult syncResult) {
	SyncContext context = mSyncContext;

	// Synchronize users authenticated on the device.
	UserEntry[] users = syncUsers(context, syncResult);

	// Synchronize albums for each user.
	String activeUsername = null;
	if (mActiveAccount != null) {
	activeUsername = PicasaApi.canonicalizeUsername(mActiveAccount.name);
	}
	boolean didSyncActiveUserName = false;
	for (int i = 0, numUsers = users.length; i != numUsers; ++i) {
	if (activeUsername != null && !context.accounts[i].user.equals(activeUsername))
	continue;
	if (!ContentResolver.getSyncAutomatically(context.accounts[i].account, AUTHORITY))
	continue;
	didSyncActiveUserName = true;
	context.api.setAuth(context.accounts[i]);
	syncUserAlbums(context, users[i], syncResult);
	if (syncAlbumPhotos) {
	syncUserPhotos(context, users[i].account, syncResult);
	} else {
	// // Always sync added albums.
	// for (Long albumId : context.albumsAdded) {
	// syncAlbumPhotos(albumId, false);
	// }
	}
	}
	if (!didSyncActiveUserName) {
	++syncResult.stats.numAuthExceptions;
	}
	context.finish();
	}

	public void syncAlbumPhotos(final long albumId, final boolean forceRefresh, SyncResult syncResult) {
	SyncContext context = mSyncContext;
	AlbumEntry album = new AlbumEntry();
	if (AlbumEntry.SCHEMA.queryWithId(context.db, albumId, album)) {
	if ((album.photosDirty \|\| forceRefresh) && context.login(album.syncAccount)) {
	if (isSyncEnabled(album.syncAccount, context)) {
	syncAlbumPhotos(context, album.syncAccount, album, syncResult);
	}
	}
	}
	context.finish();
	}

	public static boolean isSyncEnabled(String accountName, SyncContext context) {
	if (context.accounts == null) {
	context.reloadAccounts();
	}
	PicasaApi.AuthAccount[] accounts = context.accounts;
	int numAccounts = accounts.length;
	for (int i = 0; i < numAccounts; ++i) {
	PicasaApi.AuthAccount account = accounts[i];
	if (account.user.equals(accountName)) {
	return ContentResolver.getSyncAutomatically(account.account, AUTHORITY);
	}
	}
	return true;
	}

	private UserEntry[] syncUsers(SyncContext context, SyncResult syncResult) {
	// Get authorized accounts.
	context.reloadAccounts();
	PicasaApi.AuthAccount[] accounts = context.accounts;
	int numUsers = accounts.length;
	UserEntry[] users = new UserEntry[numUsers];

	// Scan existing accounts.
	EntrySchema schema = UserEntry.SCHEMA;
	SQLiteDatabase db = context.db;
	Cursor cursor = schema.queryAll(db);
	if (cursor.moveToFirst()) {
	do {
	// Read the current account.
	UserEntry entry = new UserEntry();
	schema.cursorToObject(cursor, entry);

	// Find the corresponding account, or delete the row if it does
	// not exist.
	int i;
	for (i = 0; i != numUsers; ++i) {
	if (accounts[i].user.equals(entry.account)) {
	users[i] = entry;
	break;
	}
	}
	if (i == numUsers) {
	Log.e(TAG, "Deleting user " + entry.account);
	entry.albumsEtag = null;
	deleteUser(db, entry.account);
	}
	} while (cursor.moveToNext());
	} else {
	// Log.i(TAG, "No users in database yet");
	}
	cursor.close();

	// Add new accounts and synchronize user albums if recursive.
	for (int i = 0; i != numUsers; ++i) {
	UserEntry entry = users[i];
	PicasaApi.AuthAccount account = accounts[i];
	if (entry == null) {
	entry = new UserEntry();
	entry.account = account.user;
	users[i] = entry;
	Log.e(TAG, "Inserting user " + entry.account);
	}
	}
	return users;
	}

	private void syncUserAlbums(final SyncContext context, final UserEntry user, final SyncResult syncResult) {
	// Query existing album entry (id, dateEdited) sorted by ID.
	final SQLiteDatabase db = context.db;
	Cursor cursor = db.query(AlbumEntry.SCHEMA.getTableName(), ID_EDITED_PROJECTION, WHERE_ACCOUNT,
	new String[] { user.account }, null, null, AlbumEntry.Columns.DATE_EDITED);
	int localCount = cursor.getCount();

	// Build a sorted index with existing entry timestamps.
	final EntryMetadata local[] = new EntryMetadata[localCount];
	for (int i = 0; i != localCount; ++i) {
	cursor.moveToPosition(i); // TODO: throw exception here if returns
	// false?
	local[i] = new EntryMetadata(cursor.getLong(0), cursor.getLong(1), 0);
	}
	cursor.close();
	Arrays.sort(local);

	// Merge the truth from the API into the local database.
	final EntrySchema albumSchema = AlbumEntry.SCHEMA;
	final EntryMetadata key = new EntryMetadata();
	final AccountManager accountManager = AccountManager.get(getContext());
	int result = context.api.getAlbums(accountManager, syncResult, user, new GDataParser.EntryHandler() {
	public void handleEntry(Entry entry) {
	AlbumEntry album = (AlbumEntry) entry;
	long albumId = album.id;
	key.id = albumId;
	int index = Arrays.binarySearch(local, key);
	EntryMetadata metadata = index >= 0 ? local[index] : null;
	if (metadata == null \|\| metadata.dateEdited < album.dateEdited) {
	// Insert / update.
	Log.i(TAG, "insert / update album " + album.title);
	album.syncAccount = user.account;
	album.photosDirty = true;
	albumSchema.insertOrReplace(db, album);
	if (metadata == null) {
	context.albumsAdded.add(albumId);
	}
	++syncResult.stats.numUpdates;
	} else {
	// Up-to-date.
	// Log.i(TAG, "up-to-date album " + album.title);
	}

	// Mark item as surviving so it is not deleted.
	if (metadata != null) {
	metadata.survived = true;
	}
	}
	});

	// Return if not modified or on error.
	switch (result) {
	case PicasaApi.RESULT_ERROR:
	++syncResult.stats.numParseExceptions;
	case PicasaApi.RESULT_NOT_MODIFIED:
	return;
	}

	// Update the user entry with the new ETag.
	UserEntry.SCHEMA.insertOrReplace(db, user);

	// Delete all entries not present in the API response.
	for (int i = 0; i != localCount; ++i) {
	EntryMetadata metadata = local[i];
	if (!metadata.survived) {
	deleteAlbum(db, metadata.id);
	++syncResult.stats.numDeletes;
	Log.i(TAG, "delete album " + metadata.id);
	}
	}

	// Note that albums changed.
	context.albumsChanged = true;
	}

	private void syncUserPhotos(SyncContext context, String account, SyncResult syncResult) {
	// Synchronize albums with out-of-date photos.
	SQLiteDatabase db = context.db;
	Cursor cursor = db.query(AlbumEntry.SCHEMA.getTableName(), Entry.ID_PROJECTION, "sync_account=? AND photos_dirty=1",
	new String[] { account }, null, null, null);
	AlbumEntry album = new AlbumEntry();
	for (int i = 0, count = cursor.getCount(); i != count; ++i) {
	cursor.moveToPosition(i);
	if (AlbumEntry.SCHEMA.queryWithId(db, cursor.getLong(0), album)) {
	syncAlbumPhotos(context, account, album, syncResult);
	}

	// Abort if interrupted.
	if (Thread.interrupted()) {
	++syncResult.stats.numIoExceptions;
	Log.e(TAG, "syncUserPhotos interrupted");
	}
	}
	cursor.close();
	}

	private void syncAlbumPhotos(SyncContext context, final String account, AlbumEntry album, final SyncResult syncResult) {
	Log.i(TAG, "Syncing Picasa album: " + album.title);
	// Query existing album entry (id, dateEdited) sorted by ID.
	final SQLiteDatabase db = context.db;
	long albumId = album.id;
	String[] albumIdArgs = { Long.toString(albumId) };
	Cursor cursor = db.query(PhotoEntry.SCHEMA.getTableName(), ID_EDITED_INDEX_PROJECTION, WHERE_ALBUM_ID, albumIdArgs, null,
	null, "date_edited");
	int localCount = cursor.getCount();

	// Build a sorted index with existing entry timestamps and display
	// indexes.
	final EntryMetadata local[] = new EntryMetadata[localCount];
	final EntryMetadata key = new EntryMetadata();
	for (int i = 0; i != localCount; ++i) {
	cursor.moveToPosition(i); // TODO: throw exception here if returns
	// false?
	local[i] = new EntryMetadata(cursor.getLong(0), cursor.getLong(1), cursor.getInt(2));
	}
	cursor.close();
	Arrays.sort(local);

	// Merge the truth from the API into the local database.
	final EntrySchema photoSchema = PhotoEntry.SCHEMA;
	final int[] displayIndex = { 0 };
	final AccountManager accountManager = AccountManager.get(getContext());
	int result = context.api.getAlbumPhotos(accountManager, syncResult, album, new GDataParser.EntryHandler() {
	public void handleEntry(Entry entry) {
	PhotoEntry photo = (PhotoEntry) entry;
	long photoId = photo.id;
	int newDisplayIndex = displayIndex[0];
	key.id = photoId;
	int index = Arrays.binarySearch(local, key);
	EntryMetadata metadata = index >= 0 ? local[index] : null;
	if (metadata == null \|\| metadata.dateEdited < photo.dateEdited \|\| metadata.displayIndex != newDisplayIndex) {

	// Insert / update.
	// Log.i(TAG, "insert / update photo " + photo.title);
	photo.syncAccount = account;
	photo.displayIndex = newDisplayIndex;
	photoSchema.insertOrReplace(db, photo);
	++syncResult.stats.numUpdates;
	} else {
	// Up-to-date.
	// Log.i(TAG, "up-to-date photo " + photo.title);
	}

	// Mark item as surviving so it is not deleted.
	if (metadata != null) {
	metadata.survived = true;
	}

	// Increment the display index.
	displayIndex[0] = newDisplayIndex + 1;
	}
	});

	// Return if not modified or on error.
	switch (result) {
	case PicasaApi.RESULT_ERROR:
	++syncResult.stats.numParseExceptions;
	Log.e(TAG, "syncAlbumPhotos error");
	case PicasaApi.RESULT_NOT_MODIFIED:
	// Log.e(TAG, "result not modified");
	return;
	}

	// Delete all entries not present in the API response.
	for (int i = 0; i != localCount; ++i) {
	EntryMetadata metadata = local[i];
	if (!metadata.survived) {
	deletePhoto(db, metadata.id);
	++syncResult.stats.numDeletes;
	// Log.i(TAG, "delete photo " + metadata.id);
	}
	}

	// Mark album as no longer dirty and store the new ETag.
	album.photosDirty = false;
	AlbumEntry.SCHEMA.insertOrReplace(db, album);
	// Log.i(TAG, "Clearing dirty bit on album " + albumId);

	// Mark that photos changed.
	// context.photosChanged = true;
	getContext().getContentResolver().notifyChange(ALBUMS_URI, null, false);
	getContext().getContentResolver().notifyChange(PHOTOS_URI, null, false);
	}

	private void deleteUser(SQLiteDatabase db, String account) {
	Log.w(TAG, "deleteUser(" + account + ")");

	// Select albums owned by the user.
	String albumTableName = AlbumEntry.SCHEMA.getTableName();
	String[] whereArgs = { account };
	Cursor cursor = db.query(AlbumEntry.SCHEMA.getTableName(), Entry.ID_PROJECTION, WHERE_ACCOUNT, whereArgs, null, null, null);

	// Delete contained photos for each album.
	if (cursor.moveToFirst()) {
	do {
	deleteAlbumPhotos(db, cursor.getLong(0));
	} while (cursor.moveToNext());
	}
	cursor.close();

	// Delete all albums.
	db.delete(albumTableName, WHERE_ACCOUNT, whereArgs);

	// Delete the user entry.
	db.delete(UserEntry.SCHEMA.getTableName(), "account=?", whereArgs);
	}

	private void deleteAlbum(SQLiteDatabase db, long albumId) {
	// Delete contained photos.
	deleteAlbumPhotos(db, albumId);

	// Delete the album.
	AlbumEntry.SCHEMA.deleteWithId(db, albumId);
	}

	private void deleteAlbumPhotos(SQLiteDatabase db, long albumId) {
	Log.v(TAG, "deleteAlbumPhotos(" + albumId + ")");
	String photoTableName = PhotoEntry.SCHEMA.getTableName();
	String[] whereArgs = { Long.toString(albumId) };
	Cursor cursor = db.query(photoTableName, Entry.ID_PROJECTION, WHERE_ALBUM_ID, whereArgs, null, null, null);

	// Delete cache entry for each photo.
	if (cursor.moveToFirst()) {
	do {
	deletePhotoCache(cursor.getLong(0));
	} while (cursor.moveToNext());
	}
	cursor.close();

	// Delete all photos.
	db.delete(photoTableName, WHERE_ALBUM_ID, whereArgs);
	}

	private void deletePhoto(SQLiteDatabase db, long photoId) {
	PhotoEntry.SCHEMA.deleteWithId(db, photoId);
	deletePhotoCache(photoId);
	}

	private void deletePhotoCache(long photoId) {
	// TODO: implement it.
	}

	private final class SyncContext {
	// List of all authenticated user accounts.
	public PicasaApi.AuthAccount[] accounts;

	// A connection to the Picasa API for a specific user account. Initially
	// null.
	public PicasaApi api = new PicasaApi(getContext().getContentResolver());

	// A handle to the Picasa databse.
	public SQLiteDatabase db;

	// List of album IDs that were added during the sync.
	public final ArrayList<Long> albumsAdded = new ArrayList<Long>();

	// Set to true if albums were changed.
	public boolean albumsChanged = false;

	// Set to true if photos were changed.
	public boolean photosChanged = false;

	public SyncContext() {
	db = mDatabase.getWritableDatabase();
	}

	public void reloadAccounts() {
	accounts = PicasaApi.getAuthenticatedAccounts(getContext());
	}

	public void finish() {
	// Send notifications if needed and reset state.
	ContentResolver cr = getContext().getContentResolver();
	if (albumsChanged) {
	cr.notifyChange(ALBUMS_URI, null, false);
	}
	if (photosChanged) {
	cr.notifyChange(PHOTOS_URI, null, false);
	}
	albumsChanged = false;
	photosChanged = false;
	}

	public boolean login(String user) {
	if (accounts == null) {
	reloadAccounts();
	}
	final PicasaApi.AuthAccount[] authAccounts = accounts;
	for (PicasaApi.AuthAccount auth : authAccounts) {
	if (auth.user.equals(user)) {
	api.setAuth(auth);
	return true;
	}
	}
	return false;
	}
	}

	/**
	* Minimal metadata gathered during sync.
	*/
	private static final class EntryMetadata implements Comparable<EntryMetadata> {
	public long id;
	public long dateEdited;
	public int displayIndex;
	public boolean survived = false;

	public EntryMetadata() {
	}

	public EntryMetadata(long id, long dateEdited, int displayIndex) {
	this.id = id;
	this.dateEdited = dateEdited;
	this.displayIndex = displayIndex;
	}

	public int compareTo(EntryMetadata other) {
	return Long.signum(id - other.id);
	}

	}
	}