Common knowledge that all Android developers should know

[[155312]]

Software Development Process

A complete software development process is inseparable from the seven links of planning, interaction, vision, software, testing, maintenance and operation. These seven links are not isolated. They are the premise of developing a successful product, but each of them can also form a discipline and an independent position. With the popularity of agile development and the advent of the era of experience, modern software development focuses more on efficiency and agility, rather than following these development processes in a conventional way. For example, the position of software development is no longer just a technical position. It needs to participate in the early design and review, and can put forward its own opinions in terms of vision and interaction. In the process of development, it is necessary to self-test the program to solve existing problems as soon as possible. The operation and maintenance process also requires the help of software. It can be seen that modern software development has higher and higher requirements for the comprehensive quality of developers (this is not the full-stack engineer mentioned by Facebook). It is obviously unreasonable to call yourself a coder or a programmer, because this process is a coexistence of mental labor and physical brain work. It is more reasonable to call yourself an engineer.

Planning: demand collection (obtaining demand through user research, grayscale release, big data analysis, competitive product analysis, leadership brainstorming, etc.), demand organization (classifying and prioritizing demand, etc.), converting demand into solutions (outputting design documents);

Interaction: From the perspectives of psychology (taking advantage of human weaknesses), humanity (mind), and personalization, solutions are converted into interactive functions and interfaces (interactive documents need to be output), such as loading wait, message prompts, page layout, interactive logic within and between pages, page switching animations, etc. In this process, Axure or PowerPoint is generally used to create interactive documents;

Visual: Based on the interactive diagram, use PhotoShop to create visual effects. The image formats on Android are mostly png and jpg. For places where screen adaptation is required and the program is suitable for screen adaptation, you can use nine pictures in the format of *.9.png.

Software: Transform requirements into specific implementations based on visual and interactive effects. During the implementation process, changes in requirements, interactions, or vision may lead to changes in software implementation. This is because information distortion may occur in each link of planning, interaction, and vision. Software is always in a passive state due to changes in the market environment, inaccurate information, or leaders’ random decisions. Therefore, agile development, pair programming, program design, peer review, and unit testing are now advocated to improve the flexibility and stability of the program.

Testing: After the software reaches the interactive standard, the interactive program needs to be tested, among which gray release (user testing), self-testing (development self-testing), and SQA (quality assurance) are all considered testing;

Maintenance and operation: After passing the testing program and reaching the stability standard, the software can be launched. After the software is launched, it needs to be maintained, and the problems reported by users must be solved in a timely manner, and the questions of users must be answered in a timely manner; operations should be carried out according to background statistical information, seize the operable festivals, and national cultural needs to increase the stickiness of users using the product, so that more users know and use the product. This is what operations should do.

Note:

You can check out this answer to learn about the specific process of an APP from idea to launch. How difficult is it to develop an APP?

You can check out this article from Bigo Technology to learn about the process of making a mobile phone (or tablet or other electronic products) and the process of making a mobile phone.

The wisdom of asking questions

Most jobs are result-oriented, especially software development. Performance appraisal and KPI are all about assessing the results of your work, so work requires more of your problem-solving skills. As for learning, it is better to do it outside of work. I have two suggestions for improving problem-solving skills:

Learn to learn and think: The learning process should be both broad and deep. Android application development itself does not require high technical skills (because many underlying things are encapsulated by Google, frameworks, and open source code. Most of the time, you only need to read the ReadMe or API to know how to use it). It is more about knowing how to solve the problem when you encounter a problem. You need to read books, but it is also beneficial to browse forums, QQ groups, Github, StackOverflow, and CSDN blog columns.

Learn to ask questions: There are many resources around you, such as colleagues, StackOverflow, QQ technical exchange groups, and search engines. When you encounter a problem, you can use the resources around you to solve the problem. If a problem cannot be solved by myself within an hour, I will solve it through search engines, Github, QQ technical exchange groups, colleagues, and StackOverflow (the above order is arranged by priority). If you need a good answer, you need to ask good questions, especially in QQ groups or forums. In the process of asking questions, you need to reflect your thinking. You must not ask others questions that can be solved through search engines. This is a respect for others. Here are a few links recommended. It will be of great help to you if you read them carefully:

