Subversion Repositories SmartDukaan

/**

 * Copyright 2010-present Facebook.

 *

 * 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.facebook.widget;

import android.content.Context;

import android.graphics.Bitmap;

import android.view.LayoutInflater;

import android.view.View;

import android.view.ViewGroup;

import android.view.ViewStub;

import android.widget.*;

import com.facebook.FacebookException;

import com.facebook.android.R;

import com.facebook.internal.ImageDownloader;

import com.facebook.internal.ImageRequest;

import com.facebook.internal.ImageResponse;

import com.facebook.model.GraphObject;

import org.json.JSONObject;

import java.net.URI;

import java.net.URISyntaxException;

import java.text.Collator;

import java.util.*;

class GraphObjectAdapter<T extends GraphObject> extends BaseAdapter implements SectionIndexer {

    private static final int DISPLAY_SECTIONS_THRESHOLD = 1;

    private static final int HEADER_VIEW_TYPE = 0;

    private static final int GRAPH_OBJECT_VIEW_TYPE = 1;

    private static final int ACTIVITY_CIRCLE_VIEW_TYPE = 2;

    private static final int MAX_PREFETCHED_PICTURES = 20;

    private static final String ID = "id";

    private static final String NAME = "name";

    private static final String PICTURE = "picture";

    private final Map<String, ImageRequest> pendingRequests = new HashMap<String, ImageRequest>();

    private final LayoutInflater inflater;

    private List<String> sectionKeys = new ArrayList<String>();

    private Map<String, ArrayList<T>> graphObjectsBySection = new HashMap<String, ArrayList<T>>();

    private Map<String, T> graphObjectsById = new HashMap<String, T>();

    private boolean displaySections;

    private List<String> sortFields;

    private String groupByField;

    private boolean showPicture;

    private boolean showCheckbox;

    private Filter<T> filter;

    private DataNeededListener dataNeededListener;

    private GraphObjectCursor<T> cursor;

    private Context context;

    private Map<String, ImageResponse> prefetchedPictureCache = new HashMap<String, ImageResponse>();

    private ArrayList<String> prefetchedProfilePictureIds = new ArrayList<String>();

    private OnErrorListener onErrorListener;

    public interface DataNeededListener {

        public void onDataNeeded();

    }

    public interface OnErrorListener {

        void onError(GraphObjectAdapter<?> adapter, FacebookException error);

    }

    public static class SectionAndItem<T extends GraphObject> {

        public String sectionKey;

        public T graphObject;

        public enum Type {

            GRAPH_OBJECT,

            SECTION_HEADER,

            ACTIVITY_CIRCLE

        }

        public SectionAndItem(String sectionKey, T graphObject) {

            this.sectionKey = sectionKey;

            this.graphObject = graphObject;

        }

        public Type getType() {

            if (sectionKey == null) {

                return Type.ACTIVITY_CIRCLE;

            } else if (graphObject == null) {

                return Type.SECTION_HEADER;

            } else {

                return Type.GRAPH_OBJECT;

            }

        }

    }

    interface Filter<T> {

        boolean includeItem(T graphObject);

    }

    public GraphObjectAdapter(Context context) {

        this.context = context;

        this.inflater = LayoutInflater.from(context);

    }

    public List<String> getSortFields() {

        return sortFields;

    }

    public void setSortFields(List<String> sortFields) {

        this.sortFields = sortFields;

    }

    public String getGroupByField() {

        return groupByField;

    }

    public void setGroupByField(String groupByField) {

        this.groupByField = groupByField;

    }

    public boolean getShowPicture() {

        return showPicture;

    }

    public void setShowPicture(boolean showPicture) {

        this.showPicture = showPicture;

    }

    public boolean getShowCheckbox() {

        return showCheckbox;

    }

    public void setShowCheckbox(boolean showCheckbox) {

        this.showCheckbox = showCheckbox;

    }

    public DataNeededListener getDataNeededListener() {

        return dataNeededListener;

    }

    public void setDataNeededListener(DataNeededListener dataNeededListener) {

        this.dataNeededListener = dataNeededListener;

    }

    public OnErrorListener getOnErrorListener() {

        return onErrorListener;

    }

    public void setOnErrorListener(OnErrorListener onErrorListener) {

        this.onErrorListener = onErrorListener;

    }

    public GraphObjectCursor<T> getCursor() {

        return cursor;

    }

    public boolean changeCursor(GraphObjectCursor<T> cursor) {

        if (this.cursor == cursor) {

            return false;

        }

        if (this.cursor != null) {

            this.cursor.close();

        }

        this.cursor = cursor;

        rebuildAndNotify();

        return true;

    }

    public void rebuildAndNotify() {

        rebuildSections();

        notifyDataSetChanged();

    }

    public void prioritizeViewRange(int firstVisibleItem, int lastVisibleItem, int prefetchBuffer) {

        if ((lastVisibleItem < firstVisibleItem) || (sectionKeys.size() == 0)) {

            return;

        }

        // We want to prioritize requests for items which are visible but do not have pictures

        // loaded yet. We also want to pre-fetch pictures for items which are not yet visible

        // but are within a buffer on either side of the visible items, on the assumption that

        // they will be visible soon. For these latter items, we'll store the images in memory

        // in the hopes we can immediately populate their image view when needed.

        // Prioritize the requests in reverse order since each call to prioritizeRequest will just

        // move it to the front of the queue. And we want the earliest ones in the range to be at

        // the front of the queue, so all else being equal, the list will appear to populate from

        // the top down.

        for (int i = lastVisibleItem; i >= 0; i--) {

            SectionAndItem<T> sectionAndItem = getSectionAndItem(i);

            if (sectionAndItem.graphObject != null) {

                String id = getIdOfGraphObject(sectionAndItem.graphObject);

                ImageRequest request = pendingRequests.get(id);

                if (request != null) {

                    ImageDownloader.prioritizeRequest(request);

                }

            }

        }

        // For items which are not visible, but within the buffer on either side, we want to

        // fetch those items and store them in a small in-memory cache of bitmaps.

        int start = Math.max(0, firstVisibleItem - prefetchBuffer);

        int end = Math.min(lastVisibleItem + prefetchBuffer, getCount() - 1);

        ArrayList<T> graphObjectsToPrefetchPicturesFor = new ArrayList<T>();

        // Add the IDs before and after the visible range.

        for (int i = start; i < firstVisibleItem; ++i) {

            SectionAndItem<T> sectionAndItem = getSectionAndItem(i);

            if (sectionAndItem.graphObject != null) {

                graphObjectsToPrefetchPicturesFor.add(sectionAndItem.graphObject);

            }

        }

        for (int i = lastVisibleItem + 1; i <= end; ++i) {

            SectionAndItem<T> sectionAndItem = getSectionAndItem(i);

            if (sectionAndItem.graphObject != null) {

                graphObjectsToPrefetchPicturesFor.add(sectionAndItem.graphObject);

            }

        }

        for (T graphObject : graphObjectsToPrefetchPicturesFor) {

            URI uri = getPictureUriOfGraphObject(graphObject);

            final String id = getIdOfGraphObject(graphObject);

            // This URL already have been requested for pre-fetching, but we want to act in an LRU manner, so move

            // it to the end of the list regardless.

            boolean alreadyPrefetching = prefetchedProfilePictureIds.remove(id);

            prefetchedProfilePictureIds.add(id);

            // If we've already requested it for pre-fetching, no need to do so again.

            if (!alreadyPrefetching) {

                downloadProfilePicture(id, uri, null);

            }

        }

    }

    protected String getSectionKeyOfGraphObject(T graphObject) {

        String result = null;

        if (groupByField != null) {

            result = (String) graphObject.getProperty(groupByField);

            if (result != null && result.length() > 0) {

                result = result.substring(0, 1).toUpperCase();

            }

        }

        return (result != null) ? result : "";

    }

    protected CharSequence getTitleOfGraphObject(T graphObject) {

        return (String) graphObject.getProperty(NAME);

    }

    protected CharSequence getSubTitleOfGraphObject(T graphObject) {

        return null;

    }

    protected URI getPictureUriOfGraphObject(T graphObject) {

        String uri = null;

        Object o = graphObject.getProperty(PICTURE);

        if (o instanceof String) {

            uri = (String) o;

        } else if (o instanceof JSONObject) {

            ItemPicture itemPicture = GraphObject.Factory.create((JSONObject) o).cast(ItemPicture.class);

            ItemPictureData data = itemPicture.getData();

            if (data != null) {

                uri = data.getUrl();

            }

        }

        if (uri != null) {

            try {

                return new URI(uri);

            } catch (URISyntaxException e) {

            }

        }

        return null;

    }

    protected View getSectionHeaderView(String sectionHeader, View convertView, ViewGroup parent) {

        TextView result = (TextView) convertView;

        if (result == null) {

            result = (TextView) inflater.inflate(R.layout.com_facebook_picker_list_section_header, null);

        }

        result.setText(sectionHeader);

        return result;

    }

    protected View getGraphObjectView(T graphObject, View convertView, ViewGroup parent) {

        View result = convertView;

        if (result == null) {

            result = createGraphObjectView(graphObject);

        }

        populateGraphObjectView(result, graphObject);

        return result;

    }

    private View getActivityCircleView(View convertView, ViewGroup parent) {

        View result = convertView;

        if (result == null) {

            result = inflater.inflate(R.layout.com_facebook_picker_activity_circle_row, null);

        }

        ProgressBar activityCircle = (ProgressBar) result.findViewById(R.id.com_facebook_picker_row_activity_circle);

        activityCircle.setVisibility(View.VISIBLE);

        return result;

    }

    protected int getGraphObjectRowLayoutId(T graphObject) {

        return R.layout.com_facebook_picker_list_row;

    }

    protected int getDefaultPicture() {

        return R.drawable.com_facebook_profile_default_icon;

    }

    protected View createGraphObjectView(T graphObject) {

        View result = inflater.inflate(getGraphObjectRowLayoutId(graphObject), null);

        ViewStub checkboxStub = (ViewStub) result.findViewById(R.id.com_facebook_picker_checkbox_stub);

        if (checkboxStub != null) {

            if (!getShowCheckbox()) {

                checkboxStub.setVisibility(View.GONE);

            } else {

                CheckBox checkBox = (CheckBox) checkboxStub.inflate();

                updateCheckboxState(checkBox, false);

            }

        }

        ViewStub profilePicStub = (ViewStub) result.findViewById(R.id.com_facebook_picker_profile_pic_stub);

        if (!getShowPicture()) {

            profilePicStub.setVisibility(View.GONE);

        } else {

            ImageView imageView = (ImageView) profilePicStub.inflate();

            imageView.setVisibility(View.VISIBLE);

        }

        return result;

    }

    protected void populateGraphObjectView(View view, T graphObject) {

        String id = getIdOfGraphObject(graphObject);

        view.setTag(id);

        CharSequence title = getTitleOfGraphObject(graphObject);

        TextView titleView = (TextView) view.findViewById(R.id.com_facebook_picker_title);

        if (titleView != null) {

            titleView.setText(title, TextView.BufferType.SPANNABLE);

        }

        CharSequence subtitle = getSubTitleOfGraphObject(graphObject);

        TextView subtitleView = (TextView) view.findViewById(R.id.picker_subtitle);

        if (subtitleView != null) {

            if (subtitle != null) {

                subtitleView.setText(subtitle, TextView.BufferType.SPANNABLE);

                subtitleView.setVisibility(View.VISIBLE);

            } else {

                subtitleView.setVisibility(View.GONE);

            }

        }

        if (getShowCheckbox()) {

            CheckBox checkBox = (CheckBox) view.findViewById(R.id.com_facebook_picker_checkbox);

            updateCheckboxState(checkBox, isGraphObjectSelected(id));

        }

        if (getShowPicture()) {

            URI pictureURI = getPictureUriOfGraphObject(graphObject);

            if (pictureURI != null) {

                ImageView profilePic = (ImageView) view.findViewById(R.id.com_facebook_picker_image);

                // See if we have already pre-fetched this; if not, download it.

                if (prefetchedPictureCache.containsKey(id)) {

                    ImageResponse response = prefetchedPictureCache.get(id);

                    profilePic.setImageBitmap(response.getBitmap());

                    profilePic.setTag(response.getRequest().getImageUri());

                } else {

                    downloadProfilePicture(id, pictureURI, profilePic);

                }

            }

        }

    }

    /**

     * @throws FacebookException if the GraphObject doesn't have an ID.

     */

    String getIdOfGraphObject(T graphObject) {

        if (graphObject.asMap().containsKey(ID)) {

            Object obj = graphObject.getProperty(ID);

            if (obj instanceof String) {

                return (String) obj;

            }

        }

        throw new FacebookException("Received an object without an ID.");

    }

    boolean filterIncludesItem(T graphObject) {

        return filter == null || filter.includeItem(graphObject);

    }

    Filter<T> getFilter() {

        return filter;

    }

    void setFilter(Filter<T> filter) {

        this.filter = filter;

    }

    boolean isGraphObjectSelected(String graphObjectId) {

        return false;

    }

    void updateCheckboxState(CheckBox checkBox, boolean graphObjectSelected) {

        // Default is no-op

    }

    String getPictureFieldSpecifier() {

        // How big is our image?

        View view = createGraphObjectView(null);

        ImageView picture = (ImageView) view.findViewById(R.id.com_facebook_picker_image);

        if (picture == null) {

            return null;

        }

        // Note: these dimensions are in pixels, not dips

        ViewGroup.LayoutParams layoutParams = picture.getLayoutParams();

        return String.format(Locale.US, "picture.height(%d).width(%d)", layoutParams.height, layoutParams.width);

    }

    private boolean shouldShowActivityCircleCell() {

        // We show the "more data" activity circle cell if we have a listener to request more data,

        // we are expecting more data, and we have some data already (i.e., not on a fresh query).

        return (cursor != null) && cursor.areMoreObjectsAvailable() && (dataNeededListener != null) && !isEmpty();

    }

    private void rebuildSections() {

        sectionKeys = new ArrayList<String>();

        graphObjectsBySection = new HashMap<String, ArrayList<T>>();

        graphObjectsById = new HashMap<String, T>();

        displaySections = false;

        if (cursor == null || cursor.getCount() == 0) {

            return;

        }

        int objectsAdded = 0;

        cursor.moveToFirst();

        do {

            T graphObject = cursor.getGraphObject();

            if (!filterIncludesItem(graphObject)) {

                continue;

            }

            objectsAdded++;

            String sectionKeyOfItem = getSectionKeyOfGraphObject(graphObject);

            if (!graphObjectsBySection.containsKey(sectionKeyOfItem)) {

                sectionKeys.add(sectionKeyOfItem);

                graphObjectsBySection.put(sectionKeyOfItem, new ArrayList<T>());

            }

            List<T> section = graphObjectsBySection.get(sectionKeyOfItem);

            section.add(graphObject);

            graphObjectsById.put(getIdOfGraphObject(graphObject), graphObject);

        } while (cursor.moveToNext());

        if (sortFields != null) {

            final Collator collator = Collator.getInstance();

            for (List<T> section : graphObjectsBySection.values()) {

                Collections.sort(section, new Comparator<GraphObject>() {

                    @Override

                    public int compare(GraphObject a, GraphObject b) {

                        return compareGraphObjects(a, b, sortFields, collator);

                    }

                });

            }

        }

        Collections.sort(sectionKeys, Collator.getInstance());

        displaySections = sectionKeys.size() > 1 && objectsAdded > DISPLAY_SECTIONS_THRESHOLD;

    }

    SectionAndItem<T> getSectionAndItem(int position) {

        if (sectionKeys.size() == 0) {

            return null;

        }

        String sectionKey = null;

        T graphObject = null;

        if (!displaySections) {

            sectionKey = sectionKeys.get(0);

            List<T> section = graphObjectsBySection.get(sectionKey);

            if (position >= 0 && position < section.size()) {

                graphObject = graphObjectsBySection.get(sectionKey).get(position);

            } else {

                // We are off the end; we must be adding an activity circle to indicate more data is coming.

                assert dataNeededListener != null && cursor.areMoreObjectsAvailable();

                // We return null for both to indicate this.

                return new SectionAndItem<T>(null, null);

            }

        } else {

            // Count through the sections; the "0" position in each section is the header. We decrement

            // position each time we skip forward a certain number of elements, including the header.

            for (String key : sectionKeys) {

                // Decrement if we skip over the header

                if (position-- == 0) {

                    sectionKey = key;

                    break;

                }

                List<T> section = graphObjectsBySection.get(key);

                if (position < section.size()) {

                    // The position is somewhere in this section. Get the corresponding graph object.

                    sectionKey = key;

                    graphObject = section.get(position);

                    break;

                }

                // Decrement by as many items as we skipped over

                position -= section.size();

            }

        }

        if (sectionKey != null) {

            // Note: graphObject will be null if this represents a section header.

            return new SectionAndItem<T>(sectionKey, graphObject);

        } else {

            throw new IndexOutOfBoundsException("position");

        }

    }

    int getPosition(String sectionKey, T graphObject) {

        int position = 0;

        boolean found = false;

        // First find the section key and increment position one for each header we will render;

        // increment by the size of each section prior to the one we want.

        for (String key : sectionKeys) {

            if (displaySections) {

                position++;

            }

            if (key.equals(sectionKey)) {

                found = true;

                break;

            } else {

                position += graphObjectsBySection.get(key).size();

            }

        }

        if (!found) {

            return -1;

        } else if (graphObject == null) {

            // null represents the header for a section; we counted this header in position earlier,

            // so subtract it back out.

            return position - (displaySections ? 1 : 0);

        }

        // Now find index of this item within that section.

        for (T t : graphObjectsBySection.get(sectionKey)) {

            if (GraphObject.Factory.hasSameId(t, graphObject)) {

                return position;

            }

            position++;

        }

        return -1;

    }

    @Override

    public boolean isEmpty() {

        // We'll never populate sectionKeys unless we have at least one object.

        return sectionKeys.size() == 0;

    }

    @Override

    public int getCount() {

        if (sectionKeys.size() == 0) {

            return 0;

        }

        // If we are not displaying sections, we don't display a header; otherwise, we have one header per item in

        // addition to the actual items.

        int count = (displaySections) ? sectionKeys.size() : 0;

        for (List<T> section : graphObjectsBySection.values()) {

            count += section.size();

        }

        // If we should show a cell with an activity circle indicating more data is coming, add it to the count.

        if (shouldShowActivityCircleCell()) {

            ++count;

        }

        return count;

    }

    @Override

    public boolean areAllItemsEnabled() {

        return displaySections;

    }

    @Override

    public boolean hasStableIds() {

        return true;

    }

    @Override

    public boolean isEnabled(int position) {

        SectionAndItem<T> sectionAndItem = getSectionAndItem(position);

        return sectionAndItem.getType() == SectionAndItem.Type.GRAPH_OBJECT;

    }

    @Override

    public Object getItem(int position) {

        SectionAndItem<T> sectionAndItem = getSectionAndItem(position);

        return (sectionAndItem.getType() == SectionAndItem.Type.GRAPH_OBJECT) ? sectionAndItem.graphObject : null;

    }

    @Override

    public long getItemId(int position) {

        // We assume IDs that can be converted to longs. If this is not the case for certain types of

        // GraphObjects, subclasses should override this to return, e.g., position, and override hasStableIds

        // to return false.

        SectionAndItem<T> sectionAndItem = getSectionAndItem(position);

        if (sectionAndItem != null && sectionAndItem.graphObject != null) {

            String id = getIdOfGraphObject(sectionAndItem.graphObject);

            if (id != null) {

                try {

                    return Long.parseLong(id);

                } catch (NumberFormatException e) {

                    // NOOP

                }

            }

        }

        return 0;

    }

    @Override

    public int getViewTypeCount() {

        return 3;

    }

    @Override

    public int getItemViewType(int position) {

        SectionAndItem<T> sectionAndItem = getSectionAndItem(position);

        switch (sectionAndItem.getType()) {

            case SECTION_HEADER:

                return HEADER_VIEW_TYPE;

            case GRAPH_OBJECT:

                return GRAPH_OBJECT_VIEW_TYPE;

            case ACTIVITY_CIRCLE:

                return ACTIVITY_CIRCLE_VIEW_TYPE;

            default:

                throw new FacebookException("Unexpected type of section and item.");

        }

    }

    @Override

    public View getView(int position, View convertView, ViewGroup parent) {

        SectionAndItem<T> sectionAndItem = getSectionAndItem(position);

        switch (sectionAndItem.getType()) {

            case SECTION_HEADER:

                return getSectionHeaderView(sectionAndItem.sectionKey, convertView, parent);

            case GRAPH_OBJECT:

                return getGraphObjectView(sectionAndItem.graphObject, convertView, parent);

            case ACTIVITY_CIRCLE:

                // If we get a request for this view, it means we need more data.

                assert cursor.areMoreObjectsAvailable() && (dataNeededListener != null);

                dataNeededListener.onDataNeeded();

                return getActivityCircleView(convertView, parent);

            default:

                throw new FacebookException("Unexpected type of section and item.");

        }

    }

    @Override

    public Object[] getSections() {

        if (displaySections) {

            return sectionKeys.toArray();

        } else {

            return new Object[0];

        }

    }

    @Override

    public int getPositionForSection(int section) {

        if (displaySections) {

            section = Math.max(0, Math.min(section, sectionKeys.size() - 1));

            if (section < sectionKeys.size()) {

                return getPosition(sectionKeys.get(section), null);

            }

        }

        return 0;

    }

    @Override

    public int getSectionForPosition(int position) {

        SectionAndItem<T> sectionAndItem = getSectionAndItem(position);

        if (sectionAndItem != null &&

                sectionAndItem.getType() != SectionAndItem.Type.ACTIVITY_CIRCLE) {

            return Math.max(0, Math.min(sectionKeys.indexOf(sectionAndItem.sectionKey), sectionKeys.size() - 1));

        }

        return 0;

    }

    public List<T> getGraphObjectsById(Collection<String> ids) {

        Set<String> idSet = new HashSet<String>();

        idSet.addAll(ids);

        ArrayList<T> result = new ArrayList<T>(idSet.size());

        for (String id : idSet) {

            T graphObject = graphObjectsById.get(id);

            if (graphObject != null) {

                result.add(graphObject);

            }

        }

        return result;

    }

    private void downloadProfilePicture(final String profileId, URI pictureURI, final ImageView imageView) {

        if (pictureURI == null) {

            return;

        }

        // If we don't have an imageView, we are pre-fetching this image to store in-memory because we

        // think the user might scroll to its corresponding list row. If we do have an imageView, we

        // only want to queue a download if the view's tag isn't already set to the URL (which would mean

        // it's already got the correct picture).

        boolean prefetching = imageView == null;

        if (prefetching || !pictureURI.equals(imageView.getTag())) {

            if (!prefetching) {

                // Setting the tag to the profile ID indicates that we're currently downloading the

                // picture for this profile; we'll set it to the actual picture URL when complete.

                imageView.setTag(profileId);

                imageView.setImageResource(getDefaultPicture());

            }

            ImageRequest.Builder builder = new ImageRequest.Builder(context.getApplicationContext(), pictureURI)

                    .setCallerTag(this)

                    .setCallback(

                            new ImageRequest.Callback() {

                                @Override

                                public void onCompleted(ImageResponse response) {

                                    processImageResponse(response, profileId, imageView);

                                }

                            });

            ImageRequest newRequest = builder.build();

            pendingRequests.put(profileId, newRequest);

            ImageDownloader.downloadAsync(newRequest);

        }

    }

    private void callOnErrorListener(Exception exception) {

        if (onErrorListener != null) {

            if (!(exception instanceof FacebookException)) {

                exception = new FacebookException(exception);

            }

            onErrorListener.onError(this, (FacebookException) exception);

        }

    }

    private void processImageResponse(ImageResponse response, String graphObjectId, ImageView imageView) {

        pendingRequests.remove(graphObjectId);

        if (response.getError() != null) {

            callOnErrorListener(response.getError());

        }

        if (imageView == null) {

            // This was a pre-fetch request.

            if (response.getBitmap() != null) {

                // Is the cache too big?

                if (prefetchedPictureCache.size() >= MAX_PREFETCHED_PICTURES) {

                    // Find the oldest one and remove it.

                    String oldestId = prefetchedProfilePictureIds.remove(0);

                    prefetchedPictureCache.remove(oldestId);

                }

                prefetchedPictureCache.put(graphObjectId, response);

            }

        } else if (graphObjectId.equals(imageView.getTag())) {

            Exception error = response.getError();

            Bitmap bitmap = response.getBitmap();

            if (error == null && bitmap != null) {

                imageView.setImageBitmap(bitmap);

                imageView.setTag(response.getRequest().getImageUri());

            }

        }

    }

    private static int compareGraphObjects(GraphObject a, GraphObject b, Collection<String> sortFields,

            Collator collator) {

        for (String sortField : sortFields) {

            String sa = (String) a.getProperty(sortField);

            String sb = (String) b.getProperty(sortField);

            if (sa != null && sb != null) {

                int result = collator.compare(sa, sb);

                if (result != 0) {

                    return result;

                }

            } else if (!(sa == null && sb == null)) {

                return (sa == null) ? -1 : 1;

            }

        }

        return 0;

    }

    // Graph object type to navigate the JSON that sometimes comes back instead of a URL string

    private interface ItemPicture extends GraphObject {

        ItemPictureData getData();

    }

    // Graph object type to navigate the JSON that sometimes comes back instead of a URL string

    private interface ItemPictureData extends GraphObject {

        String getUrl();

    }

}