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

3. Avoiding Mistakes

4. Efficient UI Layouts

5. Design UI for Responsiveness

6. Design for Performance

7. Use of Profilers/Tools

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.

16. Temporary Fields

19. 7 Common Mistakes(Android)- Which we should not do Do: 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; }}

21. Best Practices-Performance 10

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.

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

33. In OnDraw() Method

34. Reduce calculations

35. Reduce memory allocations

36. Reduce resource loading

37. Avoid Nesting of Layouts .

39. Cache values locally in memory. But Size of cache should be chosen correctly.

40. Avoid too many calls to Network I/O.

41. Cache values locally in memory. But Size of cache should be chosen correctly. It should go to network only when it is absolutely needed.

42. Avoid open Logging statements

43. Always use conditional log statements and Use Class Names as TAG for the logs..

44. Best Practices-Responsiveness 15

46. Doing Network I/O in UI thread

47. Doing DB operation in UI thread.

48. Doing File I/O in UI thread.

49. Doing complex calculations in UI On Draw()

50. Calling InValidate() frequently.

51. Doing heavy Memory/Resource Allocations in UI thread

52. Calling a Synchronous framework API which is timeconsuming.

53. Using Thread.Sleep or Thread.wait() in UI Thread..

55. Methods on UI thread should do very very minimal operation.

56. OnCreate()

57. OnResume()

58. OnClick()

59. OnTouch()

60. Any framework callback() or Listener()

61. BroadcastReceiver()

62. Followings should be done in Child thread .

63. DB/Network/File I/O should be done in Child thread

64. Call Synchronous Time Consuming framework APIs.

66. Usage of AsyncTask

67. Already explained in previous section.

68. Usage of Child Thread and passing Handler object.

69. Create a Handler object in your UI thread

70. Spawn off worker threads to perform any required expensive operations

71. Post results from a worker thread back to the UI thread's handler either through a Runnable or a Message.

72. Update the views on the UI thread as needed .

73. 19 Best Practices- ResponsiveNess Code Snippet: private Handler handler = new Handler() { @Override public void handleMessage(Message msg) { super.handleMessage(msg); // do something } }; At second need to create Thread. new Thread() { public void run() { //long time method handler.sendEmptyMessage(0); } }.start() .

74. Best Practices-Efficient Layout 20

76. Possible ways to implement UI using

77. Linear Layout

78. Absolute Layout

79. Relative Layout

80. Which one is Efficient?.

83. LayoutOpt

84. layoutopt is a command-line tool that helps you optimize the layouts and layout hierarchies of your applications25

85. Best Practices-Tools to be Used 26

87. Traceview is a graphical viewer for execution logs saved by your application.

88. does Performance Analysis

89. ProGuard

90. The ProGuard tool shrinks, optimizes, and obfuscates your code by removing unused code and renaming classes, fields, and methods with semantically obscure names

91. FindBug

92. Static code analysis tool to be used before submitting for code review.

94. zipalign is an archive alignment tool that provides important optimization to Android application (.apk) files.

95. Ensure all uncompressed data starts with a 4Byte alignment relative to the start of the file.

96. Allows all portions to be accessed directly access via mmap()

97. Amount of RAM consumed is less

98. Performance is better.Note: It should always be done after signing your application. USAGE: zipalign [-f] [-v] <alignment> infile.apk outfile.apk 28

99. Best Practices-Coding Guidelines 29

101. Add File Headers

102. Add Class Headers

103. Commenting for Class variables

104. Method Headers

105. Method Desc

106. Input/Output Parameters info

107. Return type

108. Possible Return Values

110. Prefix s for static variables.

111. Define constants in Capitals.

112. Validate your parameters.

113. Modify strings with String Builder

114. Close all allocated resources I/O streams in finally().

115. Use Buffered I/O when big files or frequent operations are required.

116. Declare variable just before use

117. Initialize variable always.