src/com/cooliris/media/PicasaDataSource.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.media;

 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;

 import android.accounts.Account;
 import android.content.ContentProviderClient;
 import android.content.ContentResolver;
 import android.content.Context;
 import android.database.ContentObserver;
 import android.database.Cursor;
 import android.net.Uri;
 import android.os.Handler;
 import android.os.RemoteException;
 import android.util.Log;

 import com.cooliris.app.App;
 import com.cooliris.picasa.AlbumEntry;
 import com.cooliris.picasa.Entry;
 import com.cooliris.picasa.EntrySchema;
 import com.cooliris.picasa.PhotoEntry;
 import com.cooliris.picasa.PicasaApi;
 import com.cooliris.picasa.PicasaContentProvider;
 import com.cooliris.picasa.PicasaService;

 public final class PicasaDataSource implements DataSource {
     private static final String TAG = "PicasaDataSource";
     public static final DiskCache sThumbnailCache = new DiskCache("picasa-thumbs");
     private static final String DEFAULT_BUCKET_SORT_ORDER = AlbumEntry.Columns.USER + ", " + AlbumEntry.Columns.DATE_PUBLISHED
             + " DESC";

     private ContentProviderClient mProviderClient;
     private final Context mContext;

     public PicasaDataSource(final Context context) {
         mContext = context;
     }

     public static final HashMap<String, Boolean> getAccountStatus(final Context context) {
         final Account[] accounts = PicasaApi.getAccounts(context);
         int numAccounts = accounts.length;
         HashMap<String, Boolean> accountsEnabled = new HashMap<String, Boolean>(numAccounts);
         for (int i = 0; i < numAccounts; ++i) {
             Account account = accounts[i];
             boolean isEnabled = ContentResolver.getSyncAutomatically(account, PicasaContentProvider.AUTHORITY);
             String username = PicasaApi.canonicalizeUsername(account.name);
             accountsEnabled.put(username, new Boolean(isEnabled));
         }
         return accountsEnabled;
     }

     public void loadMediaSets(final MediaFeed feed) {
         // We do this here and not in the constructor to speed application
         // loading time since this method is called in a background thread
         if (mProviderClient == null) {
             mProviderClient = mContext.getContentResolver().acquireContentProviderClient(PicasaContentProvider.AUTHORITY);
         }

         // Ensure that users are up to date. TODO: also listen for accounts
         // changed broadcast.
         PicasaService.requestSync(mContext, PicasaService.TYPE_USERS_ALBUMS, 0);
         loadMediaSetsIntoFeed(feed, true);
     }

     public void shutdown() {
         ;
     }

     public void loadItemsForSet(final MediaFeed feed, final MediaSet parentSet, int rangeStart, int rangeEnd) {
         if (parentSet == null) {
             return;
         } else {
             // Return a list of items within an album.
             addItemsToFeed(feed, parentSet, rangeStart, rangeEnd);
         }
     }

     protected void loadMediaSetsIntoFeed(final MediaFeed feed, boolean sync) {
         final HashMap<String, Boolean> accountsEnabled = getAccountStatus(mContext);
         final ContentProviderClient client = mProviderClient;
         if (client == null)
             return;
         try {
             final EntrySchema albumSchema = AlbumEntry.SCHEMA;
             final Cursor cursor = client.query(PicasaContentProvider.ALBUMS_URI, albumSchema.getProjection(), null, null,
                     DEFAULT_BUCKET_SORT_ORDER);
             final AlbumEntry album = new AlbumEntry();
             MediaSet mediaSet;
             if (cursor.moveToFirst()) {
                 final int numAlbums = cursor.getCount();
                 final ArrayList<MediaSet> picasaSets = new ArrayList<MediaSet>(numAlbums);
                 do {
                     albumSchema.cursorToObject(cursor, album);
                     String userLowerCase = album.syncAccount.toLowerCase();
                     final Boolean accountEnabledObj = accountsEnabled.get(userLowerCase);
                     final boolean accountEnabled = (accountEnabledObj == null) ? false : accountEnabledObj.booleanValue();
                     if (accountEnabled) {
                         mediaSet = feed.getMediaSet(album.id);
                         if (mediaSet == null) {
                             mediaSet = feed.addMediaSet(album.id, this);
                             mediaSet.mName = album.title;
                             mediaSet.mEditUri = album.editUri;
                             mediaSet.generateTitle(true);
                         } else {
                             mediaSet.setNumExpectedItems(album.numPhotos);
                         }
                         mediaSet.mPicasaAlbumId = album.id;
                         mediaSet.mIsLocal = false;
                         mediaSet.mSyncPending = album.photosDirty;
                         picasaSets.add(mediaSet);
                     }
                 } while (cursor.moveToNext());
             }
             cursor.close();
         } catch (RemoteException e) {
             Log.e(TAG, "Error occurred loading albums");
         }
     }

     private void addItemsToFeed(MediaFeed feed, MediaSet set, int start, int end) {
         final ContentProviderClient client = mProviderClient;
         Cursor cursor = null;
         try {
             // Query photos in the album.
             final EntrySchema photosSchema = PhotoProjection.SCHEMA;
             final String whereInAlbum = "album_id = " + Long.toString(set.mId);
             cursor = client.query(PicasaContentProvider.PHOTOS_URI, photosSchema.getProjection(), whereInAlbum, null, null);
             final PhotoProjection photo = new PhotoProjection();
             int count = cursor.getCount();
             if (count < end) {
                 end = count;
             }
             set.setNumExpectedItems(count);
             set.generateTitle(true);
             // Move to the next unread item.
             final int newIndex = start + 1;
             if (newIndex > count || !cursor.move(newIndex)) {
                 end = 0;
                 cursor.close();
                 set.updateNumExpectedItems();
                 set.generateTitle(true);
                 return;
             }
             if (set.mNumItemsLoaded == 0) {
                 photosSchema.cursorToObject(cursor, photo);
                 set.mMinTimestamp = photo.dateTaken;
                 cursor.moveToLast();
                 photosSchema.cursorToObject(cursor, photo);
                 set.mMinTimestamp = photo.dateTaken;
                 cursor.moveToFirst();
             }
             for (int i = 0; i < end; ++i) {
                 photosSchema.cursorToObject(cursor, photo);
                 final MediaItem item = new MediaItem();
                 item.mId = photo.id;
                 item.mEditUri = photo.editUri;
                 item.mMimeType = photo.contentType;
                 item.mDateTakenInMs = photo.dateTaken;
                 item.mLatitude = photo.latitude;
                 item.mLongitude = photo.longitude;
                 item.mThumbnailUri = photo.thumbnailUrl;
                 item.mScreennailUri = photo.screennailUrl;
                 item.mContentUri = photo.contentUrl;
                 item.mCaption = photo.title;
                 item.mWeblink = photo.htmlPageUrl;
                 item.mDescription = photo.summary;
                 item.mFilePath = item.mContentUri;
                 feed.addItemToMediaSet(item, set);
                 if (!cursor.moveToNext()) {
                     break;
                 }
             }
         } catch (Exception e) {
             Log.e(TAG, "Error occurred loading photos for album " + set.mId);
         } finally {
             if (cursor != null) {
                 cursor.close();
             }
         }
     }

     public boolean performOperation(final int operation, final ArrayList<MediaBucket> mediaBuckets, final Object data) {
         try {
             if (operation == MediaFeed.OPERATION_DELETE) {
                 ContentProviderClient client = mProviderClient;
                 for (int i = 0, numBuckets = mediaBuckets.size(); i != numBuckets; ++i) {
                     MediaBucket bucket = mediaBuckets.get(i);
                     ArrayList<MediaItem> items = bucket.mediaItems;
                     if (items == null) {
                         // Delete an album.
                         String albumUri = PicasaContentProvider.ALBUMS_URI + "/" + bucket.mediaSet.mId;
                         client.delete(Uri.parse(albumUri), null, null);
                     } else {
                         // Delete a set of photos.
                         for (int j = 0, numItems = items.size(); j != numItems; ++j) {
                             MediaItem item = items.get(j);
                             if (item != null) {
                                 String itemUri = PicasaContentProvider.PHOTOS_URI + "/" + item.mId;
                                 client.delete(Uri.parse(itemUri), null, null);
                             }
                         }
                     }
                 }
             }
             return true;
         } catch (RemoteException e) {
             return false;
         }
     }

     public DiskCache getThumbnailCache() {
         return sThumbnailCache;
     }

     /**
      * The projection of PhotoEntry needed by the data source.
      */
     private static final class PhotoProjection extends Entry {
         public static final EntrySchema SCHEMA = new EntrySchema(PhotoProjection.class);
         @Column("edit_uri")
         public String editUri;
         @Column("title")
         public String title;
         @Column("summary")
         public String summary;
         @Column("date_taken")
         public long dateTaken;
         @Column("latitude")
         public double latitude;
         @Column("longitude")
         public double longitude;
         @Column("thumbnail_url")
         public String thumbnailUrl;
         @Column("screennail_url")
         public String screennailUrl;
         @Column("content_url")
         public String contentUrl;
         @Column("content_type")
         public String contentType;
         @Column("html_page_url")
         public String htmlPageUrl;
     }

     public String[] getDatabaseUris() {
         return new String[] { PicasaContentProvider.ALBUMS_URI.toString(), PicasaContentProvider.PHOTOS_URI.toString()};
     }

     public void refresh(final MediaFeed feed, final String[] databaseUris) {
         // Depending on what URI changed, we either need to update the mediasets or the mediaitems of a set.
         if (databaseUris != null && databaseUris.length > 0) {
             if (ArrayUtils.contains(databaseUris, PicasaContentProvider.ALBUMS_URI.toString())) {
                 // We need to refresh all mediasets of this datasource type.
                 final ArrayList<MediaSet> mediaSets = feed.getMediaSets();
                 final int numMediaSets = mediaSets.size();
                 for (int i = 0; i < numMediaSets; ++i) {
                     final MediaSet set = mediaSets.get(i);
                     if (set.mDataSource instanceof PicasaDataSource) {
                         set.mDataSource = this;
                         set.refresh();
                     }
                 }
             } else if (ArrayUtils.contains(databaseUris, PicasaContentProvider.PHOTOS_URI.toString())) {
                 // We need to update just the one set that has these photos.
                 // This operation is not yet supported, so we might as well refresh everything.
                 final ArrayList<MediaSet> mediaSets = feed.getMediaSets();
                 final int numMediaSets = mediaSets.size();
                 for (int i = 0; i < numMediaSets; ++i) {
                     final MediaSet set = mediaSets.get(i);
                     if (set.mDataSource instanceof PicasaDataSource) {
                         set.mDataSource = this;
                         set.refresh();
                     }
                 }
             }
         }
     }
 }
	/*
	* 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.media;

	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.HashMap;

	import android.accounts.Account;
	import android.content.ContentProviderClient;
	import android.content.ContentResolver;
	import android.content.Context;
	import android.database.ContentObserver;
	import android.database.Cursor;
	import android.net.Uri;
	import android.os.Handler;
	import android.os.RemoteException;
	import android.util.Log;

	import com.cooliris.app.App;
	import com.cooliris.picasa.AlbumEntry;
	import com.cooliris.picasa.Entry;
	import com.cooliris.picasa.EntrySchema;
	import com.cooliris.picasa.PhotoEntry;
	import com.cooliris.picasa.PicasaApi;
	import com.cooliris.picasa.PicasaContentProvider;
	import com.cooliris.picasa.PicasaService;

	public final class PicasaDataSource implements DataSource {
	private static final String TAG = "PicasaDataSource";
	public static final DiskCache sThumbnailCache = new DiskCache("picasa-thumbs");
	private static final String DEFAULT_BUCKET_SORT_ORDER = AlbumEntry.Columns.USER + ", " + AlbumEntry.Columns.DATE_PUBLISHED
	+ " DESC";

	private ContentProviderClient mProviderClient;
	private final Context mContext;

	public PicasaDataSource(final Context context) {
	mContext = context;
	}

	public static final HashMap<String, Boolean> getAccountStatus(final Context context) {
	final Account[] accounts = PicasaApi.getAccounts(context);
	int numAccounts = accounts.length;
	HashMap<String, Boolean> accountsEnabled = new HashMap<String, Boolean>(numAccounts);
	for (int i = 0; i < numAccounts; ++i) {
	Account account = accounts[i];
	boolean isEnabled = ContentResolver.getSyncAutomatically(account, PicasaContentProvider.AUTHORITY);
	String username = PicasaApi.canonicalizeUsername(account.name);
	accountsEnabled.put(username, new Boolean(isEnabled));
	}
	return accountsEnabled;
	}

	public void loadMediaSets(final MediaFeed feed) {
	// We do this here and not in the constructor to speed application
	// loading time since this method is called in a background thread
	if (mProviderClient == null) {
	mProviderClient = mContext.getContentResolver().acquireContentProviderClient(PicasaContentProvider.AUTHORITY);
	}

	// Ensure that users are up to date. TODO: also listen for accounts
	// changed broadcast.
	PicasaService.requestSync(mContext, PicasaService.TYPE_USERS_ALBUMS, 0);
	loadMediaSetsIntoFeed(feed, true);
	}

	public void shutdown() {
	;
	}

	public void loadItemsForSet(final MediaFeed feed, final MediaSet parentSet, int rangeStart, int rangeEnd) {
	if (parentSet == null) {
	return;
	} else {
	// Return a list of items within an album.
	addItemsToFeed(feed, parentSet, rangeStart, rangeEnd);
	}
	}

	protected void loadMediaSetsIntoFeed(final MediaFeed feed, boolean sync) {
	final HashMap<String, Boolean> accountsEnabled = getAccountStatus(mContext);
	final ContentProviderClient client = mProviderClient;
	if (client == null)
	return;
	try {
	final EntrySchema albumSchema = AlbumEntry.SCHEMA;
	final Cursor cursor = client.query(PicasaContentProvider.ALBUMS_URI, albumSchema.getProjection(), null, null,
	DEFAULT_BUCKET_SORT_ORDER);
	final AlbumEntry album = new AlbumEntry();
	MediaSet mediaSet;
	if (cursor.moveToFirst()) {
	final int numAlbums = cursor.getCount();
	final ArrayList<MediaSet> picasaSets = new ArrayList<MediaSet>(numAlbums);
	do {
	albumSchema.cursorToObject(cursor, album);
	String userLowerCase = album.syncAccount.toLowerCase();
	final Boolean accountEnabledObj = accountsEnabled.get(userLowerCase);
	final boolean accountEnabled = (accountEnabledObj == null) ? false : accountEnabledObj.booleanValue();
	if (accountEnabled) {
	mediaSet = feed.getMediaSet(album.id);
	if (mediaSet == null) {
	mediaSet = feed.addMediaSet(album.id, this);
	mediaSet.mName = album.title;
	mediaSet.mEditUri = album.editUri;
	mediaSet.generateTitle(true);
	} else {
	mediaSet.setNumExpectedItems(album.numPhotos);
	}
	mediaSet.mPicasaAlbumId = album.id;
	mediaSet.mIsLocal = false;
	mediaSet.mSyncPending = album.photosDirty;
	picasaSets.add(mediaSet);
	}
	} while (cursor.moveToNext());
	}
	cursor.close();
	} catch (RemoteException e) {
	Log.e(TAG, "Error occurred loading albums");
	}
	}

	private void addItemsToFeed(MediaFeed feed, MediaSet set, int start, int end) {
	final ContentProviderClient client = mProviderClient;
	Cursor cursor = null;
	try {
	// Query photos in the album.
	final EntrySchema photosSchema = PhotoProjection.SCHEMA;
	final String whereInAlbum = "album_id = " + Long.toString(set.mId);
	cursor = client.query(PicasaContentProvider.PHOTOS_URI, photosSchema.getProjection(), whereInAlbum, null, null);
	final PhotoProjection photo = new PhotoProjection();
	int count = cursor.getCount();
	if (count < end) {
	end = count;
	}
	set.setNumExpectedItems(count);
	set.generateTitle(true);
	// Move to the next unread item.
	final int newIndex = start + 1;
	if (newIndex > count \|\| !cursor.move(newIndex)) {
	end = 0;
	cursor.close();
	set.updateNumExpectedItems();
	set.generateTitle(true);
	return;
	}
	if (set.mNumItemsLoaded == 0) {
	photosSchema.cursorToObject(cursor, photo);
	set.mMinTimestamp = photo.dateTaken;
	cursor.moveToLast();
	photosSchema.cursorToObject(cursor, photo);
	set.mMinTimestamp = photo.dateTaken;
	cursor.moveToFirst();
	}
	for (int i = 0; i < end; ++i) {
	photosSchema.cursorToObject(cursor, photo);
	final MediaItem item = new MediaItem();
	item.mId = photo.id;
	item.mEditUri = photo.editUri;
	item.mMimeType = photo.contentType;
	item.mDateTakenInMs = photo.dateTaken;
	item.mLatitude = photo.latitude;
	item.mLongitude = photo.longitude;
	item.mThumbnailUri = photo.thumbnailUrl;
	item.mScreennailUri = photo.screennailUrl;
	item.mContentUri = photo.contentUrl;
	item.mCaption = photo.title;
	item.mWeblink = photo.htmlPageUrl;
	item.mDescription = photo.summary;
	item.mFilePath = item.mContentUri;
	feed.addItemToMediaSet(item, set);
	if (!cursor.moveToNext()) {
	break;
	}
	}
	} catch (Exception e) {
	Log.e(TAG, "Error occurred loading photos for album " + set.mId);
	} finally {
	if (cursor != null) {
	cursor.close();
	}
	}
	}

	public boolean performOperation(final int operation, final ArrayList<MediaBucket> mediaBuckets, final Object data) {
	try {
	if (operation == MediaFeed.OPERATION_DELETE) {
	ContentProviderClient client = mProviderClient;
	for (int i = 0, numBuckets = mediaBuckets.size(); i != numBuckets; ++i) {
	MediaBucket bucket = mediaBuckets.get(i);
	ArrayList<MediaItem> items = bucket.mediaItems;
	if (items == null) {
	// Delete an album.
	String albumUri = PicasaContentProvider.ALBUMS_URI + "/" + bucket.mediaSet.mId;
	client.delete(Uri.parse(albumUri), null, null);
	} else {
	// Delete a set of photos.
	for (int j = 0, numItems = items.size(); j != numItems; ++j) {
	MediaItem item = items.get(j);
	if (item != null) {
	String itemUri = PicasaContentProvider.PHOTOS_URI + "/" + item.mId;
	client.delete(Uri.parse(itemUri), null, null);
	}
	}
	}
	}
	}
	return true;
	} catch (RemoteException e) {
	return false;
	}
	}

	public DiskCache getThumbnailCache() {
	return sThumbnailCache;
	}

	/**
	* The projection of PhotoEntry needed by the data source.
	*/
	private static final class PhotoProjection extends Entry {
	public static final EntrySchema SCHEMA = new EntrySchema(PhotoProjection.class);
	@Column("edit_uri")
	public String editUri;
	@Column("title")
	public String title;
	@Column("summary")
	public String summary;
	@Column("date_taken")
	public long dateTaken;
	@Column("latitude")
	public double latitude;
	@Column("longitude")
	public double longitude;
	@Column("thumbnail_url")
	public String thumbnailUrl;
	@Column("screennail_url")
	public String screennailUrl;
	@Column("content_url")
	public String contentUrl;
	@Column("content_type")
	public String contentType;
	@Column("html_page_url")
	public String htmlPageUrl;
	}

	public String[] getDatabaseUris() {
	return new String[] { PicasaContentProvider.ALBUMS_URI.toString(), PicasaContentProvider.PHOTOS_URI.toString()};
	}

	public void refresh(final MediaFeed feed, final String[] databaseUris) {
	// Depending on what URI changed, we either need to update the mediasets or the mediaitems of a set.
	if (databaseUris != null && databaseUris.length > 0) {
	if (ArrayUtils.contains(databaseUris, PicasaContentProvider.ALBUMS_URI.toString())) {
	// We need to refresh all mediasets of this datasource type.
	final ArrayList<MediaSet> mediaSets = feed.getMediaSets();
	final int numMediaSets = mediaSets.size();
	for (int i = 0; i < numMediaSets; ++i) {
	final MediaSet set = mediaSets.get(i);
	if (set.mDataSource instanceof PicasaDataSource) {
	set.mDataSource = this;
	set.refresh();
	}
	}
	} else if (ArrayUtils.contains(databaseUris, PicasaContentProvider.PHOTOS_URI.toString())) {
	// We need to update just the one set that has these photos.
	// This operation is not yet supported, so we might as well refresh everything.
	final ArrayList<MediaSet> mediaSets = feed.getMediaSets();
	final int numMediaSets = mediaSets.size();
	for (int i = 0; i < numMediaSets; ++i) {
	final MediaSet set = mediaSets.get(i);
	if (set.mDataSource instanceof PicasaDataSource) {
	set.mDataSource = this;
	set.refresh();
	}
	}
	}
	}
	}
	}