The main feature in any image editor application like Phimpme Android other than editing the image is the ability to revert the changes (UNDO) that are done and the ability to revert the reversion i.e reperform the changes (REDO).
In Phimpme Application, we implemented this by using an ArrayList of Bitmaps. We stored the copy of the image bitmap whenever the modification is done on it. This helped us to get back to the previous image when required. But there is a problem in this method. They method may produce OutOfMemory Error when storing the bitmap in ArrayList when memory gets full. So for dealing solving this in the Phimpme application, we added a try – catch block and when the out of memory exception is caught, we recycled and removed the initial modified image from list i.e the image of index 1 in ArrayList. Index 0 is the original image on which we are working on. When we recycled that image, it gives space for adding another image, So added the recent image at the end of the list.
addToUndoList() function is shown below.
private void addToUndoList() {
try{
recycleBitmapList(++currentShowingIndex);
bitmapsForUndo.add(mainBitmap.copy(mainBitmap.getConfig(),true));
}catch (OutOfMemoryError error){
bitmapsForUndo.get(1).recycle();
bitmapsForUndo.remove(1);
bitmapsForUndo.add(mainBitmap.copy(mainBitmap.getConfig(),true));
}
}
In the above function, bitmapsForUndo is ArrayList in which we added modified bitmaps in the editor of Phimpme application. mainBitmap is the image bitmap on which all modifications are being done in the editor. The sense of integer variable currentShowingIndex is clear from its name that it points to the index of the image that is currently getting shown.
Eg. Consider a case when you perform 5 edits on an image using Phimpme Editor, then 6 image bitmaps get stored in the ArrayList including the original image and currentShowingIndex will be 5. Now if you undo the steps twice the currentShowingIndex becomes 3. The bitmaps of the index 4 and 5 have not been removed from the ArrayList yet. So they will be useful if you want to redo the changes.
When you make an another edit, an image bitmap gets added at index 4 and that should be the last element of the ArrayList. But you see that there is a bitmap of index 5 making that the last element of the ArrayList, not the newly added one. So in order to achieve that, the elements present in the ArrayList whose index is greater than currentShowingIndex have to recycled and removed before adding a newly modified image bitmap to the ArrayList. The first line in the try block of the above functions is referring to the function that is going to implement this. That function’s implementation is given below
private void recycleBitmapList(int fromIndex){
while (fromIndex < bitmapsForUndo.size()){
bitmapsForUndo.get(fromIndex).recycle();
bitmapsForUndo.remove(fromIndex);
}
}
Removing the bitmap from the ArrayList doesn’t clear the memory. That bitmap has to be recycled before getting removed from the ArrayList which is performed in the above function of the Phimpme application’s image editor. The above recycleBitmapList function recycles and removes the bitmaps which have an index greater than or equal to the index that is passed as an argument to that function.
This function should also be called in onDestroy function of android activity as
recycleBitmapList(0);
This recycles and removes the whole ArrayList.
As now the implementation of the creation and recycling of the ArrayList is done, we can use this ArrayList to create getter functions for the undo and redo bitmaps. When the getUndoBitmap() is called the currentShowingIndex should decrement by one if greater than zero. When getRedoBitmap() is called the currentShowingIndex has to be incremented by one until it gets equal to the index of the last element present in the array list.
These methods are shown below.
private Bitmap getUndoBitmap(){
if (currentShowingIndex - 1 >= 0)
currentShowingIndex -= 1;
else currentShowingIndex = 0;
return bitmapsForUndo
.get(currentShowingIndex)
.copy(bitmapsForUndo.get(currentShowingIndex).getConfig(), true);
}
private Bitmap getRedoBitmap(){
if (currentShowingIndex + 1 <= bitmapsForUndo.size())
currentShowingIndex += 1;
else currentShowingIndex = bitmapsForUndo.size() - 1;
return bitmapsForUndo
.get(currentShowingIndex)
.copy(bitmapsForUndo.get(currentShowingIndex).getConfig(), true);
}
Logic part is done by here. We integrated these getter functions to button click functions of Phimpme Image Editor. setButtonVisibility() is called whenever undo or redo is button is pressed. This function sets the enable state and visibility of the button i.e the undo button is visible and enabled only if undo is possible. So does for the redo button.
setButtonVisibility() is shown below.
private void setButtonsVisibility() {
if (currentShowingIndex > 0) {
undo.setColorFilter(Color.BLACK);
undo.setEnabled(true);
}else {
undo.setColorFilter(Color.GRAY);
undo.setEnabled(false);
}
if (currentShowingIndex + 1 < bitmapsForUndo.size()) {
redo.setColorFilter(Color.BLACK);
redo.setEnabled(true);
}else {
redo.setColorFilter(Color.GRAY);
redo.setEnabled(false);
}
}
The above function grays the button if it is in the disabled state and will be black when the enabled state conditions are satisfied.
Finally, the OnClick() function of the editor of Phimpme is shown below.
@Override
public void onClick(View v) {
switch (v.getId()){
case R.id.edit_undo:
onUndoPressed();
break;
case R.id.edit_redo:
onRedoPressed();
break;
}
}
private void onUndoPressed() {
if (mainBitmap != null) {
if (!mainBitmap.isRecycled()) {
mainBitmap.recycle();
}
}
mainBitmap = getUndoBitmap();
mainImage.setImageBitmap(mainBitmap);
setButtonsVisibility();
}
private void onRedoPressed() {
if (mainBitmap != null) {
if (!mainBitmap.isRecycled()) {
mainBitmap.recycle();
}
}
mainBitmap = getRedoBitmap();
mainImage.setImageBitmap(mainBitmap);
setButtonsVisibility();
}
This shows how we implemented undo and redo in Image Editor of Phimpme Image Application.