src/com/android/launcher3/AppsContainerView.java - LeafOS-Project/android_packages_apps_Launcher3 - Gitiles

 package com.android.launcher3;

 import android.content.ComponentName;
 import android.content.Context;
 import android.graphics.Point;
 import android.graphics.Rect;
 import android.util.AttributeSet;
 import android.view.Gravity;
 import android.view.LayoutInflater;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.BaseAdapter;
 import android.widget.FrameLayout;
 import android.widget.LinearLayout;
 import android.widget.ListView;
 import android.widget.SectionIndexer;
 import android.widget.TextView;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;


 /**
  * Represents a row in the apps list view.
  */
 class AppsRow {
     int sectionId;
     String sectionDescription;
     List<AppInfo> apps;

     public AppsRow(int sId, String sc, List<AppInfo> ai) {
         sectionId = sId;
         sectionDescription = sc;
         apps = ai;
     }

     public AppsRow(int sId, List<AppInfo> ai) {
         sectionId = sId;
         apps = ai;
     }
 }

 /**
  * An interface to an algorithm that generates app rows.
  */
 interface AppRowAlgorithm {
     public List<AppsRow> computeAppRows(List<AppInfo> sortedApps, int appsPerRow);
     public int getIconViewLayoutId();
     public int getRowViewLayoutId();
     public void bindRowViewIconToInfo(BubbleTextView icon, AppInfo info);
 }

 /**
  * Computes the rows in the apps list view.
  */
 class SectionedAppsAlgorithm implements AppRowAlgorithm {

     @Override
     public List<AppsRow> computeAppRows(List<AppInfo> sortedApps, int appsPerRow) {
         List<AppsRow> rows = new ArrayList<>();
         LinkedHashMap<String, List<AppInfo>> sections = computeSectionedApps(sortedApps);
         int sectionId = 0;
         for (Map.Entry<String, List<AppInfo>> sectionEntry : sections.entrySet()) {
             String section = sectionEntry.getKey();
             List<AppInfo> apps = sectionEntry.getValue();
             int numRows = (int) Math.ceil((float) apps.size() / appsPerRow);
             for (int i = 0; i < numRows; i++) {
                 List<AppInfo> appsInRow = new ArrayList<>();
                 int offset = i * appsPerRow;
                 for (int j = 0; j < appsPerRow; j++) {
                     if (offset + j < apps.size()) {
                         appsInRow.add(apps.get(offset + j));
                     }
                 }
                 if (i == 0) {
                     rows.add(new AppsRow(sectionId, section, appsInRow));
                 } else {
                     rows.add(new AppsRow(sectionId, appsInRow));
                 }
             }
             sectionId++;
         }
         return rows;
     }

     @Override
     public int getIconViewLayoutId() {
         return R.layout.apps_grid_row_icon_view;
     }

     @Override
     public int getRowViewLayoutId() {
         return R.layout.apps_grid_row_view;
     }

     private LinkedHashMap<String, List<AppInfo>> computeSectionedApps(List<AppInfo> sortedApps) {
         LinkedHashMap<String, List<AppInfo>> sections = new LinkedHashMap<>();
         for (AppInfo info : sortedApps) {
             String section = getSection(info);
             List<AppInfo> sectionApps = sections.get(section);
             if (sectionApps == null) {
                 sectionApps = new ArrayList<>();
                 sections.put(section, sectionApps);
             }
             sectionApps.add(info);
         }
         return sections;
     }

     @Override
     public void bindRowViewIconToInfo(BubbleTextView icon, AppInfo info) {
         icon.applyFromApplicationInfo(info);
     }

     private String getSection(AppInfo app) {
         return app.title.toString().substring(0, 1).toLowerCase();
     }
 }

 /**
  * Computes the rows in the apps grid view.
  */
 class ListedAppsAlgorithm implements AppRowAlgorithm {

     @Override
     public List<AppsRow> computeAppRows(List<AppInfo> sortedApps, int appsPerRow) {
         List<AppsRow> rows = new ArrayList<>();
         int sectionId = -1;
         String prevSection = "";
         for (AppInfo info : sortedApps) {
             List<AppInfo> appsInRow = new ArrayList<>();
             appsInRow.add(info);
             String section = getSection(info);
             if (!prevSection.equals(section)) {
                 prevSection = section;
                 sectionId++;
                 rows.add(new AppsRow(sectionId, section, appsInRow));
             } else {
                 rows.add(new AppsRow(sectionId, appsInRow));
             }
         }
         return rows;
     }

     @Override
     public int getIconViewLayoutId() {
         return R.layout.apps_list_row_icon_view;
     }

     @Override
     public int getRowViewLayoutId() {
         return R.layout.apps_list_row_view;
     }

     @Override
     public void bindRowViewIconToInfo(BubbleTextView icon, AppInfo info) {
         icon.applyFromApplicationInfo(info);
     }

     private String getSection(AppInfo app) {
         return app.title.toString().substring(0, 1).toLowerCase();
     }
 }

 /**
  * The adapter of all the apps
  */
 class AppsListAdapter extends BaseAdapter implements SectionIndexer {

     private LayoutInflater mLayoutInflater;
     private List<AppsRow> mAppRows = new ArrayList<>();
     private View.OnTouchListener mTouchListener;
     private View.OnClickListener mIconClickListener;
     private View.OnLongClickListener mIconLongClickListener;
     private AppRowAlgorithm mRowAlgorithm;
     private int mAppsPerRow;

     public AppsListAdapter(Context context, View.OnTouchListener touchListener,
             View.OnClickListener iconClickListener, View.OnLongClickListener iconLongClickListener) {
         mLayoutInflater = LayoutInflater.from(context);
         mTouchListener = touchListener;
         mIconClickListener = iconClickListener;
         mIconLongClickListener = iconLongClickListener;
     }

     void setApps(List<AppsRow> apps, int appsPerRow, AppRowAlgorithm algo) {
         mAppsPerRow = appsPerRow;
         mRowAlgorithm = algo;
         mAppRows.clear();
         mAppRows.addAll(apps);
         notifyDataSetChanged();
     }

     @Override
     public int getCount() {
         return mAppRows.size();
     }

     @Override
     public Object getItem(int position) {
         return mAppRows.get(position);
     }

     @Override
     public long getItemId(int position) {
         return position;
     }

     @Override
     public View getView(int position, View convertView, ViewGroup parent) {
         AppsRow info = mAppRows.get(position);
         ViewGroup row = (ViewGroup) convertView;
         if (row == null) {
             // Inflate the row and all the icon children necessary
             row = (ViewGroup) mLayoutInflater.inflate(mRowAlgorithm.getRowViewLayoutId(),
                     parent, false);
             for (int i = 0; i < mAppsPerRow; i++) {
                 BubbleTextView icon = (BubbleTextView) mLayoutInflater.inflate(
                         mRowAlgorithm.getIconViewLayoutId(), row, false);
                 LinearLayout.LayoutParams lp = new LinearLayout.LayoutParams(0,
                         ViewGroup.LayoutParams.WRAP_CONTENT, 1);
                 lp.gravity = Gravity.CENTER_VERTICAL;
                 icon.setLayoutParams(lp);
                 icon.setOnTouchListener(mTouchListener);
                 icon.setOnClickListener(mIconClickListener);
                 icon.setOnLongClickListener(mIconLongClickListener);
                 icon.setFocusable(true);
                 row.addView(icon);
             }
         }
         // Bind the section header
         TextView tv = (TextView) row.findViewById(R.id.section);
         if (info.sectionDescription != null) {
             tv.setText(info.sectionDescription);
             tv.setVisibility(View.VISIBLE);
         } else {
             tv.setVisibility(View.INVISIBLE);
         }
         // Bind the icons
         for (int i = 0; i < mAppsPerRow; i++) {
             BubbleTextView icon = (BubbleTextView) row.getChildAt(i + 1);
             if (i < info.apps.size()) {
                 mRowAlgorithm.bindRowViewIconToInfo(icon, info.apps.get(i));
                 icon.setVisibility(View.VISIBLE);
             } else {
                 icon.setVisibility(View.INVISIBLE);
             }
         }
         return row;
     }

     @Override
     public Object[] getSections() {
         ArrayList<Object> sections = new ArrayList<>();
         int prevSectionId = -1;
         for (AppsRow row : mAppRows) {
             if (row.sectionId != prevSectionId) {
                 sections.add(row.sectionDescription.toUpperCase());
                 prevSectionId = row.sectionId;
             }
         }
         return sections.toArray();
     }

     @Override
     public int getPositionForSection(int sectionIndex) {
         for (int i = 0; i < mAppRows.size(); i++) {
             AppsRow row = mAppRows.get(i);
             if (row.sectionId == sectionIndex) {
                 return i;
             }
         }
         return 0;
     }

     @Override
     public int getSectionForPosition(int position) {
         return mAppRows.get(position).sectionId;
     }
 }

 /**
  * The alphabetically sorted list of applications.
  */
 class AlphabeticalAppList {

     /**
      * Callbacks for when this list is modified.
      */
     public interface Callbacks {
         public void onAppsUpdated();
     }

     private List<AppInfo> mApps;
     private Callbacks mCb;

     public AlphabeticalAppList(Callbacks cb) {
         mCb = cb;
     }

     /**
      * Returns the list of applications.
      */
     public List<AppInfo> getApps() {
         return mApps;
     }

     /**
      * Sets the current set of apps.
      */
     public void setApps(List<AppInfo> apps) {
         Collections.sort(apps, LauncherModel.getAppNameComparator());
         mApps = apps;
         mCb.onAppsUpdated();
     }

     /**
      * Adds new apps to the list.
      */
     public void addApps(List<AppInfo> apps) {
         // We add it in place, in alphabetical order
         Comparator<AppInfo> appNameComparator = LauncherModel.getAppNameComparator();
         for (AppInfo info : apps) {
             // This call will return the exact index of where the item is if >= 0, or the index
             // where it should be inserted if < 0.
             int index = Collections.binarySearch(mApps, info, appNameComparator);
             if (index < 0) {
                 mApps.add(-(index + 1), info);
             }
         }
         mCb.onAppsUpdated();
     }

     /**
      * Updates existing apps in the list
      */
     public void updateApps(List<AppInfo> apps) {
         Comparator<AppInfo> appNameComparator = LauncherModel.getAppNameComparator();
         for (AppInfo info : apps) {
             int index = mApps.indexOf(info);
             if (index != -1) {
                 mApps.set(index, info);
             } else {
                 index = Collections.binarySearch(mApps, info, appNameComparator);
                 if (index < 0) {
                     mApps.add(-(index + 1), info);
                 }
             }
         }
         mCb.onAppsUpdated();
     }

     /**
      * Removes some apps from the list.
      */
     public void removeApps(List<AppInfo> apps) {
         for (AppInfo info : apps) {
             int removeIndex = findAppByComponent(mApps, info);
             if (removeIndex != -1) {
                 mApps.remove(removeIndex);
             }
         }
         mCb.onAppsUpdated();
     }

     /**
      * Finds the index of an app given a target AppInfo.
      */
     private int findAppByComponent(List<AppInfo> apps, AppInfo targetInfo) {
         ComponentName targetComponent = targetInfo.intent.getComponent();
         int length = apps.size();
         for (int i = 0; i < length; ++i) {
             AppInfo info = apps.get(i);
             if (info.user.equals(info.user)
                     && info.intent.getComponent().equals(targetComponent)) {
                 return i;
             }
         }
         return -1;
     }

 }

 /**
  * The all apps list view container.
  */
 public class AppsContainerView extends FrameLayout implements DragSource, View.OnTouchListener,
         View.OnLongClickListener, Insettable, AlphabeticalAppList.Callbacks {

     static final int GRID_LAYOUT = 0;
     static final int LIST_LAYOUT = 1;
     static final int USE_LAYOUT = LIST_LAYOUT;

     private Launcher mLauncher;
     private AppRowAlgorithm mAppRowsAlgorithm;
     private AppsListAdapter mAdapter;
     private AlphabeticalAppList mApps;
     private ListView mList;
     private int mAppsRowSize;
     private Point mLastTouchDownPos = new Point();
     private Rect mPadding = new Rect();

     public AppsContainerView(Context context) {
         this(context, null);
     }

     public AppsContainerView(Context context, AttributeSet attrs) {
         this(context, attrs, 0);
     }

     public AppsContainerView(Context context, AttributeSet attrs, int defStyleAttr) {
         this(context, attrs, defStyleAttr, 0);
     }

     public AppsContainerView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
         super(context, attrs, defStyleAttr, defStyleRes);
         LauncherAppState app = LauncherAppState.getInstance();
         DeviceProfile grid = app.getDynamicGrid().getDeviceProfile();

         mLauncher = (Launcher) context;
         if (USE_LAYOUT == GRID_LAYOUT) {
             mAppRowsAlgorithm = new SectionedAppsAlgorithm();
             mAppsRowSize = grid.allAppsRowsSize;
         } else if (USE_LAYOUT == LIST_LAYOUT) {
             mAppRowsAlgorithm = new ListedAppsAlgorithm();
             mAppsRowSize = 1;
         }
         mAdapter = new AppsListAdapter(context, this, mLauncher, this);
         mApps = new AlphabeticalAppList(this);
     }

     /**
      * Sets the current set of apps.
      */
     public void setApps(List<AppInfo> apps) {
         mApps.setApps(apps);
     }

     /**
      * Adds new apps to the list.
      */
     public void addApps(List<AppInfo> apps) {
         mApps.addApps(apps);
     }

     /**
      * Updates existing apps in the list
      */
     public void updateApps(List<AppInfo> apps) {
         mApps.updateApps(apps);
     }

     /**
      * Removes some apps from the list.
      */
     public void removeApps(List<AppInfo> apps) {
         mApps.removeApps(apps);
     }

     /**
      * Scrolls this list view to the top.
      */
     public void scrollToTop() {
         mList.scrollTo(0, 0);
     }

     /**
      * Returns the content view used for the launcher transitions.
      */
     public View getContentView() {
         return findViewById(R.id.apps_list);
     }

     /**
      * Returns the reveal view used for the launcher transitions.
      */
     public View getRevealView() {
         return findViewById(R.id.all_apps_transition_overlay);
     }

     @Override
     public void onAppsUpdated() {
         List<AppsRow> rows = mAppRowsAlgorithm.computeAppRows(mApps.getApps(), mAppsRowSize);
         mAdapter.setApps(rows, mAppsRowSize, mAppRowsAlgorithm);
     }

     @Override
     protected void onFinishInflate() {
         mList = (ListView) findViewById(R.id.apps_list);
         mList.setFastScrollEnabled(true);
         mList.setFastScrollAlwaysVisible(true);
         mList.setItemsCanFocus(true);
         mList.setAdapter(mAdapter);
         mPadding.set(getPaddingLeft(), getPaddingTop(), getPaddingRight(), getPaddingBottom());
     }

     @Override
     public void setInsets(Rect insets) {
         setPadding(mPadding.left + insets.left, mPadding.top + insets.top,
                 mPadding.right + insets.right, mPadding.bottom + insets.bottom);
     }

     @Override
     public boolean onTouch(View v, MotionEvent event) {
         if (event.getAction() == MotionEvent.ACTION_DOWN ||
                 event.getAction() == MotionEvent.ACTION_MOVE) {
             mLastTouchDownPos.set((int) event.getX(), (int) event.getY());
         }
         return false;
     }

     @Override
     public boolean onLongClick(View v) {
         // Return early if this is not initiated from a touch
         if (!v.isInTouchMode()) return false;
         // When we have exited all apps or are in transition, disregard long clicks
         if (!mLauncher.isAppsViewVisible() ||
                 mLauncher.getWorkspace().isSwitchingState()) return false;
         // Return if global dragging is not enabled
         if (!mLauncher.isDraggingEnabled()) return false;

         // Start the drag
         mLauncher.getWorkspace().beginDragShared(v, mLastTouchDownPos, this, false);

         // We delay entering spring-loaded mode slightly to make sure the UI
         // thready is free of any work.
         postDelayed(new Runnable() {
             @Override
             public void run() {
                 // We don't enter spring-loaded mode if the drag has been cancelled
                 if (mLauncher.getDragController().isDragging()) {
                     // Go into spring loaded mode (must happen before we startDrag())
                     mLauncher.enterSpringLoadedDragMode();
                 }
             }
         }, 150);

         return false;
     }

     @Override
     public boolean supportsFlingToDelete() {
         return true;
     }

     @Override
     public boolean supportsAppInfoDropTarget() {
         return true;
     }

     @Override
     public boolean supportsDeleteDropTarget() {
         return true;
     }

     @Override
     public float getIntrinsicIconScaleFactor() {
         LauncherAppState app = LauncherAppState.getInstance();
         DeviceProfile grid = app.getDynamicGrid().getDeviceProfile();
         return (float) grid.allAppsIconSizePx / grid.iconSizePx;
     }

     @Override
     public void onFlingToDeleteCompleted() {
         // We just dismiss the drag when we fling, so cleanup here
         mLauncher.exitSpringLoadedDragModeDelayed(true,
                 Launcher.EXIT_SPRINGLOADED_MODE_SHORT_TIMEOUT, null);
         mLauncher.unlockScreenOrientation(false);
     }

     @Override
     public void onDropCompleted(View target, DropTarget.DragObject d, boolean isFlingToDelete, boolean success) {
         if (isFlingToDelete || !success || (target != mLauncher.getWorkspace() &&
                 !(target instanceof DeleteDropTarget) && !(target instanceof Folder))) {
             // Exit spring loaded mode if we have not successfully dropped or have not handled the
             // drop in Workspace
             mLauncher.exitSpringLoadedDragModeDelayed(true,
                     Launcher.EXIT_SPRINGLOADED_MODE_SHORT_TIMEOUT, null);
         }
         mLauncher.unlockScreenOrientation(false);

         // Display an error message if the drag failed due to there not being enough space on the
         // target layout we were dropping on.
         if (!success) {
             boolean showOutOfSpaceMessage = false;
             if (target instanceof Workspace) {
                 int currentScreen = mLauncher.getCurrentWorkspaceScreen();
                 Workspace workspace = (Workspace) target;
                 CellLayout layout = (CellLayout) workspace.getChildAt(currentScreen);
                 ItemInfo itemInfo = (ItemInfo) d.dragInfo;
                 if (layout != null) {
                     layout.calculateSpans(itemInfo);
                     showOutOfSpaceMessage =
                             !layout.findCellForSpan(null, itemInfo.spanX, itemInfo.spanY);
                 }
             }
             if (showOutOfSpaceMessage) {
                 mLauncher.showOutOfSpaceMessage(false);
             }

             d.deferDragViewCleanupPostAnimation = false;
         }
     }
 }
	package com.android.launcher3;

	import android.content.ComponentName;
	import android.content.Context;
	import android.graphics.Point;
	import android.graphics.Rect;
	import android.util.AttributeSet;
	import android.view.Gravity;
	import android.view.LayoutInflater;
	import android.view.MotionEvent;
	import android.view.View;
	import android.view.ViewGroup;
	import android.widget.BaseAdapter;
	import android.widget.FrameLayout;
	import android.widget.LinearLayout;
	import android.widget.ListView;
	import android.widget.SectionIndexer;
	import android.widget.TextView;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.Comparator;
	import java.util.LinkedHashMap;
	import java.util.List;
	import java.util.Map;


	/**
	* Represents a row in the apps list view.
	*/
	class AppsRow {
	int sectionId;
	String sectionDescription;
	List<AppInfo> apps;

	public AppsRow(int sId, String sc, List<AppInfo> ai) {
	sectionId = sId;
	sectionDescription = sc;
	apps = ai;
	}

	public AppsRow(int sId, List<AppInfo> ai) {
	sectionId = sId;
	apps = ai;
	}
	}

	/**
	* An interface to an algorithm that generates app rows.
	*/
	interface AppRowAlgorithm {
	public List<AppsRow> computeAppRows(List<AppInfo> sortedApps, int appsPerRow);
	public int getIconViewLayoutId();
	public int getRowViewLayoutId();
	public void bindRowViewIconToInfo(BubbleTextView icon, AppInfo info);
	}

	/**
	* Computes the rows in the apps list view.
	*/
	class SectionedAppsAlgorithm implements AppRowAlgorithm {

	@Override
	public List<AppsRow> computeAppRows(List<AppInfo> sortedApps, int appsPerRow) {
	List<AppsRow> rows = new ArrayList<>();
	LinkedHashMap<String, List<AppInfo>> sections = computeSectionedApps(sortedApps);
	int sectionId = 0;
	for (Map.Entry<String, List<AppInfo>> sectionEntry : sections.entrySet()) {
	String section = sectionEntry.getKey();
	List<AppInfo> apps = sectionEntry.getValue();
	int numRows = (int) Math.ceil((float) apps.size() / appsPerRow);
	for (int i = 0; i < numRows; i++) {
	List<AppInfo> appsInRow = new ArrayList<>();
	int offset = i * appsPerRow;
	for (int j = 0; j < appsPerRow; j++) {
	if (offset + j < apps.size()) {
	appsInRow.add(apps.get(offset + j));
	}
	}
	if (i == 0) {
	rows.add(new AppsRow(sectionId, section, appsInRow));
	} else {
	rows.add(new AppsRow(sectionId, appsInRow));
	}
	}
	sectionId++;
	}
	return rows;
	}

	@Override
	public int getIconViewLayoutId() {
	return R.layout.apps_grid_row_icon_view;
	}

	@Override
	public int getRowViewLayoutId() {
	return R.layout.apps_grid_row_view;
	}

	private LinkedHashMap<String, List<AppInfo>> computeSectionedApps(List<AppInfo> sortedApps) {
	LinkedHashMap<String, List<AppInfo>> sections = new LinkedHashMap<>();
	for (AppInfo info : sortedApps) {
	String section = getSection(info);
	List<AppInfo> sectionApps = sections.get(section);
	if (sectionApps == null) {
	sectionApps = new ArrayList<>();
	sections.put(section, sectionApps);
	}
	sectionApps.add(info);
	}
	return sections;
	}

	@Override
	public void bindRowViewIconToInfo(BubbleTextView icon, AppInfo info) {
	icon.applyFromApplicationInfo(info);
	}

	private String getSection(AppInfo app) {
	return app.title.toString().substring(0, 1).toLowerCase();
	}
	}

	/**
	* Computes the rows in the apps grid view.
	*/
	class ListedAppsAlgorithm implements AppRowAlgorithm {

	@Override
	public List<AppsRow> computeAppRows(List<AppInfo> sortedApps, int appsPerRow) {
	List<AppsRow> rows = new ArrayList<>();
	int sectionId = -1;
	String prevSection = "";
	for (AppInfo info : sortedApps) {
	List<AppInfo> appsInRow = new ArrayList<>();
	appsInRow.add(info);
	String section = getSection(info);
	if (!prevSection.equals(section)) {
	prevSection = section;
	sectionId++;
	rows.add(new AppsRow(sectionId, section, appsInRow));
	} else {
	rows.add(new AppsRow(sectionId, appsInRow));
	}
	}
	return rows;
	}

	@Override
	public int getIconViewLayoutId() {
	return R.layout.apps_list_row_icon_view;
	}

	@Override
	public int getRowViewLayoutId() {
	return R.layout.apps_list_row_view;
	}

	@Override
	public void bindRowViewIconToInfo(BubbleTextView icon, AppInfo info) {
	icon.applyFromApplicationInfo(info);
	}

	private String getSection(AppInfo app) {
	return app.title.toString().substring(0, 1).toLowerCase();
	}
	}

	/**
	* The adapter of all the apps
	*/
	class AppsListAdapter extends BaseAdapter implements SectionIndexer {

	private LayoutInflater mLayoutInflater;
	private List<AppsRow> mAppRows = new ArrayList<>();
	private View.OnTouchListener mTouchListener;
	private View.OnClickListener mIconClickListener;
	private View.OnLongClickListener mIconLongClickListener;
	private AppRowAlgorithm mRowAlgorithm;
	private int mAppsPerRow;

	public AppsListAdapter(Context context, View.OnTouchListener touchListener,
	View.OnClickListener iconClickListener, View.OnLongClickListener iconLongClickListener) {
	mLayoutInflater = LayoutInflater.from(context);
	mTouchListener = touchListener;
	mIconClickListener = iconClickListener;
	mIconLongClickListener = iconLongClickListener;
	}

	void setApps(List<AppsRow> apps, int appsPerRow, AppRowAlgorithm algo) {
	mAppsPerRow = appsPerRow;
	mRowAlgorithm = algo;
	mAppRows.clear();
	mAppRows.addAll(apps);
	notifyDataSetChanged();
	}

	@Override
	public int getCount() {
	return mAppRows.size();
	}

	@Override
	public Object getItem(int position) {
	return mAppRows.get(position);
	}

	@Override
	public long getItemId(int position) {
	return position;
	}

	@Override
	public View getView(int position, View convertView, ViewGroup parent) {
	AppsRow info = mAppRows.get(position);
	ViewGroup row = (ViewGroup) convertView;
	if (row == null) {
	// Inflate the row and all the icon children necessary
	row = (ViewGroup) mLayoutInflater.inflate(mRowAlgorithm.getRowViewLayoutId(),
	parent, false);
	for (int i = 0; i < mAppsPerRow; i++) {
	BubbleTextView icon = (BubbleTextView) mLayoutInflater.inflate(
	mRowAlgorithm.getIconViewLayoutId(), row, false);
	LinearLayout.LayoutParams lp = new LinearLayout.LayoutParams(0,
	ViewGroup.LayoutParams.WRAP_CONTENT, 1);
	lp.gravity = Gravity.CENTER_VERTICAL;
	icon.setLayoutParams(lp);
	icon.setOnTouchListener(mTouchListener);
	icon.setOnClickListener(mIconClickListener);
	icon.setOnLongClickListener(mIconLongClickListener);
	icon.setFocusable(true);
	row.addView(icon);
	}
	}
	// Bind the section header
	TextView tv = (TextView) row.findViewById(R.id.section);
	if (info.sectionDescription != null) {
	tv.setText(info.sectionDescription);
	tv.setVisibility(View.VISIBLE);
	} else {
	tv.setVisibility(View.INVISIBLE);
	}
	// Bind the icons
	for (int i = 0; i < mAppsPerRow; i++) {
	BubbleTextView icon = (BubbleTextView) row.getChildAt(i + 1);
	if (i < info.apps.size()) {
	mRowAlgorithm.bindRowViewIconToInfo(icon, info.apps.get(i));
	icon.setVisibility(View.VISIBLE);
	} else {
	icon.setVisibility(View.INVISIBLE);
	}
	}
	return row;
	}

	@Override
	public Object[] getSections() {
	ArrayList<Object> sections = new ArrayList<>();
	int prevSectionId = -1;
	for (AppsRow row : mAppRows) {
	if (row.sectionId != prevSectionId) {
	sections.add(row.sectionDescription.toUpperCase());
	prevSectionId = row.sectionId;
	}
	}
	return sections.toArray();
	}

	@Override
	public int getPositionForSection(int sectionIndex) {
	for (int i = 0; i < mAppRows.size(); i++) {
	AppsRow row = mAppRows.get(i);
	if (row.sectionId == sectionIndex) {
	return i;
	}
	}
	return 0;
	}

	@Override
	public int getSectionForPosition(int position) {
	return mAppRows.get(position).sectionId;
	}
	}

	/**
	* The alphabetically sorted list of applications.
	*/
	class AlphabeticalAppList {

	/**
	* Callbacks for when this list is modified.
	*/
	public interface Callbacks {
	public void onAppsUpdated();
	}

	private List<AppInfo> mApps;
	private Callbacks mCb;

	public AlphabeticalAppList(Callbacks cb) {
	mCb = cb;
	}

	/**
	* Returns the list of applications.
	*/
	public List<AppInfo> getApps() {
	return mApps;
	}

	/**
	* Sets the current set of apps.
	*/
	public void setApps(List<AppInfo> apps) {
	Collections.sort(apps, LauncherModel.getAppNameComparator());
	mApps = apps;
	mCb.onAppsUpdated();
	}

	/**
	* Adds new apps to the list.
	*/
	public void addApps(List<AppInfo> apps) {
	// We add it in place, in alphabetical order
	Comparator<AppInfo> appNameComparator = LauncherModel.getAppNameComparator();
	for (AppInfo info : apps) {
	// This call will return the exact index of where the item is if >= 0, or the index
	// where it should be inserted if < 0.
	int index = Collections.binarySearch(mApps, info, appNameComparator);
	if (index < 0) {
	mApps.add(-(index + 1), info);
	}
	}
	mCb.onAppsUpdated();
	}

	/**
	* Updates existing apps in the list
	*/
	public void updateApps(List<AppInfo> apps) {
	Comparator<AppInfo> appNameComparator = LauncherModel.getAppNameComparator();
	for (AppInfo info : apps) {
	int index = mApps.indexOf(info);
	if (index != -1) {
	mApps.set(index, info);
	} else {
	index = Collections.binarySearch(mApps, info, appNameComparator);
	if (index < 0) {
	mApps.add(-(index + 1), info);
	}
	}
	}
	mCb.onAppsUpdated();
	}

	/**
	* Removes some apps from the list.
	*/
	public void removeApps(List<AppInfo> apps) {
	for (AppInfo info : apps) {
	int removeIndex = findAppByComponent(mApps, info);
	if (removeIndex != -1) {
	mApps.remove(removeIndex);
	}
	}
	mCb.onAppsUpdated();
	}

	/**
	* Finds the index of an app given a target AppInfo.
	*/
	private int findAppByComponent(List<AppInfo> apps, AppInfo targetInfo) {
	ComponentName targetComponent = targetInfo.intent.getComponent();
	int length = apps.size();
	for (int i = 0; i < length; ++i) {
	AppInfo info = apps.get(i);
	if (info.user.equals(info.user)
	&& info.intent.getComponent().equals(targetComponent)) {
	return i;
	}
	}
	return -1;
	}

	}

	/**
	* The all apps list view container.
	*/
	public class AppsContainerView extends FrameLayout implements DragSource, View.OnTouchListener,
	View.OnLongClickListener, Insettable, AlphabeticalAppList.Callbacks {

	static final int GRID_LAYOUT = 0;
	static final int LIST_LAYOUT = 1;
	static final int USE_LAYOUT = LIST_LAYOUT;

	private Launcher mLauncher;
	private AppRowAlgorithm mAppRowsAlgorithm;
	private AppsListAdapter mAdapter;
	private AlphabeticalAppList mApps;
	private ListView mList;
	private int mAppsRowSize;
	private Point mLastTouchDownPos = new Point();
	private Rect mPadding = new Rect();

	public AppsContainerView(Context context) {
	this(context, null);
	}

	public AppsContainerView(Context context, AttributeSet attrs) {
	this(context, attrs, 0);
	}

	public AppsContainerView(Context context, AttributeSet attrs, int defStyleAttr) {
	this(context, attrs, defStyleAttr, 0);
	}

	public AppsContainerView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
	super(context, attrs, defStyleAttr, defStyleRes);
	LauncherAppState app = LauncherAppState.getInstance();
	DeviceProfile grid = app.getDynamicGrid().getDeviceProfile();

	mLauncher = (Launcher) context;
	if (USE_LAYOUT == GRID_LAYOUT) {
	mAppRowsAlgorithm = new SectionedAppsAlgorithm();
	mAppsRowSize = grid.allAppsRowsSize;
	} else if (USE_LAYOUT == LIST_LAYOUT) {
	mAppRowsAlgorithm = new ListedAppsAlgorithm();
	mAppsRowSize = 1;
	}
	mAdapter = new AppsListAdapter(context, this, mLauncher, this);
	mApps = new AlphabeticalAppList(this);
	}

	/**
	* Sets the current set of apps.
	*/
	public void setApps(List<AppInfo> apps) {
	mApps.setApps(apps);
	}

	/**
	* Adds new apps to the list.
	*/
	public void addApps(List<AppInfo> apps) {
	mApps.addApps(apps);
	}

	/**
	* Updates existing apps in the list
	*/
	public void updateApps(List<AppInfo> apps) {
	mApps.updateApps(apps);
	}

	/**
	* Removes some apps from the list.
	*/
	public void removeApps(List<AppInfo> apps) {
	mApps.removeApps(apps);
	}

	/**
	* Scrolls this list view to the top.
	*/
	public void scrollToTop() {
	mList.scrollTo(0, 0);
	}

	/**
	* Returns the content view used for the launcher transitions.
	*/
	public View getContentView() {
	return findViewById(R.id.apps_list);
	}

	/**
	* Returns the reveal view used for the launcher transitions.
	*/
	public View getRevealView() {
	return findViewById(R.id.all_apps_transition_overlay);
	}

	@Override
	public void onAppsUpdated() {
	List<AppsRow> rows = mAppRowsAlgorithm.computeAppRows(mApps.getApps(), mAppsRowSize);
	mAdapter.setApps(rows, mAppsRowSize, mAppRowsAlgorithm);
	}

	@Override
	protected void onFinishInflate() {
	mList = (ListView) findViewById(R.id.apps_list);
	mList.setFastScrollEnabled(true);
	mList.setFastScrollAlwaysVisible(true);
	mList.setItemsCanFocus(true);
	mList.setAdapter(mAdapter);
	mPadding.set(getPaddingLeft(), getPaddingTop(), getPaddingRight(), getPaddingBottom());
	}

	@Override
	public void setInsets(Rect insets) {
	setPadding(mPadding.left + insets.left, mPadding.top + insets.top,
	mPadding.right + insets.right, mPadding.bottom + insets.bottom);
	}

	@Override
	public boolean onTouch(View v, MotionEvent event) {
	if (event.getAction() == MotionEvent.ACTION_DOWN \|\|
	event.getAction() == MotionEvent.ACTION_MOVE) {
	mLastTouchDownPos.set((int) event.getX(), (int) event.getY());
	}
	return false;
	}

	@Override
	public boolean onLongClick(View v) {
	// Return early if this is not initiated from a touch
	if (!v.isInTouchMode()) return false;
	// When we have exited all apps or are in transition, disregard long clicks
	if (!mLauncher.isAppsViewVisible() \|\|
	mLauncher.getWorkspace().isSwitchingState()) return false;
	// Return if global dragging is not enabled
	if (!mLauncher.isDraggingEnabled()) return false;

	// Start the drag
	mLauncher.getWorkspace().beginDragShared(v, mLastTouchDownPos, this, false);

	// We delay entering spring-loaded mode slightly to make sure the UI
	// thready is free of any work.
	postDelayed(new Runnable() {
	@Override
	public void run() {
	// We don't enter spring-loaded mode if the drag has been cancelled
	if (mLauncher.getDragController().isDragging()) {
	// Go into spring loaded mode (must happen before we startDrag())
	mLauncher.enterSpringLoadedDragMode();
	}
	}
	}, 150);

	return false;
	}

	@Override
	public boolean supportsFlingToDelete() {
	return true;
	}

	@Override
	public boolean supportsAppInfoDropTarget() {
	return true;
	}

	@Override
	public boolean supportsDeleteDropTarget() {
	return true;
	}

	@Override
	public float getIntrinsicIconScaleFactor() {
	LauncherAppState app = LauncherAppState.getInstance();
	DeviceProfile grid = app.getDynamicGrid().getDeviceProfile();
	return (float) grid.allAppsIconSizePx / grid.iconSizePx;
	}

	@Override
	public void onFlingToDeleteCompleted() {
	// We just dismiss the drag when we fling, so cleanup here
	mLauncher.exitSpringLoadedDragModeDelayed(true,
	Launcher.EXIT_SPRINGLOADED_MODE_SHORT_TIMEOUT, null);
	mLauncher.unlockScreenOrientation(false);
	}

	@Override
	public void onDropCompleted(View target, DropTarget.DragObject d, boolean isFlingToDelete, boolean success) {
	if (isFlingToDelete \|\| !success \|\| (target != mLauncher.getWorkspace() &&
	!(target instanceof DeleteDropTarget) && !(target instanceof Folder))) {
	// Exit spring loaded mode if we have not successfully dropped or have not handled the
	// drop in Workspace
	mLauncher.exitSpringLoadedDragModeDelayed(true,
	Launcher.EXIT_SPRINGLOADED_MODE_SHORT_TIMEOUT, null);
	}
	mLauncher.unlockScreenOrientation(false);

	// Display an error message if the drag failed due to there not being enough space on the
	// target layout we were dropping on.
	if (!success) {
	boolean showOutOfSpaceMessage = false;
	if (target instanceof Workspace) {
	int currentScreen = mLauncher.getCurrentWorkspaceScreen();
	Workspace workspace = (Workspace) target;
	CellLayout layout = (CellLayout) workspace.getChildAt(currentScreen);
	ItemInfo itemInfo = (ItemInfo) d.dragInfo;
	if (layout != null) {
	layout.calculateSpans(itemInfo);
	showOutOfSpaceMessage =
	!layout.findCellForSpan(null, itemInfo.spanX, itemInfo.spanY);
	}
	}
	if (showOutOfSpaceMessage) {
	mLauncher.showOutOfSpaceMessage(false);
	}

	d.deferDragViewCleanupPostAnimation = false;
	}
	}
	}