Best Practices for Android development

Learn from Futurice's Android developers. Follow these guidelines to avoid reinventing the wheel. If you are interested in developing an iOS or Windows Phone, see the iOS good practices and Windows client good practices these two articles.
Summary

??? Using Gradle and its recommended engineering structure
??? Put passwords and sensitive data in gradle.properties
??? Do not write your own HTTP client, use volley or okhttp library
??? Parsing JSON data using the Jackson Library
??? Avoid using guava while using some class libraries to avoid 65k method limit (up to 65,536 methods can be executed in an Android program)
??? Using fragments to render the UI view
??? Use activities just to manage fragments
??? Layout layouts are XMLS code that organizes them.
??? Use the styles file to avoid duplicate properties when layoutout xmls layouts
??? Use multiple style files to avoid a single large style file
??? Keep your colors.xml short dry (don't repeat yourself), just define the palette
??? Always use Dimens.xml DRY (do not repeat yourself), define Universal constants
??? Don't make a deep viewgroup.
??? Avoid processing on the client when using Webviews, beware of memory leaks
??? Use robolectric Unit Test, Robotium do UI test
??? Use Genymotion as your simulator
??? Always use Proguard and dexguard to confuse projects

Android SDK

Place your Android SDK in a location unrelated to your home directory or other applications. When you install some Ides that include the SDK, you may place the SDK in the same directory as the IDE, which can be cumbersome when you need to upgrade (or reinstall) the IDE or replace the IDE. Also, if your IDE is in a normal user, not running under root, you should avoid the SDK in the system-level directory that requires Sudo permissions.
Build the System

Your default compilation environment should be gradle. ANT has many limitations and is also very redundant. With Gradle, it is convenient to do the following:

??? Build variants of different versions of apps
??? Make a simple script-like task
??? Manage and download dependencies
??? Custom Secret Keys
??? More

At the same time, the Android Gradle plugin as a new standard building system is being actively developed by Google.
Engineering structure

There are two popular structures: the old ant & Eclipse ADT Engineering structure, and the new Gradle & Android Studio Engineering structure, you should choose a new engineering structure, if your project is still using the old structure, consider abandoning it, and porting the project to the new structure.

The old structure:

Old-structure
├─assets
├─libs
├─res
├─src
│? └─com/futurice/project
├─androidmanifest.xml
├─build.gradle
├─project.properties
└─proguard-rules.pro

The new structure

New-structure
├─library-foobar
├─app
│? ├─libs
│? ├─src
│? │? ├─androidtest
│? │? │? └─java
│? │? │???? └─com/futurice/project
│? │? └─main
│? │???? ├─java
│? │???? │? └─com/futurice/project
│? │???? ├─res
│? │???? └─androidmanifest.xml
│? ├─build.gradle
│? └─proguard-rules.pro
├─build.gradle
└─settings.gradle

The main difference is that the new structure clearly separates the ' source sets ' (Main,androidtest), an idea of gradle. You can do this, for example, by adding source group ' paid ' and ' free ' in SRC, which will become the source code for your application's two modes of billing and freeware.

When your project references a third-party project library (for example, Library-foobar), it is very useful to have a top-level package name app that distinguishes your application from third-party library projects. These library items are then constantly referenced by Settings.gradle, where app/build.gradle can be referenced.
Gradle Configuration

Common structure Reference Google's Guide on Gradle for Android

In addition to these scripting languages (shell, Python, Perl, etc), you can also use Gradle to create tasks. For more information, please refer to Gradle ' s documentation.

Password in the version release of your app's build.gradle you need to define signingconfigs. At this point you should avoid the following:

Don't do this. This will appear in version control.

Signingconfigs {
??? Release {
??????? StoreFile file ("Myapp.keystore")
??????? Storepassword "Password123"
??????? Keyalias "Thekey"
??????? Keypassword "password789"
??? }
}

Instead, create a gradle.properties file that does not join the version control system.

Keystore_password=password123
key_password=password789

The file is automatically introduced by Gradle and you can use it in the Buld.gradle file, for example:

Signingconfigs {
??? Release {
??????? try {
??????????? StoreFile file ("Myapp.keystore")
??????????? Storepassword Keystore_password
??????????? Keyalias "Thekey"
??????????? Keypassword Key_password
??????? }
??????? catch (ex) {
??????????? throw new Invaliduserdataexception ("should define Keystore_password and Key_password in Gradle.properties.")
??????? }
??? }
}

Using the Maven dependency scheme instead of using the import jar package scenario if you explicitly use the jar file in your project, then they may become permanent versions, such as 2.1.1. Download jar Package Update They are very cumbersome and this problem Maven nicely solves this in Android Gradle is also a recommended approach in building. You can specify a range of versions, such as 2.1.+, and then MAVEN will automatically upgrade to the latest version that was developed, for example:

dependencies {
??? Compile ' com.netflix.rxjava:rxjava-core:0.19.+ '
??? Compile ' com.netflix.rxjava:rxjava-android:0.19.+ '
??? Compile ' com.fasterxml.jackson.core:jackson-databind:2.4.+ '
??? Compile ' com.fasterxml.jackson.core:jackson-core:2.4.+ '
??? Compile ' com.fasterxml.jackson.core:jackson-annotations:2.4.+ '
??? Compile ' com.squareup.okhttp:okhttp:2.0.+ '
??? Compile ' com.squareup.okhttp:okhttp-urlconnection:2.0.+ '
}

IDEs and text editors
IDE integrated development environment and text editor

No matter what editor you use, be sure to build a good engineering structure editor everyone has their own choice, so your editor works according to the engineering structure and build system, it is your own responsibility.

Now, Android Studio, because he was developed by Google, the closest to Gradle, the default use of the latest engineering structure, has been to the beta stage (currently has release 1.0), it is for Android development customized.

You can also use Eclipse ADT, but you need to configure it because it uses the old engineering structure and ant as the building system. You can even use a text editor such as vim,sublime text, or Emacs. If that's the case, you'll need to use the Gardle and adb command line. If using Eclipse integrated Gradle is not for you, you just use the command line to build the project, or migrate to Android studio.

No matter what development tool you use, just make sure that Gradle and the new project structure remain the official way to build your application, and avoid adding your editor profile to version control. For example, avoid joining Ant build.xml files. Especially if you change ant's configuration, don't forget to keep build.gradle up to date and work. Also, be kind to other developers, and don't force changes to their development tools and preferences.
Class Library

Jackson is a class library that transforms Java objects into JSON and JSON-converted Java classes. Gson is a popular solution to this problem, but we find Jackson more efficient because it supports alternative approaches to JSON: streams, memory tree models, and traditional json-pojo data binding. However, keep in mind that the Jsonkson library is larger than Gson, so depending on your situation, you may choose Gson to avoid the app 65k method limitations. Other options: Json-smart and Boon Json

Network request, cache, picture execution request backend server, there are several interactive solutions, you should consider implementing your own network client. Use volley or retrofit. Volley also provides a picture cache class. If you choose to use retrofit, consider using Picasso to load pictures and caches while using okhttp as an efficient network request. Both Retrofit,picasso and Okhttp have developed the same company (note: It was developed by Square), so they work well together. OkHttp can also use volley with volley.

RxJava is a class library of functional reactivity, in other words, capable of handling asynchronous events. This is a powerful and promising model, and it can also cause confusion, because it is so different. We recommend careful consideration before using this library to structure the entire application. Some projects are done using Rxjava, and if you need help you can get in touch with these people: Timo Tuominen, Olli Salonen, Andre Medeiros, Mark voit, Antti Lammi, Vera Izrailit, J Uha Ristolainen. We also wrote some blogs: [1], [2], [3], [4].

If you've had an experience with Rx before, start applying it from the API response. Also, start with simple UI event handling, such as clicking an event or entering an event in the search bar. If you have confidence in your RX technology and want to apply it to your overall architecture, write the Javadocs document in a complex section. Keep in mind that other developers who are unfamiliar with Rxjava may find it very difficult to understand the entire project. Do your best to help them understand your code and RX.

Retrolambda is a Java class library that uses lambda expression syntax on Android and pre-JDK8 platforms. It helps keep your code compact and readable, especially when you're programming using a style like the Rxjava function. When you use it, install JDK8, set it as the SDK path in the Android Studio Project Structure dialog box, set the Java8_home and Java7_home environment variables, and then configure the Build.gradle in the project root directory:

dependencies {
??? Classpath ' me.tatarka:gradle-retrolambda:2.4.+ '
}

At the same time, add the Build.gradle in each module

Apply plugin: ' Retrolambda '

Android {
??? compileoptions {
??? Sourcecompatibility Javaversion.version_1_8
??? Targetcompatibility Javaversion.version_1_8
}

RETROLAMBDA {
??? JDK system.getenv ("Java8_home")
??? OLDJDK system.getenv ("Java7_home")
??? Javaversion javaversion.version_1_7
}

Android Studio offers Java8 lambdas strap is code hint support. If you're not familiar with Lambdas, just start with the following:

??? Any method that contains only one interface is "lambda friendly" and the code can be folded into a more compact syntax
??? If you have questions about parameters or similar, write a normal anonymous inner class and let Android status generate a lambda for you.

Beware of the Dex method limit, while avoiding the use of too many class library Android apps, when packaged into a Dex file, there is a 65,535 application method that is tough to limit [1] [2] [3]. When you break the 65k limit you will see a fatal error. Therefore, using a normal range of class library files, and using the Dex-method-counts tool to determine which class libraries can be used under the 65k limit, specifically avoid using the Guava class library because it contains more than 13k methods.
Activities and Fragments

Fragments should be the default choice for you to implement the UI interface. You can re-use the fragments user interface to assemble your app. We strongly recommend using fragments instead of activity to present the UI interface for the following reasons:

??? Provides multi-pane layout solution Fragments's introduction mainly extends the mobile app to the tablet, so you may have a, B two panes on the tablet, but A and B may be filled with the entire screen on the phone app. If your app uses fragments at first, it's easy to adapt your app to a different size screen in the future.

??? Inter-screen data communication the API for sending complex data (such as Java objects) from one activity to another activity,android does not provide a suitable method. With fragment, however, you can use an activity instance as the communication channel for this activity fragments. Even if this is better than communication between activity and activity, you also want to consider using the event bus architecture, such as Otto or Greenrobot Eventbus, as a more concise implementation. If you want to avoid adding another class library, Rxjava can also implement an event Bus.

??? Fragments general Universal not only UI you can have a fragment with no interface to provide background work as activity. Further you can use this feature to create a fragment that contains the logic to change other fragment rather than putting this logic in the activity.

??? Even Actionbar can use internal fragment to manage you can choose to use a fragment without a UI interface to manage Actionbar specifically, or you can choose to use the action to add it to each fragment As the parent activity's actionbar. Reference.

Unfortunately, we do not recommend extensive use of nested fragments, because sometimes it causes matryoshka bugs. We only use fragment extensively when it makes sense (for example, when the horizontal sliding viewpager is in the same fragment as the screen) or if he is indeed a sensible choice.

At an architectural level, your app should have a top-level activity to contain most of the business-related fragment. You may also have some auxiliary activity, which is simply limited in both methods Intent.setdata () or intent.setaction () or similar methods to the primary activity communication.
Java Package Architecture

The Android application is roughly the model-view-controller structure of Java in architecture. In Android, fragment and activity are typically controller classes (http://www.informit.com/articles/article.aspx?p=2126865). In other words, they are part of the user interface and are also part of the views view.

Because of this, it is difficult to strictly classify fragments (or activities) strictly into the controller controlloers or view views. It is best to put them in a separate fragments package. As long as you follow the recommendations mentioned earlier, activities can be placed in the top-level directory. If you plan to have more than 2 to 3 activity, create a new activities package as well.

However, this architecture can be seen as another form of MVC that contains JSON data to be parsed by the API response to populate the Pojo models package. and a view pack to contain your custom views, notifications, navigation views, widgets, and more. The adapter adapter is between the data and the view. However, they usually need to export some views through the GetView () method, so you can put the adapters package inside the view package.

The classes for some controller roles are application-level and are close to the system. These classes are placed under the managers package. Some complex data processing classes, such as "dateutils", are placed under the utils bag. Interacting with the backend is responsible for the network processing class, which is placed under the networks package.

All in all, arrange them with the closest to the user and not the closest to the backend.

Com.futurice.project
├─network
├─models
├─managers
├─utils
├─fragments
└─views
?? ├─adapters
?? ├─actionbar
?? ├─widgets
?? └─notifications

Resource Files Resources

??? Naming follows a prefix indicating the type of habit, shaped like type_foo_bar.xml. For example: Fragment_contact_details.xml,view_primary_button.xml,activity_main.xml.

Organize layout files If you're not sure how to format a layout file, it might help to follow the rules.

??? One row per property, 4 spaces indented
??? Android:id always as the first attribute
??? android:layout_**** property on top
??? The Style property is at the bottom
??? Close label/> A single line, helping to adjust and add new properties
??? Considering the use of designtime attributes design-time layout properties, Android Studio has provided support instead of hard-coded android:text (Translator Note: This blog link to Stormzhang can also be referenced in the wall).

<?xml version= "1.0" encoding= "Utf-8"?>
<linearlayout
??? Xmlns:android= "Http://schemas.android.com/apk/res/android"
??? Xmlns:tools= "Http://schemas.android.com/tools"
??? Android:layout_width= "Match_parent"
??? android:layout_height= "Match_parent"
??? android:orientation= "Vertical"
??? >

??? <textview
??????? Android:id= "@+id/name"
??????? Android:layout_width= "Match_parent"
??????? android:layout_height= "Wrap_content"
??????? Android:layout_alignparentright= "true"
??????? android:text= "@string/name"
??????? style= "@style/fancytext"
??????? />

??? <include layout= "@layout/reusable_part"/>

</LinearLayout>

As a rule of thumb, the android:layout_**** attribute should be defined in the layout XML, while the other attribute android:**** should be placed in the Styler XML. There are exceptions to this rule, but the general work is very good. The whole idea is to keep the layout property (positioning, margin, sizing) and the content property in the layout file, while placing all the appearance detail properties (colors, padding, font) in the style file.

The exceptions are the following:

??? Android:id should obviously be in the layout file
??? Layout file android:orientation is usually more meaningful for a linearlayout
??? Android:text because it is defined, it should be placed in the layout file
??? Sometimes it is more meaningful to put the android:layout_width and Android:layout_height attributes in a style as a common style, but these should be placed in the layout file by default.

Using styles almost every project requires proper use of the style file because it is common for a view to have a duplicate look. For most text content in your app, at the very least you should have a common style file, such as:

<style name= "ContentText" >
??? <item name= "Android:textsize" > @dimen/font_normal</item>
??? <item name= "Android:textcolor" > @color/basic_black</item>
</style>

Apply to TextView:

<textview
??? Android:layout_width= "Wrap_content"
??? android:layout_height= "Wrap_content"
??? android:text= "@string/price"
??? style= "@style/contenttext"
??? />

You may need to do the same thing for the button control and don't stop there. Put a set of related and repeating android:**** properties into a common style.

You can have multiple Styles.xml files by splitting a large style file into multiple files. The Android SDK supports other files, styles this file name does not work, and it works with XML <style> tags in the file. So you can have multiple style files Styles.xml,style_home.xml,style_item_details.xml,styles_forms.xml. Not used for resource file paths need to be built for the system to make sense, and files in the Res/values directory can be arbitrarily named.

Colors.xml is a palette in your Colors.xml file that should just map the name of the color to an RGBA value, and nothing else. Do not use it to define RGBA values for different buttons.

Don't do this.

<resources>
??? <color name= "Button_foreground" > #FFFFFF </color>
??? <color name= "Button_background" > #2A91BD </color>
??? <color name= "comment_background_inactive" > #5F5F5F </color>
??? <color name= "comment_background_active" > #939393 </color>
??? <color name= "Comment_foreground" > #FFFFFF </color>
??? <color name= "Comment_foreground_important" > #FF9D2F </color>
??? ...
??? <color name= "Comment_shadow" > #323232 </color>

With this format, it's very easy for you to start repeating the definition of RGBA values, which makes it complex to change the basic color changes. At the same time, these definitions are associated with some environments, such as button or comment, and should be placed in a button style rather than in a color.xml file.

Instead, do this:

<resources>

??? <!--grayscale--
??? <color name= "White"???? > #FFFFFF </color>
??? <color name= "Gray_light" > #DBDBDB </color>
??? <color name= "Gray"????? > #939393 </color>
??? <color name= "Gray_dark" > #5F5F5F </color>
??? <color name= "BLACK"???? > #323232 </color>

??? <!--basic Colors--
??? <color name= "Green" > #27D34D </color>
??? <color name= "Blue" > #2A91BD </color>
??? <color name= "Orange" > #FF9D2F </color>
??? <color name= "Red" > #FF432F </color>

</resources>

To the Application Designer, the palette needs to be the same name as "Green", "blue", and so on. "Brand_primary", "Brand_secondary", "brand_negative" Such names are also fully acceptable. Colors such as these can be easily modified or reconstructed, which makes it very clear how many different colors the application uses altogether. It is often important to reduce the variety of colors used by a UI that has an aesthetic value.

Treat the Dimens.xml file as you would with Colors.xml you should also define a "palette" of gap intervals and font sizes, just as you would define a color palette. A good example is as follows:

<resources>

??? <!--font Sizes--
??? <dimen name= "Font_larger" >22sp</dimen>
??? <dimen name= "Font_large" >18sp</dimen>
??? <dimen name= "Font_normal" >15sp</dimen>
??? <dimen name= "Font_small" >12sp</dimen>

??? <!--typical spacing between
??? <dimen name= "Spacing_huge" >40dp</dimen>
??? <dimen name= "Spacing_large" >24dp</dimen>
??? <dimen name= "Spacing_normal" >14dp</dimen>
??? <dimen name= "Spacing_small" >10dp</dimen>
??? <dimen name= "Spacing_tiny" >4dp</dimen>

??? <!--typical sizes of views--
??? <dimen name= "Button_height_tall" >60dp</dimen>
??? <dimen name= "Button_height_normal" >40dp</dimen>
??? <dimen name= "Button_height_short" >32dp</dimen>

</resources>

When you write margins and paddings at layout time, you should use the spacing_**** dimension format instead of writing the values directly as string strings. This writing will be very much felt and will make the organization and change the style or layout is very easy.

Avoid deep view structure sometimes in order to put a view, you may try to add another linearlayout. You may use this method to solve:

<linearlayout
??? Android:layout_width= "Match_parent"
??? android:layout_height= "Match_parent"
??? android:orientation= "Vertical"
??? >

??? <relativelayout
??????? ...
??????? >

??????? <linearlayout
??????????? ...
??????????? >

??????????? <linearlayout
??????????????? ...
??????????????? >

??????????????? <linearlayout
??????????????????? ...
??????????????????? >
??????????????? </LinearLayout>

??????????? </LinearLayout>

??????? </LinearLayout>

??? </RelativeLayout>

</LinearLayout>

Even if you do not use it very explicitly in a layout file, if you are in a Java file from a view inflate (this inflate translation does not pass, you can understand the line) to other views, it is also possible to happen.

May cause a series of problems. You may experience performance problems because processing requires processing a complex UI tree structure. It is also possible to cause the following more serious problem stackoverflowerror.

So try to keep your view tree: Learn how to use relativelayout, how to optimize your layout and how to use <merge> tags.

Be careful about the webviews problem. If you have to display a Web view, say for a news article, avoid doing HTML work for the client, it is best to let the backend engineer assist, but he will be a "pure" HTML. Webviews can also cause memory leaks when keeping their activity, rather than being bound to the applicationcontext. When using simple text or buttons, avoid using WebView, which is better when using TextView or buttons.
Test framework

The test framework for the Android SDK is still in its infancy, especially with regard to UI testing. Android Gradle currently implements a test called Connectedandroidtest, which uses a junit-provided extension for Android extension of the JUnit with helpers for Android. Can Run the JUnit test you generated,

Used only as unit tests when using robolectric, views do not use it is one of the most to provide "non-connected devices" in order to speed up the development of the test, very time to do models and view models unit testing. However, using the Robolectric test is imprecise and not completely UI tested. When you're testing a problem with UI elements, dialogs, and so on, it's mostly because you're working in the dark (testing without a controllable interface)

*robotium makes writing UI testing very simple. * For UI testing you do not need to run a test with the device connection Robotium. But it might be good for you because it has a lot to help the class get and analyze the view, control the screen. The test case looks as simple as this:

Solo.sendkey (Solo.menu);
Solo.clickontext ("more"); Searches for the first occurence of ' more ' and clicks on it
Solo.clickontext ("Preferences");
Solo.clickontext ("Edit File Extensions");
Assert.asserttrue (Solo.searchtext ("RTF"));

Analog device

If you're developing Android apps full time, then buy a genymotion emulatorlicense. The Genymotion simulator runs faster than the typical AVD simulator by speeding up the speed of the second frame. He has the tools to demonstrate your app, high-quality analog network connections, GPS locations, and more. It also has the ideal connection test. If you're involved in adapting to a lot of different devices, buying a genymotion copyright is much cheaper than buying a lot of real equipment.

Note: The Genymotion simulator does not load all Google services, such as Google Play store and maps. You may also want to test the API specified by Samsung, and if so you still need to purchase a real Samsung device.
Confusing configuration

Proguard is a tool used extensively in Android projects to compress and confuse packaged sources.

Whether you use Proguard depends on the configuration of your project, and when you build a release version of the APK, usually you should configure the Gradle file.

Buildtypes {
??? Debug {
??????? Minifyenabled false
??? }
??? Release {
??????? Signingconfig Signingconfigs.release
??????? minifyenabled true
??????? Proguardfiles ' Proguard-rules.pro '
??? }
}

In order to decide which code should be retained and which code should be confused, you have to specify one or more entity classes in your code. These entities should be the specified class that contains the main method, Applets,midlets,activities, and so on. The Android framework uses a default configuration file that can be found under the Sdk_home/tools/proguard/proguard-android.txt directory. Custom engineering Specifies that project-specific obfuscation rules, as defined in My-project/app/proguard-rules.pro, are added to the default configuration.

A common problem with Proguard is to see if the application crashes and reports ClassNotFoundException or nosuchfieldexception or similar exceptions, even if the compilation is not warning and runs successfully. This means the following two possibilities:

??? Proguard has removed classes, enumerations, methods, member variables, or annotations, to consider whether it is necessary.
??? Proguard confuses the names of classes, enumerations, and member variables, but these names are also used in the original name, such as through Java reflection.

Check the App/build/outputs/proguard/release/usage.txt file to see if the object in question has been removed. Check the App/build/outputs/proguard/release/mapping.txt file to see if the problematic object is confused.

In order to prevent Proguard from stripping away needed classes or class members, add a keep options to your Proguard conf IG: To prevent proguard stripping of required classes and class members, add a keep option in your proguard configuration file:

-keep class Com.futurice.project.MyClass {*;}

To prevent Proguard from confusing some classes and members, add Keepnames:

-keepnames class Com.futurice.project.MyClass {*;}

See some examples in this template's Proguard config. For more examples please refer to Proguard.

At the beginning of the build project, release a version to check if the Proguard rule is keeping an important part of the correct one. At the same time, whenever you add a new class library, make a release version, and the APK runs on the device and tests it. Don't wait until your app releases the "1.0" version, and then you may encounter a lot of unexpected anomalies that will take some time to fix them.

Tips are written mapping.txt each time a new version is released. For each release, if the user encounters a bug, a confused stack trace is submitted. Identify issues that you can debug by keeping the Mapping.txt file.

Dexguard If you need core tools to optimize, and specifically confuse the release code, consider using Dexguard, a commercial software, Proguard is also developed by their team. It will be easy to split the Dex file to solve the 65K method limitation problem.
Thanks

Thanks Antti Lammi, Joni Karppinen, Peter tackage, Timo Tuominen, Vera izrailit, Vihtori m?ntyl?, Mark voit, Andre Medeiros, Pa UL Houghton these people and futurice developers to share their Android development experience.
License

Futurice Oy Creative Commons Attribution 4.0 International (CC by 4.0)
Translation

Translated to Chinese by andyiac

Best Practices for Android development