How to use search engines such as Google?

How should programmers ask questions?

The wisdom of asking questions

Smart Questions

How to solve the bug

In order to write this article, I specifically asked a question on Zhihu:

What are your tricks for solving bugs?

Before you know how to quickly solve a bug, you need to know what a bug is. A function that does not meet the planning, interaction, and visual requirements is not called a bug, it is called a functional defect; a function that cannot be used normally after completion is not called a bug, because it has not reached the testable standard at all. I think that problems found after your program reaches the testable standard are called bugs. Combining my own experience in solving bugs and the answers on Zhihu, I have summarized the common methods for solving bugs (the premise for you to solve bugs efficiently is that you can quickly locate the location of the defect, so most of the following methods talk about how to quickly locate the problem. As for actually solving the bug, you need to modify the program yourself):

Breakpoint debugging:

Take Eclipse as an example:

1. Breakpoint:

(1) Breakpoint:

(2) Clear breakpoints:

2. Two ways to start debugging mode:

(1) Start the debugging program through debug as: right-click the project name --] Debug AS --] Android Application --] A prompt box "watching for the debugger......" will pop up on the simulator or real machine. Do not click it and wait for it to disappear automatically. At this time, you have entered the debugging mode and operate the program to reach the breakpoint.

(2) While the program is running, select the program to be debugged in the DDMS view and start the debugging mode:

3. Debugging: Please try the debugging shortcut keys F5, F6, F7, and F8 by yourself;

4. Watch member variables: During debugging, for example, when executing for, while, do while loops, recursion, system callbacks, etc., you can use watch to observe changes in member variables or method return values. The watch method is:

Note: For more information about debugging Android programs in Eclipse IDE, see: Program debugging in Android eclipse

Print:

