preserving tile order when orientation changes

Author: unknown

res/layout/activity_main.xml

@@ -4,10 +4,10 @@
     android:layout_height="match_parent"
     android:padding="5dp" >
 
-    <cz.destil.sliderpuzzle.ui.GameboardView
+    <cz.destil.sliderpuzzle.ui.GameBoardView
         android:id="@+id/gameboard"
         android:layout_width="match_parent"
         android:layout_height="match_parent" >
-    </cz.destil.sliderpuzzle.ui.GameboardView>
+    </cz.destil.sliderpuzzle.ui.GameBoardView>
 
 </LinearLayout>

src/cz/destil/sliderpuzzle/ui/GameboardView.java

@@ -1,6 +1,7 @@
 package cz.destil.sliderpuzzle.ui;
 
 import java.util.ArrayList;
+import java.util.LinkedList;
 
 import android.animation.Animator;
 import android.animation.Animator.AnimatorListener;
@@ -34,7 +35,7 @@
  * @author David Vavra
  * 
  */
-public class GameboardView extends RelativeLayout implements OnTouchListener {
+public class GameBoardView extends RelativeLayout implements OnTouchListener {
 
 	public static final int GRID_SIZE = 4; // 4x4
 	private int tileSize;
@@ -44,8 +45,9 @@ public class GameboardView extends RelativeLayout implements OnTouchListener {
 	private RectF gameboardRect;
 	private PointF lastDragPoint;
 	private ArrayList<GameTileMotionDescriptor> currentMotionDescriptors;
+	private LinkedList<Integer> tileOrder;
 
-	public GameboardView(Context context, AttributeSet attrSet) {
+	public GameBoardView(Context context, AttributeSet attrSet) {
 		super(context, attrSet);
 	}
 
@@ -89,10 +91,20 @@ public void fillTiles() {
 		Bitmap original = ((BitmapDrawable) globe).getBitmap();
 		TileSlicer tileSlicer = new TileSlicer(original, GRID_SIZE, getContext());
 		// fill gameboard with slices
+		if (tileOrder == null) {
+			tileSlicer.randomizeSlices();
+		} else {
+			tileSlicer.setSliceOrder(tileOrder);
+		}
 		tiles = new ArrayList<TileView>();
 		for (int rowI = 0; rowI < GRID_SIZE; rowI++) {
 			for (int colI = 0; colI < GRID_SIZE; colI++) {
-				TileView tile = tileSlicer.getSlice(TileSlicer.RANDOM_SLICE);
+				TileView tile;
+				if (tileOrder == null) {
+					tile = tileSlicer.getTile();
+				} else {
+					tile = tileSlicer.getTile();
+				}
 				tile.coordinate = new Coordinate(rowI, colI);
 				if (tile.isEmpty()) {
 					emptyTile = tile;
@@ -186,8 +198,8 @@ private boolean lastDragMovedMinimally() {
 	}
 
 	/**
-	 * Follows finger while dragging all currently moved tiles.
-	 * Allows movement only along x axis for row and y axis for column.
+	 * Follows finger while dragging all currently moved tiles. Allows movement
+	 * only along x axis for row and y axis for column.
 	 * 
 	 * @param event
 	 */
@@ -454,6 +466,32 @@ private Rect rectForCoordinate(Coordinate coordinate) {
 		return new Rect(left, top, left + tileSize, top + tileSize);
 	}
 
+	/**
+	 * Returns current tile locations. Useful for preserving state when
+	 * orientation changes.
+	 * 
+	 * @return current tile locations
+	 */
+	public LinkedList<Integer> getTileOrder() {
+		LinkedList<Integer> tileLocations = new LinkedList<Integer>();
+		for (int rowI = 0; rowI < GRID_SIZE; rowI++) {
+			for (int colI = 0; colI < GRID_SIZE; colI++) {
+				TileView tile = getTileAtCoordinate(new Coordinate(rowI, colI));
+				tileLocations.add(tile.originalIndex);
+			}
+		}
+		return tileLocations;
+	}
+
+	/**
+	 * Sets tile locations from previous state.
+	 * 
+	 * @param tileLocations list of integers marking order
+	 */
+	public void setTileOrder(LinkedList<Integer> tileLocations) {
+		this.tileOrder = tileLocations;
+	}
+
 	/**
 	 * Describes movement of the tile. It is used to move several tiles at once.
 	 */

src/cz/destil/sliderpuzzle/ui/MainActivity.java

@@ -1,7 +1,10 @@
 package cz.destil.sliderpuzzle.ui;
 
+import java.util.LinkedList;
+
 import android.content.Intent;
 import android.os.Bundle;
+import android.util.Log;
 
 import com.actionbarsherlock.app.SherlockActivity;
 import com.actionbarsherlock.view.Menu;
@@ -19,10 +22,20 @@
  */
 public class MainActivity extends SherlockActivity {
 
+	private GameBoardView gameBoard;
+
 	@Override
 	public void onCreate(Bundle savedInstanceState) {
 		super.onCreate(savedInstanceState);
 		setContentView(R.layout.activity_main);
+		gameBoard = (GameBoardView) findViewById(R.id.gameboard);
+		// use preserved tile locations when orientation changed
+		@SuppressWarnings({ "deprecation", "unchecked" })
+		final LinkedList<Integer> tileOrder = (LinkedList<Integer>) getLastNonConfigurationInstance();
+		if (tileOrder != null) {
+			Log.d("tile locations",tileOrder.toString());
+			gameBoard.setTileOrder(tileOrder);
+		}
 	}
 
 	@Override
@@ -36,8 +49,8 @@ public boolean onCreateOptionsMenu(Menu menu) {
 	public boolean onOptionsItemSelected(MenuItem item) {
 		switch (item.getItemId()) {
 		case R.id.new_game:
-			GameboardView gameboard = (GameboardView) findViewById(R.id.gameboard);
-			gameboard.fillTiles();
+			gameBoard.setTileOrder(null);
+			gameBoard.fillTiles();
 			return true;
 		case R.id.about:
 			startActivity(new Intent(this, AboutActivity.class));
@@ -47,5 +60,10 @@ public boolean onOptionsItemSelected(MenuItem item) {
 		}
 	}
 
-	// TODO: preserve state when rotated
+	@Override
+	public Object onRetainNonConfigurationInstance() {
+		// preserve state when rotated
+		Log.d("tile locations",gameBoard.getTileOrder().toString());
+		return gameBoard.getTileOrder();
+	}
 }

src/cz/destil/sliderpuzzle/util/TileSlicer.java

@@ -1,7 +1,8 @@
 package cz.destil.sliderpuzzle.util;
 
-import java.util.ArrayList;
-import java.util.Random;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
 
 import android.content.Context;
 import android.graphics.Bitmap;
@@ -26,8 +27,9 @@ public class TileSlicer {
 	public static final int RANDOM_SLICE = -1;
 	private Bitmap original;
 	private int tileSize, gridSize;
-	private ArrayList<Bitmap> slices;
-	private Random random;
+	private List<Bitmap> slices;
+	private int lastSliceServed;
+	private List<Integer> sliceOrder;
 	private Context context;
 
 	/**
@@ -44,8 +46,7 @@ public TileSlicer(Bitmap original, int gridSize, Context context) {
 		this.gridSize = gridSize;
 		this.tileSize = original.getWidth() / gridSize;
 		this.context = context;
-		random = new Random();
-		slices = new ArrayList<Bitmap>();
+		slices = new LinkedList<Bitmap>();
 		sliceOriginal();
 	}
 
@@ -55,32 +56,66 @@ public TileSlicer(Bitmap original, int gridSize, Context context) {
 	private void sliceOriginal() {
 		int x, y;
 		Bitmap bitmap;
+		lastSliceServed = 0;
 		for (int rowI = 0; rowI < gridSize; rowI++) {
 			for (int colI = 0; colI < gridSize; colI++) {
 				// don't slice last part - empty slice
 				if (rowI == gridSize - 1 && colI == gridSize - 1) {
 					continue;
+				} else {
+					x = rowI * tileSize;
+					y = colI * tileSize;
+					// slice
+					bitmap = Bitmap.createBitmap(original, x, y, tileSize, tileSize);
+					// draw border lines
+					Canvas canvas = new Canvas(bitmap);
+					Paint paint = new Paint();
+					paint.setColor(Color.parseColor("#fbfdff"));
+					int end = tileSize - 1;
+					canvas.drawLine(0, 0, 0, end, paint);
+					canvas.drawLine(0, end, end, end, paint);
+					canvas.drawLine(end, end, end, 0, paint);
+					canvas.drawLine(end, 0, 0, 0, paint);
+					slices.add(bitmap);
 				}
-				x = rowI * tileSize;
-				y = colI * tileSize;
-				// slice
-				bitmap = Bitmap.createBitmap(original, x, y, tileSize, tileSize);
-				// draw border lines
-				Canvas canvas = new Canvas(bitmap);
-				Paint paint = new Paint();
-				paint.setColor(Color.parseColor("#fbfdff"));
-				int end = tileSize - 1;
-				canvas.drawLine(0, 0, 0, end, paint);
-				canvas.drawLine(0, end, end, end, paint);
-				canvas.drawLine(end, end, end, 0, paint);
-				canvas.drawLine(end, 0, 0, 0, paint);
-				slices.add(bitmap);
 			}
 		}
 		// remove original bitmap from memory
 		original = null;
 	}
 
+	/**
+	 * Randomizes slices in case no previous instance is available.
+	 */
+	public void randomizeSlices() {
+		// randomize first 15 slices
+		Collections.shuffle(slices);
+		// last one is empty slice
+		slices.add(null);
+		sliceOrder = null;
+	}
+
+	/**
+	 * Sets slice order in case of previous instance is available, eg. from
+	 * screen rotation.
+	 * 
+	 * @param order
+	 *            list of integers marking order of slices
+	 */
+	public void setSliceOrder(List<Integer> order) {
+		List<Bitmap> newSlices = new LinkedList<Bitmap>();
+		for (int o : order) {
+			if (o < slices.size()) {
+				newSlices.add(slices.get(o));
+			} else {
+				// empty slice
+				newSlices.add(null);
+			}
+		}
+		sliceOrder = order;
+		slices = newSlices;
+	}
+
 	/**
 	 * Serves slice and frees it from memory
 	 * 
@@ -90,18 +125,21 @@ private void sliceOriginal() {
 	 * @return TileView with the image or empty tile if there are no such
 	 *         slices.
 	 */
-	public TileView getSlice(int index) {
+	public TileView getTile() {
 		TileView tile = null;
 		if (slices.size() > 0) {
-			if (index == RANDOM_SLICE) {
-				index = random.nextInt(slices.size());
+			int originalIndex;
+			if (sliceOrder == null) {
+				originalIndex = lastSliceServed++;
+			} else {
+				originalIndex = sliceOrder.get(lastSliceServed++);
+			}
+			tile = new TileView(context, originalIndex);
+			if (slices.get(0) == null) {
+				// empty slice
+				tile.setEmpty(true);
 			}
-			tile = new TileView(context, index);
-			tile.setImageBitmap(slices.remove(index));
-		} else {
-			// empty slice
-			tile = new TileView(context, index);
-			tile.setEmpty(true);
+			tile.setImageBitmap(slices.remove(0));
 		}
 		return tile;
 	}