Linear layouts are more efficient than relative or absolute layouts for list items. Relative layouts are more flexible but also more expensive to render. Developers should use tools like LayoutOpt and TraceView to optimize layout hierarchies and identify performance bottlenecks. ProGuard can also help by removing unused code and optimizing code size.

1. Best Practices- Android Programming Jan 2011

2. 2HiglightsCommon Mistakes

3. Avoiding Mistakes

4. Efficient UI Layouts

5. Design UI for Responsiveness

6. Design for Performance

7. Use of Profilers/Tools

8. Best Coding Practices3Common Mistakes- Which we should not do Write Duplicate Code

9. Every time you need to make a change in the routine, you need to edit it in several places. Suggestion : Don’t Copy Paste Code!

10. Make common function or utlitiy class which can be used across other classes

11. Make Accessible Fields

12. Fields should be private except for constants.

13. Accesible Fields cause tight coupling.

14. Accesible Fields are easily corruptible.Suggestion: Use getters and setters for accessing Data.4Common Mistakes- Which we should not do Using Magic Numbers

15. Magic numbers are not readable and understandable. If one has to change for (inti = 1; i =< 52; i++) {j = i + randomInt(53 - i) – 1swapEntries(i, j)}Suggestion : Replace with meaningful Constants and define in common constants file.

16. Temporary Fields

17. If a variable need not be shared across methods, make it local.5Common Mistakes- Which we should not do Initializing Strings with new OperatorDon’t:String str = new String(“This is bad.”);Do:String str = “This is good.”;Empty Catch BlocksDon’t: keep empty catch blocks, Do : Handle the exception properly or at least Log the exception.Leaving resources for Garbage Collector. Don’t: forget to deInitialize resources and relying on GC. Do : Nullify the resources once its usage is done and clear the memory using clear() on collection if used.

18. 6Common Mistakes(Android)- Which we should not do Usage of Hardcoded strings in code.Don’t:setName(“Android”);Do:setName(getstring(R.String.Android);Suggestion:Strings should be defined in string.xml file. No string should be used in the code. XML file saved at res/values/strings.xml.Doing I/O operations in Lifecycle or framework callback method.Don’t:onCreate(){ //Making an Httpconnection or // // Making Query to DB }

19. 7Common Mistakes(Android)- Which we should not doDo:onCreate{ // Create an AsyncTask for any I/O operation}Example for creating AsyncTask:private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> { protected Long doInBackground(URL... urls) { int count = urls.length; long totalSize = 0; for (inti = 0; i < count; i++) { totalSize += Downloader.downloadFile(urls[i]); publishProgress((int) ((i / (float) count) * 100)); } return totalSize; }}

20. 8Common Mistakes(Android)- Which we should not do Usage of Pixels in Layout Attributes.Don’t:layout_width = “100px” or layout_width = “100”Do:layout_width = “100dp” or use wrap_contentSuggestion:One should use dpi.e density independent pixels or should use wrap_content or fill_parent.One can use sp for FontSize and dp if you do not want to allow the user to scale the text.\Usage of Absolute Layout 9Common Mistakes(Android)- Which we should not do Allocate objects in User interface loops.Don’t:If you allocate objects in a user interface loop, you will force a periodic garbage collection, creating "hiccups" in the user experience.Suggestion:Allocations should be done beforehand and should never be done in any loop or in any OnDraw() method as this operation is very expensive.

21. Best Practices-Performance10

22. 11Best Practices- PerformanceAvoid Creating Objects

23. Extracting strings from a set of input data, try to return a substring of the original data, instead of creating a copy.

24. Avoid Copies of strings. Appending strings to string buffer directly

25. Prefer Static over Virtual

26. Invocations would be 15 to 20% faster

27. Avoid internal Getter and Setters.

28. Virtual methods calls are very expensive so providing direct access to fields would be much faster.

29. Use Static Final For Constantsstatic intintVal = 42;static String strVal = "Hello, world!“;As it requires <clinit>method and constants are accessed via Field lookups.

30. 12Best Practices- PerformanceUse Package Scope in Inner Classespublic class Foo { private intmValue; public void run() { Inner in = new Inner(); mValue = 27; in.stuff(); } private void doStuff(int value) { System.out.println("Value is " + value); } private class Inner { void stuff() { Foo.this.doStuff(Foo.this.mValue); } }}

31. 13Best Practices- PerformanceKnow and Use the libraries

32. Usgae Lib APIs would be more efficient than using our own set of APIs.