The print debugging method is very useful for code segments such as loops, asynchronous loading, recursion, and JNI. Especially in loops, when the number of loops is very large, debugging through breakpoints is obviously a laborious task. At this time, printing becomes more "intelligent". I usually output print information through the following encapsulated print debugging class. This class can print print, log, line number, file name, StrictMode and other information. When you don't need to print information, just change DEBUG_MODE to false:

 import android.content.Context;
 import android.os.StrictMode;
 import android.util.Log;
 import android.widget.Toast;
 /**
 * Debug printing class
 *
 * */  
 public   class DebugUtils{
 private DebugUtils(){
 }
 public   static   void println( String printInfo ){
 if ( Debug.DEBUG_MODE && null != printInfo ){
 System.out.println( printInfo );
 }
 }
 public   static   void print( String printInfo ){
 if ( Debug.DEBUG_MODE && null != printInfo ){
 System.out.print( printInfo );
 }
 }
 public   static   void printLogI( String logInfo ){
 printLogI( TAG, logInfo );
 }
 public   static   void printLogI( String tag, String logInfo ){
 if (Debug.DEBUG_MODE && null != tag && null != logInfo ){
 Log.i( tag, logInfo );
 }
 }
 public   static   void printLogE( String logInfo ){
 printLogE( TAG, logInfo );
 }
 public   static   void printLogE( String tag, String logInfo ){
 if (Debug.DEBUG_MODE && null != tag && null != logInfo ){
 Log.e( tag, logInfo );
 }
 }
 public   static   void printLogW( String logInfo ){
 printLogW( TAG, logInfo );
 }
 public   static   void printLogW( String tag, String logInfo ){
 if (Debug.DEBUG_MODE && null != tag && null != logInfo ){
 Log.w( tag, logInfo );
 }
 }
 public   static   void printLogD( String logInfo ){
 printLogD( TAG, logInfo );
 }
 public   static   void printLogD( String tag, String logInfo ){
 if (Debug.DEBUG_MODE && null != tag && null != logInfo ){
 Log.d( tag, logInfo );
 }
 }
 public   static   void printLogV( String logInfo ){
 printLogV( TAG, logInfo );
 }
 public   static   void printLogV( String tag, String logInfo ){
 if (Debug.DEBUG_MODE && null != tag || null != logInfo ){
 Log.v( tag, logInfo );
 }
 }
 public   static   void printLogWtf( String logInfo ){
 printLogWtf( TAG, logInfo );
 }
 public   static   void printLogWtf( String tag, String logInfo ){
 if (Debug.DEBUG_MODE && null != tag && null != logInfo ){
 Log.wtf( tag, logInfo );
 }
 }
 public   static   void showToast( Context context, String toastInfo ){
 if ( null != context && null != toastInfo ){
 Toast.makeText( context, toastInfo, Toast.LENGTH_LONG ).show( );
 }
 }
 public   static   void showToast( Context context, String toastInfo, int timeLen ){
 if ( null != context && null != toastInfo && ( timeLen ] 0 ) ){
 Toast.makeText( context, toastInfo, timeLen ).show( );
 }
 }
 public   static   void printBaseInfo( ){
 if ( Debug.DEBUG_MODE ) {
 StringBuffer strBuffer = new StringBuffer( );
 StackTraceElement[ ] stackTrace = new Throwable( ).getStackTrace( );
 strBuffer.append( "; class:" ).append( stackTrace[ 1 ].getClassName( ) )
 .append( "; method:" ).append( stackTrace[ 1 ].getMethodName( ) )
 .append( "; number:" ).append( stackTrace[ 1 ].getLineNumber( ) )
 .append( "; fileName:" ).append( stackTrace[ 1 ].getFileName( ) );
 println( strBuffer.toString( ) );
 }
 }
 public   static   void printFileNameAndLinerNumber( ){
 if ( Debug.DEBUG_MODE ) {
 StringBuffer strBuffer = new StringBuffer( );
 StackTraceElement[ ] stackTrace = new Throwable( ).getStackTrace( );
 strBuffer.append( "; fileName:" ).append( stackTrace[ 1 ].getFileName( ) )
 .append( "; number:" ).append( stackTrace[ 1 ].getLineNumber( ) );
 println( strBuffer.toString( ) );
 }
 }
 public   static   int printLineNumber(){
 if ( Debug.DEBUG_MODE ) {
 StringBuffer strBuffer = new StringBuffer( );
 StackTraceElement[ ] stackTrace = new Throwable( ).getStackTrace( );
 strBuffer.append( "; number:" ).append( stackTrace[ 1 ].getLineNumber( ) );
 println( strBuffer.toString( ) );
 return stackTrace[ 1 ].getLineNumber( );
 } else {
 return   0 ;
 }
 }
 public   static   void printMethod(){
 if ( Debug.DEBUG_MODE ) {
 StringBuffer strBuffer = new StringBuffer( );
 StackTraceElement[ ] stackTrace = new Throwable( ).getStackTrace( );
 strBuffer.append( "; number:" ).append( stackTrace[ 1 ].getMethodName( ) );
 println( strBuffer.toString( ) );
 }
 }
 public   static   void printFileNameAndLinerNumber( String printInfo ){
 if ( null == printInfo || !Debug.DEBUG_MODE ){
 return ;
 }
 StringBuffer strBuffer = new StringBuffer( );
 StackTraceElement[ ] stackTrace = new Throwable( ).getStackTrace( );
 strBuffer.append( "; fileName:" ).append( stackTrace[ 1 ].getFileName( ) )
 .append( "; number:" ).append( stackTrace[ 1 ].getLineNumber( ) ).append( "\n" )
 .append( ( null != printInfo ) ? printInfo : "" );
 println( strBuffer.toString( ) );
 }
 public   static   void showStrictMode( ) {
 if (DebugUtils.Debug.DEBUG_MODE) {
 StrictMode.setThreadPolicy( new StrictMode.ThreadPolicy.Builder()
 .detectDiskReads().detectDiskWrites().detectNetwork().penaltyLog().build());
 StrictMode.setVmPolicy( new StrictMode.VmPolicy.Builder()
 .detectLeakedSqlLiteObjects().detectLeakedClosableObjects().penaltyLog().penaltyDeath().build());
 }
 }
 public   static   void d(String tag, String msg){
 if (DebugUtils.Debug.DEBUG_MODE){
 Log.d(tag, msg);
 }
 }
 public   class Debug{
 public   static   final   boolean DEBUG_MODE = true ;
 }
 public   static   final String TAG = "Debug" ;
 }

