1.description:
An
android app has some limitations when it comes to memory availability. Unlike a
normal Java app, you do not have luxury of expanding memory your application
uses, as it will be completely dependent on the device on which the app is
running, memory available in the phone, number of applications running
simultaneously. We will not have control over these external factors so we will
need to optimize memory usage on our end.
· Use
of flags: Set android:hardwareAccelerated=”true” and android:largeHeap=”true”
flags in manifest file. Downside is that these flags are only available after
android 3.0. More than 50% of android devices still run on gingerbread (2.3+),
so this is not a very reliable solution if you are targeting a larger audience.
Though worth a try for high end (3.0+) devices.
· Memory leakage: DVM garbage collection works n principle of
JVM garbage collection, that is it will reclaim the memory for an object if
there is no reference to it. So make sure when you are done with an object and
do not need it anymore, mark the object reference as null.
·
Use minimum space for an object: Design your classes
intelligently, for example if you are handling student data and you address
details will not be used frequently, create a separate class and initialize the
object only when it is required. Remember, if a char can work, don;t use int or
long.
· Objects are always placed on heap: One of my colleagues
was wondering that how can an object occupy space, after the method exits, if
the object is declared inside a method. Remember, only references are stored in
the stack for method, the actual object is always stored in the heap. So the
memory will be freed only when next cycle of garbage collection occurs
· Use Garbage collection: You can call
system.gc(); to initiate garbage collection, but this only suggests JVM/DVM to
run a garbage collection, you cannot force it.
·
Playing with Bitmaps/ Images: Bitmaps and images take
highest amount of memory, so make sure you recycle() bitmaps as soon as you are
done using it. Make sure you have removed all references (imageviews/ objects)
to bitmap before calling recycle().
·
Handle Activity Stack: If the app can be used back and forth
multiple times, it is better to handle the back-front flow in the code, as
default back button handling in android needs to keep a tack of activity stack
and uses memory for that. Simplest will be to call previous activity on back
button through code and always finish current activity before moving to next.
2.code:
Bitmap bmp =( yourbitmap);
if(bmp != null) {
//release reference
bmp.recycle();
bmp = null;
}
3.note that:
- Remember to always free Bitmap objects memory before finishing your application or whatever objects containers.
- Read more about Recycle().
4.conclusion:
- Some information about Memory Leaks.
- know how to lease resources.
- know how to avoid out of memory Error.
- know how to aquire large heap for application.
- know what is garbage collection and what is garbage collector.
- The next coming posts will be on how to realse memory of bitmap objects stored in List, LinkedList, HashMap and what is LRU cache and its usage.
- The code seems to explain itself due to comments, and is very easy to understand.
- Don’t mind to write a comment whatever you like to ask, to know,to suggest or recommend.
- Hope you enjoy it!
Cheers,
Hamad Ali Shaikh
