The Tor Browser / file revision

 /* -*- Mode: Java; c-basic-offset: 4; tab-width: 20; indent-tabs-mode: nil; -*-

  * This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 package org.mozilla.gecko.home;

 import org.mozilla.gecko.R;

 import org.mozilla.gecko.db.BrowserContract.HomeItems;

 import org.mozilla.gecko.home.HomePager.OnUrlOpenListener;

 import org.mozilla.gecko.home.HomeConfig.EmptyViewConfig;

 import org.mozilla.gecko.home.HomeConfig.ItemHandler;

 import org.mozilla.gecko.home.HomeConfig.PanelConfig;

 import org.mozilla.gecko.home.HomeConfig.ViewConfig;

 import org.mozilla.gecko.util.StringUtils;

 import android.content.Context;

 import android.database.Cursor;

 import android.os.Parcel;

 import android.os.Parcelable;

 import android.text.TextUtils;

 import android.util.Log;

 import android.util.SparseArray;

 import android.view.KeyEvent;

 import android.view.LayoutInflater;

 import android.view.View;

 import android.view.ViewGroup;

 import android.widget.FrameLayout;

 import android.widget.ImageView;

 import android.widget.LinearLayout;

 import android.widget.TextView;

 import java.lang.ref.SoftReference;

 import java.util.EnumSet;

 import java.util.LinkedList;

 import java.util.Map;

 import java.util.WeakHashMap;

 import com.squareup.picasso.Picasso;

 /**

  * {@code PanelLayout} is the base class for custom layouts to be

  * used in {@code DynamicPanel}. It provides the basic framework

  * that enables custom layouts to request and reset datasets and

  * create panel views. Furthermore, it automates most of the process

  * of binding panel views with their respective datasets.

  *

  * {@code PanelLayout} abstracts the implemention details of how

  * datasets are actually loaded through the {@DatasetHandler} interface.

  * {@code DatasetHandler} provides two operations: request and reset.

  * The results of the dataset requests done via the {@code DatasetHandler}

  * are delivered to the {@code PanelLayout} with the {@code deliverDataset()}

  * method.

  *

  * Subclasses of {@code PanelLayout} should simply use the utilities

  * provided by {@code PanelLayout}. Namely:

  *

  * {@code requestDataset()} - To fetch datasets and auto-bind them to

  *                            the existing panel views backed by them.

  *

  * {@code resetDataset()} - To release any resources associated with a

  *                          previously loaded dataset.

  *

  * {@code createPanelView()} - To create a panel view for a ViewConfig

  *                             associated with the panel.

  *

  * {@code disposePanelView()} - To dispose any dataset references associated

  *                              with the given view.

  *

  * {@code PanelLayout} subclasses should always use {@code createPanelView()}

  * to create the views dynamically created based on {@code ViewConfig}. This

  * allows {@code PanelLayout} to auto-bind datasets with panel views.

  * {@code PanelLayout} subclasses are free to have any type of views to arrange

  * the panel views in different ways.

  */

 abstract class PanelLayout extends FrameLayout {

     private static final String LOGTAG = "GeckoPanelLayout";

     protected final SparseArray<ViewState> mViewStates;

     private final PanelConfig mPanelConfig;

     private final DatasetHandler mDatasetHandler;

     private final OnUrlOpenListener mUrlOpenListener;

     private final ContextMenuRegistry mContextMenuRegistry;

     /**

      * To be used by panel views to express that they are

      * backed by datasets.

      */

     public interface DatasetBacked {

         public void setDataset(Cursor cursor);

         public void setFilterManager(FilterManager manager);

     }

     /**

      * To be used by requests made to {@code DatasetHandler}s to couple dataset ID with current

      * filter for queries on the database.

      */

     public static class DatasetRequest implements Parcelable {

         public enum Type implements Parcelable {

             DATASET_LOAD,

             FILTER_PUSH,

             FILTER_POP;

             @Override

             public int describeContents() {

                 return 0;

             }

             @Override

             public void writeToParcel(Parcel dest, int flags) {

                 dest.writeInt(ordinal());

             }

             public static final Creator<Type> CREATOR = new Creator<Type>() {

                 @Override

                 public Type createFromParcel(final Parcel source) {

                     return Type.values()[source.readInt()];

                 }

                 @Override

                 public Type[] newArray(final int size) {

                     return new Type[size];

                 }

             };

         }

         private final int mViewIndex;

         private final Type mType;

         private final String mDatasetId;

         private final FilterDetail mFilterDetail;

         private DatasetRequest(Parcel in) {

             this.mViewIndex = in.readInt();

             this.mType = (Type) in.readParcelable(getClass().getClassLoader());

             this.mDatasetId = in.readString();

             this.mFilterDetail = (FilterDetail) in.readParcelable(getClass().getClassLoader());

         }

         public DatasetRequest(int index, String datasetId, FilterDetail filterDetail) {

             this(index, Type.DATASET_LOAD, datasetId, filterDetail);

         }

         public DatasetRequest(int index, Type type, String datasetId, FilterDetail filterDetail) {

             this.mViewIndex = index;

             this.mType = type;

             this.mDatasetId = datasetId;

             this.mFilterDetail = filterDetail;

         }

         public int getViewIndex() {

             return mViewIndex;

         }

         public Type getType() {

             return mType;

         }

         public String getDatasetId() {

             return mDatasetId;

         }

         public String getFilter() {

             return (mFilterDetail != null ? mFilterDetail.filter : null);

         }

         public FilterDetail getFilterDetail() {

             return mFilterDetail;

         }

         @Override

         public int describeContents() {

             return 0;

         }

         @Override

         public void writeToParcel(Parcel dest, int flags) {

             dest.writeInt(mViewIndex);

             dest.writeParcelable(mType, 0);

             dest.writeString(mDatasetId);

             dest.writeParcelable(mFilterDetail, 0);

         }

         public String toString() {

             return "{ index: " + mViewIndex +

                    ", type: " + mType +

                    ", dataset: " + mDatasetId +

                    ", filter: " + mFilterDetail +

                    " }";

         }

         public static final Creator<DatasetRequest> CREATOR = new Creator<DatasetRequest>() {

             public DatasetRequest createFromParcel(Parcel in) {

                 return new DatasetRequest(in);

             }

             public DatasetRequest[] newArray(int size) {

                 return new DatasetRequest[size];

             }

         };

     }

     /**

      * Defines the contract with the component that is responsible

      * for handling datasets requests.

      */

     public interface DatasetHandler {

         /**

          * Requests a dataset to be fetched and auto-bound to the

          * panel views backed by it.

          */

         public void requestDataset(DatasetRequest request);

         /**

          * Releases any resources associated with a panel view. It will

          * do nothing if the view with the given index been created

          * before.

          */

         public void resetDataset(int viewIndex);

     }

     public interface PanelView {

         public void setOnItemOpenListener(OnItemOpenListener listener);

         public void setOnKeyListener(OnKeyListener listener);

         public void setContextMenuInfoFactory(HomeContextMenuInfo.Factory factory);

     }

     public interface FilterManager {

         public FilterDetail getPreviousFilter();

         public boolean canGoBack();

         public void goBack();

     }

     public interface ContextMenuRegistry {

         public void register(View view);

     }

     public PanelLayout(Context context, PanelConfig panelConfig, DatasetHandler datasetHandler,

             OnUrlOpenListener urlOpenListener, ContextMenuRegistry contextMenuRegistry) {

         super(context);

         mViewStates = new SparseArray<ViewState>();

         mPanelConfig = panelConfig;

         mDatasetHandler = datasetHandler;

         mUrlOpenListener = urlOpenListener;

         mContextMenuRegistry = contextMenuRegistry;

     }

     @Override

     public void onDetachedFromWindow() {

         super.onDetachedFromWindow();

         final int count = mViewStates.size();

         for (int i = 0; i < count; i++) {

             final ViewState viewState = mViewStates.valueAt(i);

             final View view = viewState.getView();

             if (view != null) {

                 maybeSetDataset(view, null);

             }

         }

         mViewStates.clear();

     }

     /**

      * Delivers the dataset as a {@code Cursor} to be bound to the

      * panel view backed by it. This is used by the {@code DatasetHandler}

      * in response to a dataset request.

      */

     public final void deliverDataset(DatasetRequest request, Cursor cursor) {

         Log.d(LOGTAG, "Delivering request: " + request);

         final ViewState viewState = mViewStates.get(request.getViewIndex());

         if (viewState == null) {

             return;

         }

         switch (request.getType()) {

             case FILTER_PUSH:

                 viewState.pushFilter(request.getFilterDetail());

                 break;

             case FILTER_POP:

                 viewState.popFilter();

                 break;

         }

         final View activeView = viewState.getActiveView();

         if (activeView == null) {

             throw new IllegalStateException("No active view for view state: " + viewState.getIndex());

         }

         final ViewConfig viewConfig = viewState.getViewConfig();

         final View newView;

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

             newView = createEmptyView(viewConfig);

             maybeSetDataset(activeView, null);

         } else {

             newView = createPanelView(viewConfig);

             maybeSetDataset(newView, cursor);

         }

         if (activeView != newView) {

             replacePanelView(activeView, newView);

         }

     }

     /**

      * Releases any references to the given dataset from all

      * existing panel views.

      */

     public final void releaseDataset(int viewIndex) {

         Log.d(LOGTAG, "Releasing dataset: " + viewIndex);

         final ViewState viewState = mViewStates.get(viewIndex);

         if (viewState == null) {

             return;

         }

         final View view = viewState.getView();

         if (view != null) {

             maybeSetDataset(view, null);

         }

     }

     /**

      * Requests a dataset to be loaded and bound to any existing

      * panel view backed by it.

      */

     protected final void requestDataset(DatasetRequest request) {

         Log.d(LOGTAG, "Requesting request: " + request);

         if (mViewStates.get(request.getViewIndex()) == null) {

             return;

         }

         mDatasetHandler.requestDataset(request);

     }

     /**

      * Releases any resources associated with a panel view.

      * e.g. close any associated {@code Cursor}.

      */

     protected final void resetDataset(int viewIndex) {

         Log.d(LOGTAG, "Resetting view with index: " + viewIndex);

         if (mViewStates.get(viewIndex) == null) {

             return;

         }

         mDatasetHandler.resetDataset(viewIndex);

     }

     /**

      * Factory method to create instance of panels from a given

      * {@code ViewConfig}. All panel views defined in {@code PanelConfig}

      * should be created using this method so that {@PanelLayout} can

      * keep track of panel views and their associated datasets.

      */

     protected final View createPanelView(ViewConfig viewConfig) {

         Log.d(LOGTAG, "Creating panel view: " + viewConfig.getType());

         ViewState viewState = mViewStates.get(viewConfig.getIndex());

         if (viewState == null) {

             viewState = new ViewState(viewConfig);

             mViewStates.put(viewConfig.getIndex(), viewState);

         }

         View view = viewState.getView();

         if (view == null) {

             switch(viewConfig.getType()) {

                 case LIST:

                     view = new PanelListView(getContext(), viewConfig);

                     break;

                 case GRID:

                     view = new PanelGridView(getContext(), viewConfig);

                     break;

                 default:

                     throw new IllegalStateException("Unrecognized view type in " + getClass().getSimpleName());

             }

             PanelView panelView = (PanelView) view;

             panelView.setOnItemOpenListener(new PanelOnItemOpenListener(viewState));

             panelView.setOnKeyListener(new PanelKeyListener(viewState));

             panelView.setContextMenuInfoFactory(new HomeContextMenuInfo.Factory() {

                 @Override

                 public HomeContextMenuInfo makeInfoForCursor(View view, int position, long id, Cursor cursor) {

                     final HomeContextMenuInfo info = new HomeContextMenuInfo(view, position, id);

                     info.url = cursor.getString(cursor.getColumnIndexOrThrow(HomeItems.URL));

                     info.title = cursor.getString(cursor.getColumnIndexOrThrow(HomeItems.TITLE));

                     return info;

                 }

             });

             mContextMenuRegistry.register(view);

             if (view instanceof DatasetBacked) {

                 DatasetBacked datasetBacked = (DatasetBacked) view;

                 datasetBacked.setFilterManager(new PanelFilterManager(viewState));

                 // XXX: Disabled because of bug 1010986

                 // if (viewConfig.isRefreshEnabled()) {

                 //     view = new PanelRefreshLayout(getContext(), view,

                 //                                   mPanelConfig.getId(), viewConfig.getIndex());

                 // }

             }

             viewState.setView(view);

         }

         return view;

     }

     /**

      * Dispose any dataset references associated with the

      * given view.

      */

     protected final void disposePanelView(View view) {

         Log.d(LOGTAG, "Disposing panel view");

         final int count = mViewStates.size();

         for (int i = 0; i < count; i++) {

             final ViewState viewState = mViewStates.valueAt(i);

             if (viewState.getView() == view) {

                 maybeSetDataset(view, null);

                 mViewStates.remove(viewState.getIndex());

                 break;

             }

         }

     }

     private void maybeSetDataset(View view, Cursor cursor) {

         if (view instanceof DatasetBacked) {

             final DatasetBacked dsb = (DatasetBacked) view;

             dsb.setDataset(cursor);

         }

     }

     private View createEmptyView(ViewConfig viewConfig) {

         Log.d(LOGTAG, "Creating empty view: " + viewConfig.getType());

         ViewState viewState = mViewStates.get(viewConfig.getIndex());

         if (viewState == null) {

             throw new IllegalStateException("No view state found for view index: " + viewConfig.getIndex());

         }

         View view = viewState.getEmptyView();

         if (view == null) {

             view = LayoutInflater.from(getContext()).inflate(R.layout.home_empty_panel, null);

             final EmptyViewConfig emptyViewConfig = viewConfig.getEmptyViewConfig();

             // XXX: Refactor this into a custom view (bug 985134)

             final String text = (emptyViewConfig == null) ? null : emptyViewConfig.getText();

             final TextView textView = (TextView) view.findViewById(R.id.home_empty_text);

             if (TextUtils.isEmpty(text)) {

                 textView.setText(R.string.home_default_empty);

             } else {

                 textView.setText(text);

             }

             final String imageUrl = (emptyViewConfig == null) ? null : emptyViewConfig.getImageUrl();

             final ImageView imageView = (ImageView) view.findViewById(R.id.home_empty_image);

             if (TextUtils.isEmpty(imageUrl)) {

                 imageView.setImageResource(R.drawable.icon_home_empty_firefox);

             } else {

                 Picasso.with(getContext())

                        .load(imageUrl)

                        .error(R.drawable.icon_home_empty_firefox)

                        .into(imageView);

             }

             viewState.setEmptyView(view);

         }

         return view;

     }

     private void replacePanelView(View currentView, View newView) {

         final ViewGroup parent = (ViewGroup) currentView.getParent();

         parent.addView(newView, parent.indexOfChild(currentView), currentView.getLayoutParams());

         parent.removeView(currentView);

     }

     /**

      * Must be implemented by {@code PanelLayout} subclasses to define

      * what happens then the layout is first loaded. Should set initial

      * UI state and request any necessary datasets.

      */

     public abstract void load();

     /**

      * Represents a 'live' instance of a panel view associated with

      * the {@code PanelLayout}. Is responsible for tracking the history stack of filters.

      */

     protected class ViewState {

         private final ViewConfig mViewConfig;

         private SoftReference<View> mView;

         private SoftReference<View> mEmptyView;

         private LinkedList<FilterDetail> mFilterStack;

         public ViewState(ViewConfig viewConfig) {

             mViewConfig = viewConfig;

             mView = new SoftReference<View>(null);

             mEmptyView = new SoftReference<View>(null);

         }

         public ViewConfig getViewConfig() {

             return mViewConfig;

         }

         public int getIndex() {

             return mViewConfig.getIndex();

         }

         public View getView() {

             return mView.get();

         }

         public void setView(View view) {

             mView = new SoftReference<View>(view);

         }

         public View getEmptyView() {

             return mEmptyView.get();

         }

         public void setEmptyView(View view) {

             mEmptyView = new SoftReference<View>(view);

         }

         public View getActiveView() {

             final View view = getView();

             if (view != null && view.getParent() != null) {

                 return view;

             }

             final View emptyView = getEmptyView();

             if (emptyView != null && emptyView.getParent() != null) {

                 return emptyView;

             }

             return null;

         }

         public String getDatasetId() {

             return mViewConfig.getDatasetId();

         }

         public ItemHandler getItemHandler() {

             return mViewConfig.getItemHandler();

         }

         /**

          * Get the current filter that this view is displaying, or null if none.

          */

         public FilterDetail getCurrentFilter() {

             if (mFilterStack == null) {

                 return null;

             } else {

                 return mFilterStack.peek();

             }

         }

         /**

          * Get the previous filter that this view was displaying, or null if none.

          */

         public FilterDetail getPreviousFilter() {

             if (!canPopFilter()) {

                 return null;

             }

             return mFilterStack.get(1);

         }

         /**

          * Adds a filter to the history stack for this view.

          */

         public void pushFilter(FilterDetail filter) {

             if (mFilterStack == null) {

                 mFilterStack = new LinkedList<FilterDetail>();

                 // Initialize with the initial filter.

                 mFilterStack.push(new FilterDetail(mViewConfig.getFilter(),

                                                    mPanelConfig.getTitle()));

             }

             mFilterStack.push(filter);

         }

         /**

          * Remove the most recent filter from the stack.

          *

          * @return whether the filter was popped

          */

         public boolean popFilter() {

             if (!canPopFilter()) {

                 return false;

             }

             mFilterStack.pop();

             return true;

         }

         public boolean canPopFilter() {

             return (mFilterStack != null && mFilterStack.size() > 1);

         }

     }

     static class FilterDetail implements Parcelable {

         final String filter;

         final String title;

         private FilterDetail(Parcel in) {

             this.filter = in.readString();

             this.title = in.readString();

         }

         public FilterDetail(String filter, String title) {

             this.filter = filter;

             this.title = title;

         }

         @Override

         public int describeContents() {

             return 0;

         }

         @Override

         public void writeToParcel(Parcel dest, int flags) {

             dest.writeString(filter);

             dest.writeString(title);

         }

         public static final Creator<FilterDetail> CREATOR = new Creator<FilterDetail>() {

             public FilterDetail createFromParcel(Parcel in) {

                 return new FilterDetail(in);

             }

             public FilterDetail[] newArray(int size) {

                 return new FilterDetail[size];

             }

         };

     }

     /**

      * Pushes filter to {@code ViewState}'s stack and makes request for new filter value.

      */

     private void pushFilterOnView(ViewState viewState, FilterDetail filterDetail) {

         final int index = viewState.getIndex();

         final String datasetId = viewState.getDatasetId();

         mDatasetHandler.requestDataset(new DatasetRequest(index,

                                                           DatasetRequest.Type.FILTER_PUSH,

                                                           datasetId,

                                                           filterDetail));

     }

     /**

      * Pops filter from {@code ViewState}'s stack and makes request for previous filter value.

      *

      * @return whether the filter has changed

      */

     private boolean popFilterOnView(ViewState viewState) {

         if (viewState.canPopFilter()) {

             final int index = viewState.getIndex();

             final String datasetId = viewState.getDatasetId();

             final FilterDetail filterDetail = viewState.getPreviousFilter();

             mDatasetHandler.requestDataset(new DatasetRequest(index,

                                                               DatasetRequest.Type.FILTER_POP,

                                                               datasetId,

                                                               filterDetail));

             return true;

         } else {

             return false;

         }

     }

     public interface OnItemOpenListener {

         public void onItemOpen(String url, String title);

     }

     private class PanelOnItemOpenListener implements OnItemOpenListener {

         private ViewState mViewState;

         public PanelOnItemOpenListener(ViewState viewState) {

             mViewState = viewState;

         }

         @Override

         public void onItemOpen(String url, String title) {

             if (StringUtils.isFilterUrl(url)) {

                 FilterDetail filterDetail = new FilterDetail(StringUtils.getFilterFromUrl(url), title);

                 pushFilterOnView(mViewState, filterDetail);

             } else {

                 EnumSet<OnUrlOpenListener.Flags> flags = EnumSet.noneOf(OnUrlOpenListener.Flags.class);

                 if (mViewState.getItemHandler() == ItemHandler.INTENT) {

                     flags.add(OnUrlOpenListener.Flags.OPEN_WITH_INTENT);

                 }

                 mUrlOpenListener.onUrlOpen(url, flags);

             }

         }

     }

     private class PanelKeyListener implements View.OnKeyListener {

         private ViewState mViewState;

         public PanelKeyListener(ViewState viewState) {

             mViewState = viewState;

         }

         @Override

         public boolean onKey(View v, int keyCode, KeyEvent event) {

             if (event.getAction() == KeyEvent.ACTION_UP && keyCode == KeyEvent.KEYCODE_BACK) {

                 return popFilterOnView(mViewState);

             }

             return false;

         }

     }

     private class PanelFilterManager implements FilterManager {

         private final ViewState mViewState;

         public PanelFilterManager(ViewState viewState) {

             mViewState = viewState;

         }

         @Override

         public FilterDetail getPreviousFilter() {

             return mViewState.getPreviousFilter();

         }

         @Override

         public boolean canGoBack() {

             return mViewState.canPopFilter();

         }

         @Override

         public void goBack() {

             popFilterOnView(mViewState);

         }

     }

 }