Visual method:

This is suitable for code review, but it is not very reliable because human energy is limited after all. Sometimes typing an extra semicolon or incorrect indentation may cause problems in the program. However, it is an efficient method when the amount of code is small.

Automated testing:

Android's automated testing (white box testing and black box testing) tools include: monkey, Robotium, Appium, cloud testing (such as testin), for specific usage, see:

Android practical testing methods: Monkey and MonkeyRunner

Robotium

Testin

Appium Chinese Tutorial

Elimination method:

The three methods of debugging, printing, and visual inspection are suitable for reproducible problems. For random problems (in fact, there are no random problems, but the problems are not so easy to reproduce), such as when threads, audio playback, AnsynTask, Timer switching or ending, the corresponding human operations happen to cause supernatural phenomena. At this time, the problem can be checked by elimination. The specific method is to first roughly locate the location of the problem, then annotate the code section by section, observe the program phenomenon, and gradually narrow down the scope of the problem.

Version Management Introduction

In a larger software development process, there may be multiple software engineers developing a project at the same time. For example, some are responsible for reading data, obtaining network data and other API encapsulation, some are responsible for program architecture, and some are responsible for upper-level interface implementation. In order to finally compile a completed program, the code needs to be integrated. At this time, the most convenient way is to use a version management tool and upload it at a fixed time (such as every day, without changing a function, etc.). This can ensure that the code on the server is the most complete and up-to-date in real time, and can also avoid the problem of local computer crashes and code losses due to natural disasters or computer abnormalities.

Common version management tools include SVN and Git. I have also used CVS. For an introduction to version management tools, see:

Version Control

The road to choosing a version control system

Git Tutorial

A quick guide to git

Note: For Windows users, it is recommended to use the Tortoise Shell series of version control clients. Friends who use GitHub can use the GitHub for Windows client:

    tortoisegit 
     
    tortoisecvs 
     
    tortoisesvn 
     
    github for windows 

Compile

Usually when we use Eclipse or Android Studio to develop Android programs, we only need to run the program to run it on the simulator or machine, but in order to ensure the integrity of the code and be able to compile on the server, the code needs to be compiled into apk through a compilation tool. Common compilation tools are: ant, gradle, but these two compilation tools require manual typing of commands to complete the compilation function (of course, you can also write your own scripts to automate the compilation). Jenkins is a continuous integration tool that can be used to automate code cloning, compilation, and program encryption. In fact, it is also implemented through batch processing. The specific usage of ant, gradle and jenkins can be googled by yourself. It is very simple to use. Currently, many functions on Android studio and GitHub are compiled through gradle.

Introduction to professional terms

The following explanation is entirely my own understanding, and you can Google it for detailed explanations.

Version iteration: According to the priority of requirements, continuous development and upgrading are carried out after ensuring the basic functions are OK. This can reduce the risk of software development and solve the problems reported by users in a timely manner. It is easier to turn around if the ship is small.

Agile development: small steps and fast progress, roughly means not to pay too much attention to documents, but to focus on face-to-face communication, to be able to restore the user's demand scenarios with high fidelity during implementation, and to be able to quickly solve user needs.

Unit testing: a type of white box testing, which tests your own program by writing programs for core methods. The purpose of unit testing is to allow you to consciously reduce the coupling between programs and ensure that each method is the smallest unit, but this is not helpful for testing program logic. This is my own understanding. . .

