Android core analysis-design intent of Analysis Methodology Discussion

From: http://blog.csdn.net/column/details/androidcore.html? Page = 2

Design intent of Analysis Methodology Discussion

Why do we need to study android? Because it is huge enough and complicated enough, it aroused my desire as a programmer to understand this complexity. I am studying Android software as a mobile development platform, rather than the Dalvik virtual machine itself.

As a programmer installed on other platforms and engaged in andoid platform system development, my accumulated knowledge on the mobile platform is no longer sufficient, android brings us a lot of new terms, such as activity, manifest, intent, service, binder, Dalvik virtual machine, framework, Linux, navtive, JNI ...... Through the source code, in the development community, in the Development blog, and even in the recruitment process, I am constantly seeking for what Android is. After a certain period of time, I gradually learned that android is not only a general term for a type of mobile phone, but also a mobile phone development platform, not just a virtual Java operating system, not just a development community, A development standard, not just a bunch of code, Android has become a new trend.

The code is too large and the system is complex. Looking at the android researchers in the community, the process of analyzing the source code for Android has become a lost path. The developers are constantly logging on and sprinting in depth, and the head stack is not enough, there are few people who are lost in the journey of the beginning or on the half way. I feel that most of the researchers always forget to look down at the designer's intent on the mountain, blindly following the control flow of the Code into the complicated mystery, and fall into the abyss of complexity.

My research and analysis start from the intent of the designer, from the abstract or even from the philosophical height, from the simplest system prototype, from the design conjecture, instead of starting from code analysis. First, understand the android big runtime framework, the main process, the system prototype, and then use the source code analysis to enrich it. Of course, the intent of the designer here is not the intent of the real Android designer, but the intent of the android designer I think.

Abstract. We need to consider the system description in the space of philosophical meaning, that is, what the system is essentially to express. Consider the basic structure and dynamic structure of the system in the logical space. From reality to virtual object ing, we can understand the composition of system objects and analyze the relationship between consumers and consumers from the perspective of data flow, analyze the interaction between objects from the control flow perspective, and analyze the specific hierarchy from the function call.

In system design, prototype is the thing that best expresses the essence of the system in philosophical space and logical space. prototype is the first layer of the essence of things. I think any complicated system has a concise system prototype, which has its concise meaning. The system prototype is the first embodiment of the designer's intention, so we need to extract the system prototype from several directions:

(1) starting from the nature and basic principles of the system

(2) analyze the data flow and control flow of the system.

Starting from the intent of the designer, it is the first step to obtain the system prototype and extract the large logical structure and system structure. Then we can consider the design of the system from the perspective of the designer. What is the basic prototype? What are the limitations of the system, what are the application scenarios, and the introduction of some designs is still the result of System convergence. We can also analyze the code traces. How did these concepts come from? Understanding these problems from a certain degree of abstraction and height and following the principle of system prototype, it is not easy to get into details when analyzing code in depth. We can jump out and think at any time, what is the concept of the Code in the overall upload, what logic is depicted, does it need to form a virtual layer? Is he managing this hardware? Is he virtualizing this object? He is building a management organization? Or building an object management? What kind of complex algorithms are introduced to facilitate space management? What kind of prototype algorithms should actually be?

Only by going deep into this abstract level can we grasp every line of the system and the meaning of every object. Just starting from the prototype can we grasp the essence of this system. What are we doing? What does he want to express? Why do designers think this way? What is the ultimate idea? In this way, the code analysis becomes simple and clear, and the reading of the Code becomes a confirmation of conjecture and correction direction.