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

 /*
  * Copyright (C) 2015 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.launcher3.util;

 import android.util.Log;
 import android.view.KeyEvent;
 import android.view.View;
 import android.view.ViewGroup;

 import com.android.launcher3.CellLayout;
 import com.android.launcher3.DeviceProfile;
 import com.android.launcher3.ShortcutAndWidgetContainer;
 import com.android.launcher3.config.FeatureFlags;

 import java.util.Arrays;

 /**
  * Calculates the next item that a {@link KeyEvent} should change the focus to.
  *<p>
  * Note, this utility class calculates everything regards to icon index and its (x,y) coordinates.
  * Currently supports:
  * <ul>
  *  <li> full matrix of cells that are 1x1
  *  <li> sparse matrix of cells that are 1x1
  *     [ 1][  ][ 2][  ]
  *     [  ][  ][ 3][  ]
  *     [  ][ 4][  ][  ]
  *     [  ][ 5][ 6][ 7]
  * </ul>
  * *<p>
  * For testing, one can use a BT keyboard, or use following adb command.
  * ex. $ adb shell input keyevent 20 // KEYCODE_DPAD_LEFT
  */
 public class FocusLogic {

     private static final String TAG = "FocusLogic";
     private static final boolean DEBUG = false;

     /** Item and page index related constant used by {@link #handleKeyEvent}. */
     public static final int NOOP = -1;

     public static final int PREVIOUS_PAGE_RIGHT_COLUMN  = -2;
     public static final int PREVIOUS_PAGE_FIRST_ITEM    = -3;
     public static final int PREVIOUS_PAGE_LAST_ITEM     = -4;
     public static final int PREVIOUS_PAGE_LEFT_COLUMN   = -5;

     public static final int CURRENT_PAGE_FIRST_ITEM     = -6;
     public static final int CURRENT_PAGE_LAST_ITEM      = -7;

     public static final int NEXT_PAGE_FIRST_ITEM        = -8;
     public static final int NEXT_PAGE_LEFT_COLUMN       = -9;
     public static final int NEXT_PAGE_RIGHT_COLUMN      = -10;

     public static final int ALL_APPS_COLUMN = -11;

     // Matrix related constant.
     public static final int EMPTY = -1;
     public static final int PIVOT = 100;

     /**
      * Returns true only if this utility class handles the key code.
      */
     public static boolean shouldConsume(int keyCode) {
         return (keyCode == KeyEvent.KEYCODE_DPAD_LEFT || keyCode == KeyEvent.KEYCODE_DPAD_RIGHT ||
                 keyCode == KeyEvent.KEYCODE_DPAD_UP || keyCode == KeyEvent.KEYCODE_DPAD_DOWN ||
                 keyCode == KeyEvent.KEYCODE_MOVE_HOME || keyCode == KeyEvent.KEYCODE_MOVE_END ||
                 keyCode == KeyEvent.KEYCODE_PAGE_UP || keyCode == KeyEvent.KEYCODE_PAGE_DOWN);
     }

     public static int handleKeyEvent(int keyCode, int [][] map, int iconIdx, int pageIndex,
             int pageCount, boolean isRtl) {

         int cntX = map == null ? -1 : map.length;
         int cntY = map == null ? -1 : map[0].length;

         if (DEBUG) {
             Log.v(TAG, String.format(
                     "handleKeyEvent START: cntX=%d, cntY=%d, iconIdx=%d, pageIdx=%d, pageCnt=%d",
                     cntX, cntY, iconIdx, pageIndex, pageCount));
         }

         int newIndex = NOOP;
         switch (keyCode) {
             case KeyEvent.KEYCODE_DPAD_LEFT:
                 newIndex = handleDpadHorizontal(iconIdx, cntX, cntY, map, -1 /*increment*/, isRtl);
                 if (!isRtl && newIndex == NOOP && pageIndex > 0) {
                     newIndex = PREVIOUS_PAGE_RIGHT_COLUMN;
                 } else if (isRtl && newIndex == NOOP && pageIndex < pageCount - 1) {
                     newIndex = NEXT_PAGE_RIGHT_COLUMN;
                 }
                 break;
             case KeyEvent.KEYCODE_DPAD_RIGHT:
                 newIndex = handleDpadHorizontal(iconIdx, cntX, cntY, map, 1 /*increment*/, isRtl);
                 if (!isRtl && newIndex == NOOP && pageIndex < pageCount - 1) {
                     newIndex = NEXT_PAGE_LEFT_COLUMN;
                 } else if (isRtl && newIndex == NOOP && pageIndex > 0) {
                     newIndex = PREVIOUS_PAGE_LEFT_COLUMN;
                 }
                 break;
             case KeyEvent.KEYCODE_DPAD_DOWN:
                 newIndex = handleDpadVertical(iconIdx, cntX, cntY, map, 1  /*increment*/);
                 break;
             case KeyEvent.KEYCODE_DPAD_UP:
                 newIndex = handleDpadVertical(iconIdx, cntX, cntY, map, -1  /*increment*/);
                 break;
             case KeyEvent.KEYCODE_MOVE_HOME:
                 newIndex = handleMoveHome();
                 break;
             case KeyEvent.KEYCODE_MOVE_END:
                 newIndex = handleMoveEnd();
                 break;
             case KeyEvent.KEYCODE_PAGE_DOWN:
                 newIndex = handlePageDown(pageIndex, pageCount);
                 break;
             case KeyEvent.KEYCODE_PAGE_UP:
                 newIndex = handlePageUp(pageIndex);
                 break;
             default:
                 break;
         }

         if (DEBUG) {
             Log.v(TAG, String.format("handleKeyEvent FINISH: index [%d -> %s]",
                     iconIdx, getStringIndex(newIndex)));
         }
         return newIndex;
     }

     /**
      * Returns a matrix of size (m x n) that has been initialized with {@link #EMPTY}.
      *
      * @param m                 number of columns in the matrix
      * @param n                 number of rows in the matrix
      */
     // TODO: get rid of dynamic matrix creation.
     private static int[][] createFullMatrix(int m, int n) {
         int[][] matrix = new int [m][n];

         for (int i=0; i < m;i++) {
             Arrays.fill(matrix[i], EMPTY);
         }
         return matrix;
     }

     /**
      * Returns a matrix of size same as the {@link CellLayout} dimension that is initialized with the
      * index of the child view.
      */
     // TODO: get rid of the dynamic matrix creation
     public static int[][] createSparseMatrix(CellLayout layout) {
         ShortcutAndWidgetContainer parent = layout.getShortcutsAndWidgets();
         final int m = layout.getCountX();
         final int n = layout.getCountY();
         final boolean invert = parent.invertLayoutHorizontally();

         int[][] matrix = createFullMatrix(m, n);

         // Iterate thru the children.
         for (int i = 0; i < parent.getChildCount(); i++ ) {
             View cell = parent.getChildAt(i);
             if (!cell.isFocusable()) {
                 continue;
             }
             int cx = ((CellLayout.LayoutParams) cell.getLayoutParams()).cellX;
             int cy = ((CellLayout.LayoutParams) cell.getLayoutParams()).cellY;
             matrix[invert ? (m - cx - 1) : cx][cy] = i;
         }
         if (DEBUG) {
             printMatrix(matrix);
         }
         return matrix;
     }

     /**
      * Creates a sparse matrix that merges the icon and hotseat view group using the cell layout.
      * The size of the returning matrix is [icon column count x (icon + hotseat row count)]
      * in portrait orientation. In landscape, [(icon + hotseat) column count x (icon row count)]
      */
     // TODO: get rid of the dynamic matrix creation
     public static int[][] createSparseMatrixWithHotseat(
             CellLayout iconLayout, CellLayout hotseatLayout, DeviceProfile dp) {

         ViewGroup iconParent = iconLayout.getShortcutsAndWidgets();
         ViewGroup hotseatParent = hotseatLayout.getShortcutsAndWidgets();

         boolean isHotseatHorizontal = !dp.isVerticalBarLayout();
         boolean moreIconsInHotseatThanWorkspace = !FeatureFlags.NO_ALL_APPS_ICON &&
                 (isHotseatHorizontal
                         ? hotseatLayout.getCountX() > iconLayout.getCountX()
                         : hotseatLayout.getCountY() > iconLayout.getCountY());

         int m, n;
         if (isHotseatHorizontal) {
             m = hotseatLayout.getCountX();
             n = iconLayout.getCountY() + hotseatLayout.getCountY();
         } else {
             m = iconLayout.getCountX() + hotseatLayout.getCountX();
             n = hotseatLayout.getCountY();
         }
         int[][] matrix = createFullMatrix(m, n);
         if (moreIconsInHotseatThanWorkspace) {
             int allappsiconRank = dp.inv.getAllAppsButtonRank();
             if (isHotseatHorizontal) {
                 for (int j = 0; j < n; j++) {
                     matrix[allappsiconRank][j] = ALL_APPS_COLUMN;
                 }
             } else {
                 for (int j = 0; j < m; j++) {
                     matrix[j][allappsiconRank] = ALL_APPS_COLUMN;
                 }
             }
         }
         // Iterate thru the children of the workspace.
         for (int i = 0; i < iconParent.getChildCount(); i++) {
             View cell = iconParent.getChildAt(i);
             if (!cell.isFocusable()) {
                 continue;
             }
             int cx = ((CellLayout.LayoutParams) cell.getLayoutParams()).cellX;
             int cy = ((CellLayout.LayoutParams) cell.getLayoutParams()).cellY;
             if (moreIconsInHotseatThanWorkspace) {
                 int allappsiconRank = dp.inv.getAllAppsButtonRank();
                 if (isHotseatHorizontal && cx >= allappsiconRank) {
                     // Add 1 to account for the All Apps button.
                     cx++;
                 }
                 if (!isHotseatHorizontal && cy >= allappsiconRank) {
                     // Add 1 to account for the All Apps button.
                     cy++;
                 }
             }
             matrix[cx][cy] = i;
         }

         // Iterate thru the children of the hotseat.
         for (int i = hotseatParent.getChildCount() - 1; i >= 0; i--) {
             if (isHotseatHorizontal) {
                 int cx = ((CellLayout.LayoutParams)
                         hotseatParent.getChildAt(i).getLayoutParams()).cellX;
                 matrix[cx][iconLayout.getCountY()] = iconParent.getChildCount() + i;
             } else {
                 int cy = ((CellLayout.LayoutParams)
                         hotseatParent.getChildAt(i).getLayoutParams()).cellY;
                 matrix[iconLayout.getCountX()][cy] = iconParent.getChildCount() + i;
             }
         }
         if (DEBUG) {
             printMatrix(matrix);
         }
         return matrix;
     }

     /**
      * Creates a sparse matrix that merges the icon of previous/next page and last column of
      * current page. When left key is triggered on the leftmost column, sparse matrix is created
      * that combines previous page matrix and an extra column on the right. Likewise, when right
      * key is triggered on the rightmost column, sparse matrix is created that combines this column
      * on the 0th column and the next page matrix.
      *
      * @param pivotX    x coordinate of the focused item in the current page
      * @param pivotY    y coordinate of the focused item in the current page
      */
     // TODO: get rid of the dynamic matrix creation
     public static int[][] createSparseMatrixWithPivotColumn(CellLayout iconLayout,
             int pivotX, int pivotY) {

         ViewGroup iconParent = iconLayout.getShortcutsAndWidgets();

         int[][] matrix = createFullMatrix(iconLayout.getCountX() + 1, iconLayout.getCountY());

         // Iterate thru the children of the top parent.
         for (int i = 0; i < iconParent.getChildCount(); i++) {
             View cell = iconParent.getChildAt(i);
             if (!cell.isFocusable()) {
                 continue;
             }
             int cx = ((CellLayout.LayoutParams) cell.getLayoutParams()).cellX;
             int cy = ((CellLayout.LayoutParams) cell.getLayoutParams()).cellY;
             if (pivotX < 0) {
                 matrix[cx - pivotX][cy] = i;
             } else {
                 matrix[cx][cy] = i;
             }
         }

         if (pivotX < 0) {
             matrix[0][pivotY] = PIVOT;
         } else {
             matrix[pivotX][pivotY] = PIVOT;
         }
         if (DEBUG) {
             printMatrix(matrix);
         }
         return matrix;
     }

     //
     // key event handling methods.
     //

     /**
      * Calculates icon that has is closest to the horizontal axis in reference to the cur icon.
      *
      * Example of the check order for KEYCODE_DPAD_RIGHT:
      * [  ][  ][13][14][15]
      * [  ][ 6][ 8][10][12]
      * [ X][ 1][ 2][ 3][ 4]
      * [  ][ 5][ 7][ 9][11]
      */
     // TODO: add unit tests to verify all permutation.
     private static int handleDpadHorizontal(int iconIdx, int cntX, int cntY,
             int[][] matrix, int increment, boolean isRtl) {
         if(matrix == null) {
             throw new IllegalStateException("Dpad navigation requires a matrix.");
         }
         int newIconIndex = NOOP;

         int xPos = -1;
         int yPos = -1;
         // Figure out the location of the icon.
         for (int i = 0; i < cntX; i++) {
             for (int j = 0; j < cntY; j++) {
                 if (matrix[i][j] == iconIdx) {
                     xPos = i;
                     yPos = j;
                 }
             }
         }
         if (DEBUG) {
             Log.v(TAG, String.format("\thandleDpadHorizontal: \t[x, y]=[%d, %d] iconIndex=%d",
                     xPos, yPos, iconIdx));
         }

         // Rule1: check first in the horizontal direction
         for (int x = xPos + increment; 0 <= x && x < cntX; x += increment) {
             if ((newIconIndex = inspectMatrix(x, yPos, cntX, cntY, matrix)) != NOOP
                     && newIconIndex != ALL_APPS_COLUMN) {
                 return newIconIndex;
             }
         }

         // Rule2: check (x1-n, yPos + increment),   (x1-n, yPos - increment)
         //              (x2-n, yPos + 2*increment), (x2-n, yPos - 2*increment)
         int nextYPos1;
         int nextYPos2;
         boolean haveCrossedAllAppsColumn1 = false;
         boolean haveCrossedAllAppsColumn2 = false;
         int x = -1;
         for (int coeff = 1; coeff < cntY; coeff++) {
             nextYPos1 = yPos + coeff * increment;
             nextYPos2 = yPos - coeff * increment;
             x = xPos + increment * coeff;
             if (inspectMatrix(x, nextYPos1, cntX, cntY, matrix) == ALL_APPS_COLUMN) {
                 haveCrossedAllAppsColumn1 = true;
             }
             if (inspectMatrix(x, nextYPos2, cntX, cntY, matrix) == ALL_APPS_COLUMN) {
                 haveCrossedAllAppsColumn2 = true;
             }
             for (; 0 <= x && x < cntX; x += increment) {
                 int offset1 = haveCrossedAllAppsColumn1 && x < cntX - 1 ? increment : 0;
                 newIconIndex = inspectMatrix(x, nextYPos1 + offset1, cntX, cntY, matrix);
                 if (newIconIndex != NOOP) {
                     return newIconIndex;
                 }
                 int offset2 = haveCrossedAllAppsColumn2 && x < cntX - 1 ? -increment : 0;
                 newIconIndex = inspectMatrix(x, nextYPos2 + offset2, cntX, cntY, matrix);
                 if (newIconIndex != NOOP) {
                     return newIconIndex;
                 }
             }
         }

         // Rule3: if switching between pages, do a brute-force search to find an item that was
         //        missed by rules 1 and 2 (such as when going from a bottom right icon to top left)
         if (iconIdx == PIVOT) {
             if (isRtl) {
                 return increment < 0 ? NEXT_PAGE_FIRST_ITEM : PREVIOUS_PAGE_LAST_ITEM;
             }
             return increment < 0 ? PREVIOUS_PAGE_LAST_ITEM : NEXT_PAGE_FIRST_ITEM;
         }
         return newIconIndex;
     }

     /**
      * Calculates icon that is closest to the vertical axis in reference to the current icon.
      *
      * Example of the check order for KEYCODE_DPAD_DOWN:
      * [  ][  ][  ][ X][  ][  ][  ]
      * [  ][  ][ 5][ 1][ 4][  ][  ]
      * [  ][10][ 7][ 2][ 6][ 9][  ]
      * [14][12][ 9][ 3][ 8][11][13]
      */
     // TODO: add unit tests to verify all permutation.
     private static int handleDpadVertical(int iconIndex, int cntX, int cntY,
             int [][] matrix, int increment) {
         int newIconIndex = NOOP;
         if(matrix == null) {
             throw new IllegalStateException("Dpad navigation requires a matrix.");
         }

         int xPos = -1;
         int yPos = -1;
         // Figure out the location of the icon.
         for (int i = 0; i< cntX; i++) {
             for (int j = 0; j < cntY; j++) {
                 if (matrix[i][j] == iconIndex) {
                     xPos = i;
                     yPos = j;
                 }
             }
         }

         if (DEBUG) {
             Log.v(TAG, String.format("\thandleDpadVertical: \t[x, y]=[%d, %d] iconIndex=%d",
                     xPos, yPos, iconIndex));
         }

         // Rule1: check first in the dpad direction
         for (int y = yPos + increment; 0 <= y && y <cntY && 0 <= y; y += increment) {
             if ((newIconIndex = inspectMatrix(xPos, y, cntX, cntY, matrix)) != NOOP
                     && newIconIndex != ALL_APPS_COLUMN) {
                 return newIconIndex;
             }
         }

         // Rule2: check (xPos + increment, y_(1-n)),   (xPos - increment, y_(1-n))
         //              (xPos + 2*increment, y_(2-n))), (xPos - 2*increment, y_(2-n))
         int nextXPos1;
         int nextXPos2;
         boolean haveCrossedAllAppsColumn1 = false;
         boolean haveCrossedAllAppsColumn2 = false;
         int y = -1;
         for (int coeff = 1; coeff < cntX; coeff++) {
             nextXPos1 = xPos + coeff * increment;
             nextXPos2 = xPos - coeff * increment;
             y = yPos + increment * coeff;
             if (inspectMatrix(nextXPos1, y, cntX, cntY, matrix) == ALL_APPS_COLUMN) {
                 haveCrossedAllAppsColumn1 = true;
             }
             if (inspectMatrix(nextXPos2, y, cntX, cntY, matrix) == ALL_APPS_COLUMN) {
                 haveCrossedAllAppsColumn2 = true;
             }
             for (; 0 <= y && y < cntY; y = y + increment) {
                 int offset1 = haveCrossedAllAppsColumn1 && y < cntY - 1 ? increment : 0;
                 newIconIndex = inspectMatrix(nextXPos1 + offset1, y, cntX, cntY, matrix);
                 if (newIconIndex != NOOP) {
                     return newIconIndex;
                 }
                 int offset2 = haveCrossedAllAppsColumn2 && y < cntY - 1 ? -increment : 0;
                 newIconIndex = inspectMatrix(nextXPos2 + offset2, y, cntX, cntY, matrix);
                 if (newIconIndex != NOOP) {
                     return newIconIndex;
                 }
             }
         }
         return newIconIndex;
     }

     private static int handleMoveHome() {
         return CURRENT_PAGE_FIRST_ITEM;
     }

     private static int handleMoveEnd() {
         return CURRENT_PAGE_LAST_ITEM;
     }

     private static int handlePageDown(int pageIndex, int pageCount) {
         if (pageIndex < pageCount -1) {
             return NEXT_PAGE_FIRST_ITEM;
         }
         return CURRENT_PAGE_LAST_ITEM;
     }

     private static int handlePageUp(int pageIndex) {
         if (pageIndex > 0) {
             return PREVIOUS_PAGE_FIRST_ITEM;
         } else {
             return CURRENT_PAGE_FIRST_ITEM;
         }
     }

     //
     // Helper methods.
     //

     private static boolean isValid(int xPos, int yPos, int countX, int countY) {
         return (0 <= xPos && xPos < countX && 0 <= yPos && yPos < countY);
     }

     private static int inspectMatrix(int x, int y, int cntX, int cntY, int[][] matrix) {
         int newIconIndex = NOOP;
         if (isValid(x, y, cntX, cntY)) {
             if (matrix[x][y] != -1) {
                 newIconIndex = matrix[x][y];
                 if (DEBUG) {
                     Log.v(TAG, String.format("\t\tinspect: \t[x, y]=[%d, %d] %d",
                             x, y, matrix[x][y]));
                 }
                 return newIconIndex;
             }
         }
         return newIconIndex;
     }

     /**
      * Only used for debugging.
      */
     private static String getStringIndex(int index) {
         switch(index) {
             case NOOP: return "NOOP";
             case PREVIOUS_PAGE_FIRST_ITEM:  return "PREVIOUS_PAGE_FIRST";
             case PREVIOUS_PAGE_LAST_ITEM:   return "PREVIOUS_PAGE_LAST";
             case PREVIOUS_PAGE_RIGHT_COLUMN:return "PREVIOUS_PAGE_RIGHT_COLUMN";
             case CURRENT_PAGE_FIRST_ITEM:   return "CURRENT_PAGE_FIRST";
             case CURRENT_PAGE_LAST_ITEM:    return "CURRENT_PAGE_LAST";
             case NEXT_PAGE_FIRST_ITEM:      return "NEXT_PAGE_FIRST";
             case NEXT_PAGE_LEFT_COLUMN:     return "NEXT_PAGE_LEFT_COLUMN";
             case ALL_APPS_COLUMN:           return "ALL_APPS_COLUMN";
             default:
                 return Integer.toString(index);
         }
     }

     /**
      * Only used for debugging.
      */
     private static void printMatrix(int[][] matrix) {
         Log.v(TAG, "\tprintMap:");
         int m = matrix.length;
         int n = matrix[0].length;

         for (int j=0; j < n; j++) {
             String colY = "\t\t";
             for (int i=0; i < m; i++) {
                 colY +=  String.format("%3d",matrix[i][j]);
             }
             Log.v(TAG, colY);
         }
     }

     /**
      * @param edgeColumn the column of the new icon. either {@link #NEXT_PAGE_LEFT_COLUMN} or
      * {@link #NEXT_PAGE_RIGHT_COLUMN}
      * @return the view adjacent to {@param oldView} in the {@param nextPage} of the folder.
      */
     public static View getAdjacentChildInNextFolderPage(
             ShortcutAndWidgetContainer nextPage, View oldView, int edgeColumn) {
         final int newRow = ((CellLayout.LayoutParams) oldView.getLayoutParams()).cellY;

         int column = (edgeColumn == NEXT_PAGE_LEFT_COLUMN) ^ nextPage.invertLayoutHorizontally()
                 ? 0 : (((CellLayout) nextPage.getParent()).getCountX() - 1);

         for (; column >= 0; column--) {
             for (int row = newRow; row >= 0; row--) {
                 View newView = nextPage.getChildAt(column, row);
                 if (newView != null) {
                     return newView;
                 }
             }
         }
         return null;
     }
 }
	/*
	* Copyright (C) 2015 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.launcher3.util;

	import android.util.Log;
	import android.view.KeyEvent;
	import android.view.View;
	import android.view.ViewGroup;

	import com.android.launcher3.CellLayout;
	import com.android.launcher3.DeviceProfile;
	import com.android.launcher3.ShortcutAndWidgetContainer;
	import com.android.launcher3.config.FeatureFlags;

	import java.util.Arrays;

	/**
	* Calculates the next item that a {@link KeyEvent} should change the focus to.
	*<p>
	* Note, this utility class calculates everything regards to icon index and its (x,y) coordinates.
	* Currently supports:
	* <ul>
	* <li> full matrix of cells that are 1x1
	* <li> sparse matrix of cells that are 1x1
	* [ 1][ ][ 2][ ]
	* [ ][ ][ 3][ ]
	* [ ][ 4][ ][ ]
	* [ ][ 5][ 6][ 7]
	* </ul>
	* *<p>
	* For testing, one can use a BT keyboard, or use following adb command.
	* ex. $ adb shell input keyevent 20 // KEYCODE_DPAD_LEFT
	*/
	public class FocusLogic {

	private static final String TAG = "FocusLogic";
	private static final boolean DEBUG = false;

	/** Item and page index related constant used by {@link #handleKeyEvent}. */
	public static final int NOOP = -1;

	public static final int PREVIOUS_PAGE_RIGHT_COLUMN = -2;
	public static final int PREVIOUS_PAGE_FIRST_ITEM = -3;
	public static final int PREVIOUS_PAGE_LAST_ITEM = -4;
	public static final int PREVIOUS_PAGE_LEFT_COLUMN = -5;

	public static final int CURRENT_PAGE_FIRST_ITEM = -6;
	public static final int CURRENT_PAGE_LAST_ITEM = -7;

	public static final int NEXT_PAGE_FIRST_ITEM = -8;
	public static final int NEXT_PAGE_LEFT_COLUMN = -9;
	public static final int NEXT_PAGE_RIGHT_COLUMN = -10;

	public static final int ALL_APPS_COLUMN = -11;

	// Matrix related constant.
	public static final int EMPTY = -1;
	public static final int PIVOT = 100;

	/**
	* Returns true only if this utility class handles the key code.
	*/
	public static boolean shouldConsume(int keyCode) {
	return (keyCode == KeyEvent.KEYCODE_DPAD_LEFT \|\| keyCode == KeyEvent.KEYCODE_DPAD_RIGHT \|\|
	keyCode == KeyEvent.KEYCODE_DPAD_UP \|\| keyCode == KeyEvent.KEYCODE_DPAD_DOWN \|\|
	keyCode == KeyEvent.KEYCODE_MOVE_HOME \|\| keyCode == KeyEvent.KEYCODE_MOVE_END \|\|
	keyCode == KeyEvent.KEYCODE_PAGE_UP \|\| keyCode == KeyEvent.KEYCODE_PAGE_DOWN);
	}

	public static int handleKeyEvent(int keyCode, int [][] map, int iconIdx, int pageIndex,
	int pageCount, boolean isRtl) {

	int cntX = map == null ? -1 : map.length;
	int cntY = map == null ? -1 : map[0].length;

	if (DEBUG) {
	Log.v(TAG, String.format(
	"handleKeyEvent START: cntX=%d, cntY=%d, iconIdx=%d, pageIdx=%d, pageCnt=%d",
	cntX, cntY, iconIdx, pageIndex, pageCount));
	}

	int newIndex = NOOP;
	switch (keyCode) {
	case KeyEvent.KEYCODE_DPAD_LEFT:
	newIndex = handleDpadHorizontal(iconIdx, cntX, cntY, map, -1 /increment/, isRtl);
	if (!isRtl && newIndex == NOOP && pageIndex > 0) {
	newIndex = PREVIOUS_PAGE_RIGHT_COLUMN;
	} else if (isRtl && newIndex == NOOP && pageIndex < pageCount - 1) {
	newIndex = NEXT_PAGE_RIGHT_COLUMN;
	}
	break;
	case KeyEvent.KEYCODE_DPAD_RIGHT:
	newIndex = handleDpadHorizontal(iconIdx, cntX, cntY, map, 1 /increment/, isRtl);
	if (!isRtl && newIndex == NOOP && pageIndex < pageCount - 1) {
	newIndex = NEXT_PAGE_LEFT_COLUMN;
	} else if (isRtl && newIndex == NOOP && pageIndex > 0) {
	newIndex = PREVIOUS_PAGE_LEFT_COLUMN;
	}
	break;
	case KeyEvent.KEYCODE_DPAD_DOWN:
	newIndex = handleDpadVertical(iconIdx, cntX, cntY, map, 1 /increment/);
	break;
	case KeyEvent.KEYCODE_DPAD_UP:
	newIndex = handleDpadVertical(iconIdx, cntX, cntY, map, -1 /increment/);
	break;
	case KeyEvent.KEYCODE_MOVE_HOME:
	newIndex = handleMoveHome();
	break;
	case KeyEvent.KEYCODE_MOVE_END:
	newIndex = handleMoveEnd();
	break;
	case KeyEvent.KEYCODE_PAGE_DOWN:
	newIndex = handlePageDown(pageIndex, pageCount);
	break;
	case KeyEvent.KEYCODE_PAGE_UP:
	newIndex = handlePageUp(pageIndex);
	break;
	default:
	break;
	}

	if (DEBUG) {
	Log.v(TAG, String.format("handleKeyEvent FINISH: index [%d -> %s]",
	iconIdx, getStringIndex(newIndex)));
	}
	return newIndex;
	}

	/**
	* Returns a matrix of size (m x n) that has been initialized with {@link #EMPTY}.
	*
	* @param m number of columns in the matrix
	* @param n number of rows in the matrix
	*/
	// TODO: get rid of dynamic matrix creation.
	private static int[][] createFullMatrix(int m, int n) {
	int[][] matrix = new int [m][n];

	for (int i=0; i < m;i++) {
	Arrays.fill(matrix[i], EMPTY);
	}
	return matrix;
	}

	/**
	* Returns a matrix of size same as the {@link CellLayout} dimension that is initialized with the
	* index of the child view.
	*/
	// TODO: get rid of the dynamic matrix creation
	public static int[][] createSparseMatrix(CellLayout layout) {
	ShortcutAndWidgetContainer parent = layout.getShortcutsAndWidgets();
	final int m = layout.getCountX();
	final int n = layout.getCountY();
	final boolean invert = parent.invertLayoutHorizontally();

	int[][] matrix = createFullMatrix(m, n);

	// Iterate thru the children.
	for (int i = 0; i < parent.getChildCount(); i++ ) {
	View cell = parent.getChildAt(i);
	if (!cell.isFocusable()) {
	continue;
	}
	int cx = ((CellLayout.LayoutParams) cell.getLayoutParams()).cellX;
	int cy = ((CellLayout.LayoutParams) cell.getLayoutParams()).cellY;
	matrix[invert ? (m - cx - 1) : cx][cy] = i;
	}
	if (DEBUG) {
	printMatrix(matrix);
	}
	return matrix;
	}

	/**
	* Creates a sparse matrix that merges the icon and hotseat view group using the cell layout.
	* The size of the returning matrix is [icon column count x (icon + hotseat row count)]
	* in portrait orientation. In landscape, [(icon + hotseat) column count x (icon row count)]
	*/
	// TODO: get rid of the dynamic matrix creation
	public static int[][] createSparseMatrixWithHotseat(
	CellLayout iconLayout, CellLayout hotseatLayout, DeviceProfile dp) {

	ViewGroup iconParent = iconLayout.getShortcutsAndWidgets();
	ViewGroup hotseatParent = hotseatLayout.getShortcutsAndWidgets();

	boolean isHotseatHorizontal = !dp.isVerticalBarLayout();
	boolean moreIconsInHotseatThanWorkspace = !FeatureFlags.NO_ALL_APPS_ICON &&
	(isHotseatHorizontal
	? hotseatLayout.getCountX() > iconLayout.getCountX()
	: hotseatLayout.getCountY() > iconLayout.getCountY());

	int m, n;
	if (isHotseatHorizontal) {
	m = hotseatLayout.getCountX();
	n = iconLayout.getCountY() + hotseatLayout.getCountY();
	} else {
	m = iconLayout.getCountX() + hotseatLayout.getCountX();
	n = hotseatLayout.getCountY();
	}
	int[][] matrix = createFullMatrix(m, n);
	if (moreIconsInHotseatThanWorkspace) {
	int allappsiconRank = dp.inv.getAllAppsButtonRank();
	if (isHotseatHorizontal) {
	for (int j = 0; j < n; j++) {
	matrix[allappsiconRank][j] = ALL_APPS_COLUMN;
	}
	} else {
	for (int j = 0; j < m; j++) {
	matrix[j][allappsiconRank] = ALL_APPS_COLUMN;
	}
	}
	}
	// Iterate thru the children of the workspace.
	for (int i = 0; i < iconParent.getChildCount(); i++) {
	View cell = iconParent.getChildAt(i);
	if (!cell.isFocusable()) {
	continue;
	}
	int cx = ((CellLayout.LayoutParams) cell.getLayoutParams()).cellX;
	int cy = ((CellLayout.LayoutParams) cell.getLayoutParams()).cellY;
	if (moreIconsInHotseatThanWorkspace) {
	int allappsiconRank = dp.inv.getAllAppsButtonRank();
	if (isHotseatHorizontal && cx >= allappsiconRank) {
	// Add 1 to account for the All Apps button.
	cx++;
	}
	if (!isHotseatHorizontal && cy >= allappsiconRank) {
	// Add 1 to account for the All Apps button.
	cy++;
	}
	}
	matrix[cx][cy] = i;
	}

	// Iterate thru the children of the hotseat.
	for (int i = hotseatParent.getChildCount() - 1; i >= 0; i--) {
	if (isHotseatHorizontal) {
	int cx = ((CellLayout.LayoutParams)
	hotseatParent.getChildAt(i).getLayoutParams()).cellX;
	matrix[cx][iconLayout.getCountY()] = iconParent.getChildCount() + i;
	} else {
	int cy = ((CellLayout.LayoutParams)
	hotseatParent.getChildAt(i).getLayoutParams()).cellY;
	matrix[iconLayout.getCountX()][cy] = iconParent.getChildCount() + i;
	}
	}
	if (DEBUG) {
	printMatrix(matrix);
	}
	return matrix;
	}

	/**
	* Creates a sparse matrix that merges the icon of previous/next page and last column of
	* current page. When left key is triggered on the leftmost column, sparse matrix is created
	* that combines previous page matrix and an extra column on the right. Likewise, when right
	* key is triggered on the rightmost column, sparse matrix is created that combines this column
	* on the 0th column and the next page matrix.
	*
	* @param pivotX x coordinate of the focused item in the current page
	* @param pivotY y coordinate of the focused item in the current page
	*/
	// TODO: get rid of the dynamic matrix creation
	public static int[][] createSparseMatrixWithPivotColumn(CellLayout iconLayout,
	int pivotX, int pivotY) {

	ViewGroup iconParent = iconLayout.getShortcutsAndWidgets();

	int[][] matrix = createFullMatrix(iconLayout.getCountX() + 1, iconLayout.getCountY());

	// Iterate thru the children of the top parent.
	for (int i = 0; i < iconParent.getChildCount(); i++) {
	View cell = iconParent.getChildAt(i);
	if (!cell.isFocusable()) {
	continue;
	}
	int cx = ((CellLayout.LayoutParams) cell.getLayoutParams()).cellX;
	int cy = ((CellLayout.LayoutParams) cell.getLayoutParams()).cellY;
	if (pivotX < 0) {
	matrix[cx - pivotX][cy] = i;
	} else {
	matrix[cx][cy] = i;
	}
	}

	if (pivotX < 0) {
	matrix[0][pivotY] = PIVOT;
	} else {
	matrix[pivotX][pivotY] = PIVOT;
	}
	if (DEBUG) {
	printMatrix(matrix);
	}
	return matrix;
	}

	//
	// key event handling methods.
	//

	/**
	* Calculates icon that has is closest to the horizontal axis in reference to the cur icon.
	*
	* Example of the check order for KEYCODE_DPAD_RIGHT:
	* [ ][ ][13][14][15]
	* [ ][ 6][ 8][10][12]
	* [ X][ 1][ 2][ 3][ 4]
	* [ ][ 5][ 7][ 9][11]
	*/
	// TODO: add unit tests to verify all permutation.
	private static int handleDpadHorizontal(int iconIdx, int cntX, int cntY,
	int[][] matrix, int increment, boolean isRtl) {
	if(matrix == null) {
	throw new IllegalStateException("Dpad navigation requires a matrix.");
	}
	int newIconIndex = NOOP;

	int xPos = -1;
	int yPos = -1;
	// Figure out the location of the icon.
	for (int i = 0; i < cntX; i++) {
	for (int j = 0; j < cntY; j++) {
	if (matrix[i][j] == iconIdx) {
	xPos = i;
	yPos = j;
	}
	}
	}
	if (DEBUG) {
	Log.v(TAG, String.format("\thandleDpadHorizontal: \t[x, y]=[%d, %d] iconIndex=%d",
	xPos, yPos, iconIdx));
	}

	// Rule1: check first in the horizontal direction
	for (int x = xPos + increment; 0 <= x && x < cntX; x += increment) {
	if ((newIconIndex = inspectMatrix(x, yPos, cntX, cntY, matrix)) != NOOP
	&& newIconIndex != ALL_APPS_COLUMN) {
	return newIconIndex;
	}
	}

	// Rule2: check (x1-n, yPos + increment), (x1-n, yPos - increment)
	// (x2-n, yPos + 2increment), (x2-n, yPos - 2increment)
	int nextYPos1;
	int nextYPos2;
	boolean haveCrossedAllAppsColumn1 = false;
	boolean haveCrossedAllAppsColumn2 = false;
	int x = -1;
	for (int coeff = 1; coeff < cntY; coeff++) {
	nextYPos1 = yPos + coeff * increment;
	nextYPos2 = yPos - coeff * increment;
	x = xPos + increment * coeff;
	if (inspectMatrix(x, nextYPos1, cntX, cntY, matrix) == ALL_APPS_COLUMN) {
	haveCrossedAllAppsColumn1 = true;
	}
	if (inspectMatrix(x, nextYPos2, cntX, cntY, matrix) == ALL_APPS_COLUMN) {
	haveCrossedAllAppsColumn2 = true;
	}
	for (; 0 <= x && x < cntX; x += increment) {
	int offset1 = haveCrossedAllAppsColumn1 && x < cntX - 1 ? increment : 0;
	newIconIndex = inspectMatrix(x, nextYPos1 + offset1, cntX, cntY, matrix);
	if (newIconIndex != NOOP) {
	return newIconIndex;
	}
	int offset2 = haveCrossedAllAppsColumn2 && x < cntX - 1 ? -increment : 0;
	newIconIndex = inspectMatrix(x, nextYPos2 + offset2, cntX, cntY, matrix);
	if (newIconIndex != NOOP) {
	return newIconIndex;
	}
	}
	}

	// Rule3: if switching between pages, do a brute-force search to find an item that was
	// missed by rules 1 and 2 (such as when going from a bottom right icon to top left)
	if (iconIdx == PIVOT) {
	if (isRtl) {
	return increment < 0 ? NEXT_PAGE_FIRST_ITEM : PREVIOUS_PAGE_LAST_ITEM;
	}
	return increment < 0 ? PREVIOUS_PAGE_LAST_ITEM : NEXT_PAGE_FIRST_ITEM;
	}
	return newIconIndex;
	}

	/**
	* Calculates icon that is closest to the vertical axis in reference to the current icon.
	*
	* Example of the check order for KEYCODE_DPAD_DOWN:
	* [ ][ ][ ][ X][ ][ ][ ]
	* [ ][ ][ 5][ 1][ 4][ ][ ]
	* [ ][10][ 7][ 2][ 6][ 9][ ]
	* [14][12][ 9][ 3][ 8][11][13]
	*/
	// TODO: add unit tests to verify all permutation.
	private static int handleDpadVertical(int iconIndex, int cntX, int cntY,
	int [][] matrix, int increment) {
	int newIconIndex = NOOP;
	if(matrix == null) {
	throw new IllegalStateException("Dpad navigation requires a matrix.");
	}

	int xPos = -1;
	int yPos = -1;
	// Figure out the location of the icon.
	for (int i = 0; i< cntX; i++) {
	for (int j = 0; j < cntY; j++) {
	if (matrix[i][j] == iconIndex) {
	xPos = i;
	yPos = j;
	}
	}
	}

	if (DEBUG) {
	Log.v(TAG, String.format("\thandleDpadVertical: \t[x, y]=[%d, %d] iconIndex=%d",
	xPos, yPos, iconIndex));
	}

	// Rule1: check first in the dpad direction
	for (int y = yPos + increment; 0 <= y && y <cntY && 0 <= y; y += increment) {
	if ((newIconIndex = inspectMatrix(xPos, y, cntX, cntY, matrix)) != NOOP
	&& newIconIndex != ALL_APPS_COLUMN) {
	return newIconIndex;
	}
	}

	// Rule2: check (xPos + increment, y_(1-n)), (xPos - increment, y_(1-n))
	// (xPos + 2increment, y_(2-n))), (xPos - 2increment, y_(2-n))
	int nextXPos1;
	int nextXPos2;
	boolean haveCrossedAllAppsColumn1 = false;
	boolean haveCrossedAllAppsColumn2 = false;
	int y = -1;
	for (int coeff = 1; coeff < cntX; coeff++) {
	nextXPos1 = xPos + coeff * increment;
	nextXPos2 = xPos - coeff * increment;
	y = yPos + increment * coeff;
	if (inspectMatrix(nextXPos1, y, cntX, cntY, matrix) == ALL_APPS_COLUMN) {
	haveCrossedAllAppsColumn1 = true;
	}
	if (inspectMatrix(nextXPos2, y, cntX, cntY, matrix) == ALL_APPS_COLUMN) {
	haveCrossedAllAppsColumn2 = true;
	}
	for (; 0 <= y && y < cntY; y = y + increment) {
	int offset1 = haveCrossedAllAppsColumn1 && y < cntY - 1 ? increment : 0;
	newIconIndex = inspectMatrix(nextXPos1 + offset1, y, cntX, cntY, matrix);
	if (newIconIndex != NOOP) {
	return newIconIndex;
	}
	int offset2 = haveCrossedAllAppsColumn2 && y < cntY - 1 ? -increment : 0;
	newIconIndex = inspectMatrix(nextXPos2 + offset2, y, cntX, cntY, matrix);
	if (newIconIndex != NOOP) {
	return newIconIndex;
	}
	}
	}
	return newIconIndex;
	}

	private static int handleMoveHome() {
	return CURRENT_PAGE_FIRST_ITEM;
	}

	private static int handleMoveEnd() {
	return CURRENT_PAGE_LAST_ITEM;
	}

	private static int handlePageDown(int pageIndex, int pageCount) {
	if (pageIndex < pageCount -1) {
	return NEXT_PAGE_FIRST_ITEM;
	}
	return CURRENT_PAGE_LAST_ITEM;
	}

	private static int handlePageUp(int pageIndex) {
	if (pageIndex > 0) {
	return PREVIOUS_PAGE_FIRST_ITEM;
	} else {
	return CURRENT_PAGE_FIRST_ITEM;
	}
	}

	//
	// Helper methods.
	//

	private static boolean isValid(int xPos, int yPos, int countX, int countY) {
	return (0 <= xPos && xPos < countX && 0 <= yPos && yPos < countY);
	}

	private static int inspectMatrix(int x, int y, int cntX, int cntY, int[][] matrix) {
	int newIconIndex = NOOP;
	if (isValid(x, y, cntX, cntY)) {
	if (matrix[x][y] != -1) {
	newIconIndex = matrix[x][y];
	if (DEBUG) {
	Log.v(TAG, String.format("\t\tinspect: \t[x, y]=[%d, %d] %d",
	x, y, matrix[x][y]));
	}
	return newIconIndex;
	}
	}
	return newIconIndex;
	}

	/**
	* Only used for debugging.
	*/
	private static String getStringIndex(int index) {
	switch(index) {
	case NOOP: return "NOOP";
	case PREVIOUS_PAGE_FIRST_ITEM: return "PREVIOUS_PAGE_FIRST";
	case PREVIOUS_PAGE_LAST_ITEM: return "PREVIOUS_PAGE_LAST";
	case PREVIOUS_PAGE_RIGHT_COLUMN:return "PREVIOUS_PAGE_RIGHT_COLUMN";
	case CURRENT_PAGE_FIRST_ITEM: return "CURRENT_PAGE_FIRST";
	case CURRENT_PAGE_LAST_ITEM: return "CURRENT_PAGE_LAST";
	case NEXT_PAGE_FIRST_ITEM: return "NEXT_PAGE_FIRST";
	case NEXT_PAGE_LEFT_COLUMN: return "NEXT_PAGE_LEFT_COLUMN";
	case ALL_APPS_COLUMN: return "ALL_APPS_COLUMN";
	default:
	return Integer.toString(index);
	}
	}

	/**
	* Only used for debugging.
	*/
	private static void printMatrix(int[][] matrix) {
	Log.v(TAG, "\tprintMap:");
	int m = matrix.length;
	int n = matrix[0].length;

	for (int j=0; j < n; j++) {
	String colY = "\t\t";
	for (int i=0; i < m; i++) {
	colY += String.format("%3d",matrix[i][j]);
	}
	Log.v(TAG, colY);
	}
	}

	/**
	* @param edgeColumn the column of the new icon. either {@link #NEXT_PAGE_LEFT_COLUMN} or
	* {@link #NEXT_PAGE_RIGHT_COLUMN}
	* @return the view adjacent to {@param oldView} in the {@param nextPage} of the folder.
	*/
	public static View getAdjacentChildInNextFolderPage(
	ShortcutAndWidgetContainer nextPage, View oldView, int edgeColumn) {
	final int newRow = ((CellLayout.LayoutParams) oldView.getLayoutParams()).cellY;

	int column = (edgeColumn == NEXT_PAGE_LEFT_COLUMN) ^ nextPage.invertLayoutHorizontally()
	? 0 : (((CellLayout) nextPage.getParent()).getCountX() - 1);

	for (; column >= 0; column--) {
	for (int row = newRow; row >= 0; row--) {
	View newView = nextPage.getChildAt(column, row);
	if (newView != null) {
	return newView;
	}
	}
	}
	return null;
	}
	}