Grayscale release: First, find a group of users to use the program to be released (these users can be randomly selected, set age groups, designated regions, or known to be active users in some way). During the testing process, give users some benefits to let them write user experience reports, give feedback, etc. to discover problems and defects in the program.

DA statistics: also called background statistics, by embedding points in the program, uploading user operation behaviors and data to the background when there is a network. Uploading the information of each user is called big data, and analyzing this data through modeling is called big data analysis.

Open platform: For example, sharing to QQ space, WeChat, iFlytek voice, Umeng's background statistics, weather, maps, etc. are all called open platforms. It provides some open interfaces to developers to facilitate developers to use its services. Most services on the open platform are free, but sometimes they may be unstable. For example, if there are few people using it, it will naturally not survive, and then there will be no more.

Peer review: Your peers look at your code with you to find out if there are any problems;

Pair programming: When writing code, someone sits next to you or you sit next to someone else, and you discuss while writing, which reduces the probability of logical and low-level errors in the program.

Android Development Resources

See my other article: Android Developer Website Navigation

suggestion

Try to read the official documentation as it is the original and undistorted development guide.

Even if you think designing programs is a waste of time and you just like writing programs, at least you have to use mind maps to sort out your thoughts. Mind maps are very helpful in helping you understand design documents and sort out your thoughts.

Do not use Intent to pass large amounts of data, as this may cause ANR or exceptions.

After exiting the page, the system may not execute the onDestory method in time. If you close files and release memory in the onDestory method, when you exit the program and enter it immediately, the code may re-enter the program due to the need to reinitialize this information.

After changing JNI, remember to uninstall the program that has been installed on the emulator or real machine before running the program. If you run it directly, Android will not load the latest compiled so, and you will not be able to see the modified effect immediately;

Back up the code at least once a day, or when you improve a feature. Do not back it up all at once, because when your code has a problem and you need to go back to the server, you will need to retrieve the code again. This can also prevent the code from being out of date and causing you to not know what has been changed when you merge it with others.

Encapsulate the print information into a method, and use a flag to control whether the method body of this method needs to be executed. In this way, when releasing from the debug version to the release version, you don’t need to remove the code line by line, you only need to change the value of the flag.

For JNI functions with return values, even if you do not return any value, there will be no error when compiling JNI with NDK, so when writing JNI code, be sure to check the code carefully;

JNI's frequent read and write file operations will affect the program's running performance. You can consider applying for a large memory block in the memory as a cache space at one time. This method of exchanging space for time can greatly improve the program's running efficiency.

Do not count on the finalize method of the class to handle the work that needs to be recycled and destroyed, because finalize is a system callback method and the timing of the call is unpredictable. Remember this;

When using file streams and Cursors, remember to close them after use, otherwise it may cause memory leaks and even program crashes in serious cases.

Use Google search engine first (less use of Baidu). If you cannot use Google search engine normally, it is recommended to build a ladder through proxy, VPN, modify hosts file, etc. Here is a free Google search engine

For activities that do not require hardware acceleration (no animation effects, video playback, and various multimedia file operations can all turn off hardware acceleration), turn off hardware acceleration in the AndroidManifest.xml file by using "android:hardwareAccelerated="false" to save application memory;

For applications that need to switch between landscape and portrait modes, but do not want to re-run the onCreate method when switching between landscape and portrait modes, you can call "android:configChanges="screenSize|orientation" under the corresponding Activity tag in the AndroidManifest.xml file;

In order to reduce the memory pressure of the main process of the application, for interfaces that consume more memory (such as video playback interface, flash playback interface, etc.), you can call "android:process=".processname" under the corresponding Activity tag in the AndroidManifest.xml file to open a single process, but when exiting this interface, you must call the System's kill method in the onDestory method of the interface to kill the process;

The number of elements in a single array defined in the res/values/arrays.xml file should not be too large. If it is too large, it will cause very slow data loading. Sometimes the data may not be loaded when you need to use the array resource.

The most memory-consuming part of an Activity is the background of the Activity (this is true in most cases, especially for machines with high resolutions, where the background of an interface requires several megabytes of memory). Therefore, when there are many program interfaces, you can consider converting the image into a static drawable, and then multiple activities share this background image.

You can turn off the multi-touch feature by customizing the theme for your application or activity. Just add these two tags under your custom theme:

 [item name= "android:windowEnableSplitTouch" ] false [/item]
 [item name= "android:splitMotionEvents" ] false [/item]

When entering many games, the opening animation played is mostly a video file;

The number of methods in a single Android dex file cannot exceed 65536. Can Android use multiple dex files to avoid the 65536 method limit?

Using the emulator Genymotion instead of the built-in emulator of Android (it requires the support of the virtual machine Vituralbox, but the official website has provided an installation package with an integrated virtual machine, which can be downloaded and installed directly) can greatly improve the experience of using the emulator (smooth and fast). It can also be integrated into Eclipse as a plug-in. This is a video tutorial

When setting a custom theme for an application or activity, it is best not to set it to fully transparent, otherwise the effect will be very poor when the activity returns to the desktop by pressing the Home button;

If you need to cancel the toast display function, you only need to instantiate the class once in a class (that is, define Toast as a global member variable), so that you can call mToast.cancel(). I wrote it as a static class:

 public   class ToastUtils {
 private ToastUtils(){
 }
 public   static   void showToast( Context context, String toast ){
 if ( null == mToast ) {
 mToast = Toast.makeText( context, toast, Toast.LENGTH_LONG );
 } else {
 mToast.setText(toast);
 }
 mToast.show() ;
 }
 public   static   void cancel( ){
 if ( null != mToast ) {
 mToast.cancel() ;
 }
 }
 public   static Toast mToast = null ;
 }

You can define a static class to prevent the button from being clicked repeatedly and causing a piece of code to be executed repeatedly:

 /**
 * Repeated button clicks
 *
 * */  
 public   class BtnClickUtils {
 private BtnClickUtils(){
 }
 public   static   boolean isFastDoubleClick() {
 long time = System.currentTimeMillis();
 long timeD = time - mLastClickTime;
 if ( 0 [ timeD && timeD [ 1000 ) {
 return   true ;
 }
 mLastClickTime = time;
 return   false ;
 }
 private   static   long mLastClickTime = 0 ;
 }

It is best to encrypt the data files in the assets or raw directory of the apk and decrypt them when needed. This can avoid the problem of data being cracked when the apk is cracked by others.

It is best not to call the show method of the popupwindow in the onCreate method of the activity. It may cause a program exception (android.view.WindowManager$BadTokenException: Unable to add window -- token null is not valid) because the activity is not fully initialized. If you must display the popupwindow as soon as you enter the activity, it is recommended to use handler.post and View.postDelay to handle it;

For custom View, you cannot get the width and height of the view in the constructor (the length and width are both 0 at this time). You need to get the width and height of the view in the onMeasure method or after running the onMeasure method. However, you can get the width and height information of the view in the constructor by forcing the width and height of the view to be measured in the constructor. For details, see MeasureSpec Introduction and Usage Detailed Explanation

If you think it is troublesome to configure the Android development environment after installing Eclipse, you can directly use ADT Bundle, which is a lazy package that can be used right after downloading. You can download it here.

If you have time, watch the Alibaba Technology Carnival, InfoQ speeches and interviews, and Google IO videos to learn some experience in solving problems and doing big projects.

When there are many animations in the application, and the animations are switched through pictures, you can consider borrowing the idea of ​​Cocos's sprite sheet, so as to avoid the trouble of naming pictures.

Recommended tools

Code comparison: Beyond compare

Screen color picker: ColorPix

Ladder: Red Apricot

Mind map: mindmanager

Online Tools: Online Tools