Android Classic face test summary (not to be continued)

1. Life cycle

Scenario Demo: Switch to the fragment
11-29 14:26:35.095:d/applistfragment (7649): Onattach
11-29 14:26:35.095:d/applistfragment (7649): onCreate
11-29 14:26:35.095:d/applistfragment (7649): Oncreateview
11-29 14:26:35.100:d/applistfragment (7649): onactivitycreated
11-29 14:26:35.120:d/applistfragment (7649): OnStart
11-29 14:26:35.120:d/applistfragment (7649): Onresume
Screen off:
11-29 14:27:35.185:d/applistfragment (7649): OnPause
11-29 14:27:35.205:d/applistfragment (7649): onsaveinstancestate
11-29 14:27:35.205:d/applistfragment (7649): OnStop

Screen unlock
11-29 14:33:13.240:d/applistfragment (7649): OnStart
11-29 14:33:13.275:d/applistfragment (7649): Onresume

To switch to another fragment:
11-29 14:33:33.655:d/applistfragment (7649): OnPause
11-29 14:33:33.655:d/applistfragment (7649): OnStop
11-29 14:33:33.660:d/applistfragment (7649): Ondestroyview

Switch back to the fragment itself:
11-29 14:33:55.820:d/applistfragment (7649): Oncreateview
11-29 14:33:55.825:d/applistfragment (7649): onactivitycreated
11-29 14:33:55.825:d/applistfragment (7649): OnStart
11-29 14:33:55.825:d/applistfragment (7649): Onresume
Back to Desktop
11-29 14:34:26.590:d/applistfragment (7649): OnPause
11-29 14:34:26.880:d/applistfragment (7649): onsaveinstancestate
11-29 14:34:26.880:d/applistfragment (7649): OnStop
Back to Application
11-29 14:36:51.940:d/applistfragment (7649): OnStart
11-29 14:36:51.940:d/applistfragment (7649): Onresume

Exit the App
11-29 14:37:03.020:d/applistfragment (7649): OnPause
11-29 14:37:03.155:d/applistfragment (7649): OnStop
11-29 14:37:03.155:d/applistfragment (7649): Ondestroyview
11-29 14:37:03.165:d/applistfragment (7649): OnDestroy
11-29 14:37:03.165:d/applistfragment (7649): Ondetach

What is the difference between the context in 2.Android and activity,appliction?
Same: Both activity and application are sub-classes of the context.
Context is literally understood to be the meaning of contexts, and in practice it is indeed the total use of various parameters and variables in the context of management, so that we can easily access the various resources.
Different: The maintenance life cycle is different. The context maintains the life cycle of the current activity, and application maintains the life cycle of the entire project.
When using context, be careful about memory leaks, prevent memory leaks, and pay attention to several things:
1. Do not allow objects with long life cycles to refer to the activity context, which guarantees that the object referencing the activity is the same as the activity itself life cycle.
2. For objects with long life cycles, you can use Application,context.
3. Avoid non-static internal classes, use static classes as much as possible, avoid life cycle problems, and note the life cycle changes that internal classes cause to external object references.

3. Transfer data between two activity, except intent, broadcast recipient, content provider what else?
1) using static data, public static member variable
2) using the transfer of external storage,
For example, file storage
Sharedpreferences Preferences
Sqlite Database

What is 4.Context?
1, it describes the information of an application environment, that is, the context.
2. The class is an abstract class, and Android provides a concrete implementation class (CONTEXTIML) for that abstract class.
3, through it we can get the resources and classes of the application, also include some application-level operations, such as: Start an activity, send broadcasts, accept intent, information, etc.

5. What is the maximum number of bytes in a text message?
Chinese 70 (including punctuation), English 160, 160 bytes.
Because the English alphabet uses 7-bit ASCII encoding, and the Chinese characters are 8-bit UCS-2 encoded and accounted for 2 bytes, 160 characters are converted according to 7-bit ASCII encoding, that is, the 160x7=1120 bit, and the Chinese characters are encoded according to the 8-bit UCS-2, that is, 8 characters, and a Chinese character is 2 character. , so 1120-bit conversion into Chinese characters is 1120/8/2=70.

6. How do I open a database file in the res aw directory?
Answer: You cannot open a database file in the Res AW directory directly on Android, but you need to copy the file to a directory in your phone's memory or SD card when the program first starts, and then open the database file. The basic method of replication is to use the Getresources (). Openrawresource method to obtain the InputStream object for a resource in the Res AW directory, and then write the data in the InputStream object to the corresponding file in the other directory. The Sqlitedatabase.openorcreatedatabase method can be used in the Android SDK to open SQLite database files in any directory.

architecture of the 7.Android system
Android's system architecture, like its operating system, employs a layered architecture. From the architecture diagram, Android is divided into four tiers, from the high-level to the lower layer, which are application layer, application framework layer, system run-level and Linux core.
1. Application
Android is published with a range of core application packages, including email clients, SMS short message programs, calendars, maps, browsers, contact management programs, and more. All applications are written in the JAVA language.
2. Application Framework
Developers also have full access to the API framework used by the core application. The architectural design of the application simplifies the reuse of components; Any application can publish its block of functionality and any other application can use its published block of functionality (subject to the security restrictions of the framework). Similarly, the application reuse mechanism also makes it easy for users to replace program components.
Hidden behind each app is a series of services and systems, including;
* Rich and extensible view (views) that can be used to build applications, which include lists (lists), grids (grids), text boxes (texts boxes), buttons (buttons), and even web browsers that can be embedded.
* Content Providers allows applications to access data from another application, such as a contact database, or share their own data
* Resource Manager (Resource Manager) provides access to non-code resources such as local strings, graphics, and layout files.
* Notification Manager (Notification Manager) enables applications to display customized prompts in the status bar.
* Activity Manager is used to manage the application lifecycle and provide common navigation fallback functionality.
For more details and how to write an application from scratch, refer to how to write an Android app.
3. System Runtime Library
1) Program Library
Android contains a number of C + + libraries that can be used by different components of the Android system. They provide services to developers through the Android application framework. Here are some core libraries:
* System C Library-a standard C system function library (LIBC) inherited from BSD, which is specifically tailored for embedded Linux-based devices.
* Media Library-based on PacketVideo Opencore; The library supports a variety of commonly used audio, video format playback and recording, while supporting still image files. Encoding formats include MPEG4, H. MP3, AAC, AMR, JPG, PNG.
* Surface Manager-manages the display subsystem and provides seamless integration of 2D and 3D layers for multiple applications.
* Libwebcore-an up-to-date web browser engine with support for Android browser and an embeddable Web view.
* SGL-The underlying 2D graphics engine
* 3D Libraries-based OpenGL ES 1.0 APIs implementation; The library can use hardware 3D acceleration (if available) or use highly optimized 3D soft acceleration.
* FreeType-Bitmap (bitmap) and vector (vectors) font display.

* SQLite-A lightweight relational database engine that is available and powerful for all applications.
2) Android Runtime
Android includes a core library that provides most of the functionality of the JAVA programming language core Library.
Each Android application runs in its own process and has a separate instance of the Dalvik virtual machine. Dalvik is designed as a device that can run multiple virtual systems at the same time and efficiently. Dalvik Virtual Machine Execution (. dex) Dalvik executable, which is optimized for small memory usage. While the virtual machine is a register-based, all classes are compiled by the JAVA compiler and then converted to. dex format by the "DX" tool in the SDK to be executed by the virtual machine.
Dalvik virtual machines rely on some of the features of the Linux kernel, such as threading mechanisms and underlying memory management mechanisms.
4.Linux kernel
Android's core system services rely on the Linux 2.6 kernel, such as security, memory management, process management, network protocol stacks, and drive models. The Linux kernel also acts as an abstraction layer between the hardware and the software stack.

8. Please describe the five types of layouts commonly used in Android
Android layout is an important part of the development of the application interface, in Android, there are five kinds of layout methods, namely: Framelayout (frame layout), LinearLayout (linear layout), Absolutelayout (absolute layout), Relativelayout (relative layout), tablelayout (table layout).

9. How to enable service, how to deactivate service
Services in Android and services in Windows are similar, services generally do not have user interface, it runs in the system is not easy to be detected by the user, you can use it to develop such as monitoring programs. The development of the service is relatively simple, as follows:
First step: Inheriting the Service class
public class SMSService extends Service {
}
Step Two: Configure the service in the node in the Androidmanifest.xml file:

The service cannot run itself and needs to start the service by calling the Context.startservice () or Context.bindservice () method. Both of these methods can start the service, but they are used in different situations. The service is enabled with the StartService () method, the caller is not connected to the service, and the service is still running even if the caller exits. Using the Bindservice () method to enable the service, the caller and the service are bound together, and once the caller exits, the service terminates, and there is a "no need to live at the same time Must Die" feature.

If you plan to start the service with the Context.startservice () method, the system calls the service's OnCreate () method first, and then calls the OnStart () method when the service is not created. If the StartService () method is called before the service has been created, calling the StartService () method multiple times does not cause the service to be created more than once, but results in multiple calls to the OnStart () method. Services started with the StartService () method can only call the Context.stopservice () method to end the service, and the OnDestroy () method is called at the end of the service.

If you plan to start the service with the Context.bindservice () method, the system calls the service's OnCreate () method first, and then calls the Onbind () method when the service is not created. This time the caller and the service are bound together and the caller exits, the system calls the service's Onunbind () method first, and then calls the OnDestroy () method. If the service is already bound before the Bindservice () method is called, multiple calls to the Bindservice () method do not cause the service and bindings to be created multiple times (that is, the onCreate () and Onbind () methods are not called multiple times). If the caller wants to unbind the service being bound, it can call the Unbindservice () method, and calling the method will also cause the system to invoke the service's Onunbind () –>ondestroy () method.
The service common life cycle callback method is as follows:
OnCreate () This method is called when the service is created, and the method is only called once, and the service is created only once, regardless of how many times the StartService () or Bindservice () method is called.
OnDestroy () This method is called when the service is terminated.

Life cycle methods related to starting services with the Context.startservice () method
OnStart () The method is only invoked when the service is started with the Context.startservice () method. This method is called when the service starts running. The StartService () method is called multiple times although the service is not created more than once, but the OnStart () method is called multiple times.

Life cycle methods related to starting services with the Context.bindservice () method
Onbind () The method is only invoked when the service is started with the Context.bindservice () method. This method is called when the caller and the service are bound, and the Context.bindservice () method is called multiple times when the caller is tied to the service and does not cause the method to be called more than once.
Onunbind () The method is only invoked when the service is started with the Context.bindservice () method. This method is called when the caller and the service are unbound

The code to start the service using the Context.startservice () method is as follows:

 Public  class helloactivity extends Activity {    @Override     Public void onCreate(Bundle savedinstancestate)        {        ...... Button button = (Button) This. Findviewbyid (R.id.button); Button.setonclicklistener (NewView.onclicklistener () { Public void OnClick(View v) {Intent Intent =NewIntent (helloactivity. This, Smsservice.class);       StartService (Intent);          }}); }}

Use the Context. The code for the Bindservice () method starts the service as follows:

 Public  class helloactivity extends Activity {Serviceconnection conn =NewServiceconnection () { Public void onserviceconnected(componentname name, IBinder service) {           } Public void onservicedisconnected(componentname name) {           }     };@Override        Public void onCreate(Bundle savedinstancestate) {button button = (Button) This. Findviewbyid (R.id.button); Button.setonclicklistener (NewView.onclicklistener () { Public void OnClick(View v) {Intent Intent =NewIntent (helloactivity. This, Smsservice.class); Bindservice (Intent, Conn, context.bind_auto_create);//unbindservice (conn);//Unbind}}); }}

10. Broadcast Receiver life cycle
A broadcast receiver has a callback method: void OnReceive (Context curcontext, Intent broadcastmsg). When a broadcast message arrives at the receiver, Android calls its onreceive () method and passes it to the Intent object that contains the message. The broadcast receiver is considered to be active only when it executes this method. When OnReceive () returns, it is inactive.
The process of having an active broadcast receiver is protected and will not be killed. However, the system can kill only inactive components at any time when the process is needed by other processes that occupy the memory.
This poses a problem when the response of a broadcast message is time-consuming, so it should be done in a separate thread, away from the main thread that the other components of the user interface are running. If the onreceive () derived thread then returns, the entire process, including the new thread, is judged inactive (unless the other application component in the process is active), it will put it in a crisis of being killed. The way to solve this problem is to OnReceive () Start a service and do the work in a timely manner, so the system knows that there is active work in progress.

11. Design mode and IoC (control inversion)
The source of the Android Framework's appeal is the IOC, which in the process of developing Android you will always feel the IOC brings
Great convenience, take the Activity, the following function is called automatically by the framework call:
protected void OnCreate (Bundle savedinstancestate);
Instead of being called by the program writer, the user-written code is called by the framework, which reverses
The Of course, the IOC itself is much more than that, but in this case you can also peep out the IOC
Bring great benefits. Examples of this class are ubiquitous in Android, such as the management class for databases,
For example, the Handler call of SAX in Android. Sometimes, you even need to write your own Jane
Single IoC implementation, the multithreading shown above is now a description.

12. What is ANR how to avoid it?
Anr:application Not Responding, five sec
In Android, the two system services, Activity Manager and window manager, are responsible for monitoring the response of the application. Android Displays the ANR dialog box when the following conditions occur:
More than 5 seconds of response to input events such as keystrokes, touch-screen events
Intent Receiver (Intentreceiver) has not been executed for more than 10 seconds
The Android application runs completely in a separate line approached (for example, main). This means that any operation that runs in the main thread and consumes a lot of time will cause the ANR. Because at this point, your application has no chance to respond to input events and intent broadcasts (Intent broadcast).

Therefore, any method that runs in the main thread should do as little work as possible. In particular, important methods in the life cycle of the activity, such as onCreate () and Onresume (), should be more so. Potentially more time-consuming operations, such as access to networks and databases; Or a very expensive calculation, such as changing the size of a bitmap, that needs to be done in a separate sub-thread (or with an asynchronous request, such as a database operation). But this does not mean that your main thread needs to go into a blocking state that has waited for the child thread to end – nor does it need to call the therad.wait () or Thread.Sleep () method. Instead, the main thread provides a handle (Handler) for the child thread, allowing the child thread to call it at the end of the process (Xing: See the example of Snake, which differs from what we were in contact with previously). Using this approach involves your application, which ensures that your program responds well to the input and avoids the ANR resulting from an input event that is not processed for more than 5 seconds. This practice needs to be applied to all threads that display the user interface, because they all face the same timeout problem.

What are some of the methods that must be executed when jumping between 13 and two activity?
In general, for example, there are two activity, called a A, a, when the B component is activated in a, a calls the OnPause () method, then B calls OnCreate (), OnStart (), Onresume ().

This time B overrides the form, and a calls the OnStop () method. If B is a transparent, or a dialog box style, the OnStop () method of a is not called.

14. Single-Case mode
See http://blog.csdn.net/jason0539/article/details/23297037/

15.Listview list Efficiency optimization
(1) Recycle view with Convertview
(2) Adopt Viewholder mode
(3) Loading images asynchronously
(4) Do not load pictures when sliding quickly
(5) If you have a picture in your custom item, you need to process the picture (reduce the memory of the image)
1. Edge compression of the image 2. Use the option class to save the image size 3. Avoid real-time zooming of pictures, preferably zoom to view size beforehand
(6) Try to avoid using threads in the ListView adapter, because threads are the primary cause of memory leaks because the thread's life cycle is not controllable.

16. Applying Memory optimization
(1) Bitmap set picture size (optimized memory overflow)
Bitmapfactory.option Option = new Bitmapfactory.option ();
Option.insamplesize = 2; Change the view width and height to the original 1/2
(2) Bitmap object is destroyed, you can use Recycle () method to let GC Reclaim bitmap object.
(3) Try to avoid static member variables referencing instances of excessive resource consumption, such as: Context
(4) using the application context
(5) Close resources in a timely manner, such as the need to close the cursor when querying the database
(6) Use soft references to frequently used images to save
(7) Threading is also an important cause of memory leaks, in that the life cycle of the thread is not controllable, the workaround:
1. Change the thread inner class to a static inner class
2. Saving a context reference with a weak reference
(8) use. 9 Images

17. Methods of data storage
Sharedpreference storage, file storage, SQLite storage, contentprovide storage, networked storage data

18.set, List difference: The elements in set are not duplicated
A reference to the object is stored, no duplicate objects

   Set Set=NewHashSet ();StringS1=New String("Hello");StringS2=S1;StringS3=New String("World");Set.Add (S1);Set.Add (S2);Set.Add (S3); System.Out.printlnSet.Size ());the number of objects in the//print collection is 2. 

Add:
ArrayList (): Represents the length can be changed by the group. Elements can be randomly accessed, inserted into ArrayList () and
is slower than deleting elements.
LinkedList (): A linked list data structure is used in the implementation. Fast insertion and deletion, and slow access times.

18. Static Inner class
(1) bunengdingy static member variables and methods in non-static inner classes
(2) External classes and non-static inner classes can access their own private members
(3) Static inner classes can only access static members of external classes

The principle of the

19.handler mechanism
Andriod provides handler and Looper to accommodate inter-thread communication. Handler first-out principle. The Looper class is used to manage message exchange (Messageexchange) between objects within a particular thread.
1) Looper: A thread can produce a Looper object that manages MessageQueue (Message Queuing) for this line thread.
2) Handler: You can construct a Handler object to communicate with Looper in order to push a new message into the MessageQueue, or to receive a message sent by Looper from MessageQueue.
3) MessageQueue (Message Queuing): Used to hold messages placed by a thread.
4) Thread: Uithread is usually mainthread, and Android initiates a MessageQueue for it.

20.assest folder to put files, there is no limit to the size of the file?
The answer resolution assets directory is more like an appendix type directory, Android does not generate an ID for the files in this directory and is saved in the R class, so it is less compatible with some classes and methods in Android. At the same time, because you need a string path to get the file descriptor in this directory, the access speed will be slower. But putting some files in this directory can make things easier, such as copying a database file into system memory. Note that you cannot refer to files in the assets directory in the Android XML file, only through Assetmanager to access the files. Database files and game data are better placed in this directory. In addition, the online information about assets and Raw is the same, so the error Description of the individual file size cannot exceed 1M is also spread, that is, if reading more than 1M files will be reported "Data exceeds Uncompress_data_ MAX (1314625 vs 1048576) "IOException, but also derived a variety of solutions. Personally think there should be no such restrictions, in order to verify that this statement wrote a demo, found that nearly 5 m of the compression package in assets and raw can be access to normal, so here to correct, theoretically as long as the package does not exceed the size of Android APK 50M limit is not a problem. Of course, it is not ruled out that Android is very early because of the device hardware reasons AAPT at the time of compiling the two folder size restrictions, if so, the newer version of ADT should not have this situation.

21. Process destruction priorities and their respective meanings.
The importance sequence is: foreground process, visible process, service process, background process and empty process, so the order of destruction is reverse direction.
Foreground process (foreground): The process currently being displayed on the screen and some system processes. For example, Dialer Storage,google
Search and other system processes is the foreground process, for example, when you run a program, such as a browser, when the browser interface is displayed in the foreground, the browser belongs to the foreground process (foreground), but once you press home to return to the main interface, The browser becomes a background program (background).
The last process we want to terminate is the foreground process. Visible process (visible):
Visible process is not in the foreground, but the user is still visible process, for example: Widgets, Input method, etc., are visible. Although this part of the process is not in the foreground, but also closely related to our use, we do not want them to be terminated (you certainly do not want the clock, weather, news and other widgets are terminated, then they will not sync, you do not want the input method is terminated, or you need to restart input input every time)
Secondary services (secondary server):
Some of the services currently running (major services, such as dialing, etc., are not likely to be terminated by the process management, so this is only a minor service), for example: Google Enterprise Suite, gmail internal storage, contact internal storage, and so on. Although this part of the service is a secondary service, but some of the system functions are still closely related, we often need to use them, so we also hope they are terminated
Background process (hidden):
Although the word hidden is used, it is actually a background process (background), which is the process that we generally understand to be switched to the background after startup, such as a browser, a reader, and so on. When the program is displayed on the screen, the process that he runs is the foreground process (foreground), and once we press home to return to the main interface (note that by pressing home, not pressing back), the program resides in the background and becomes the background process (background). Background process Management policy has a variety of: in a more positive way, once the program arrives in the background immediately terminate, this way will increase the speed of the program, but can not speed up the program to start again, there are more negative ways, as much as possible to retain the background program, although it may affect the speed of a single program, However, the speed is increased when you start a program that has started again. This will require users to find a balance based on their own usage habits.
Content Provisioning Node (provider):
There is no program entity, just provide the content for other programs to use, such as Calendar supply node, mail supply node and so on. When the process is terminated, such programs should have a higher priority null process (empty):
There is nothing in the process of running, some programs, such as BTE, after the program exits, will still reside in the process of an empty process, the process is not any data running, the role is often to improve the program's next startup speed or record some of the history of the program.
This part of the process is undoubtedly the first to be terminated. Add:
The importance of the process is evaluated and the importance is expressed in terms of the value "Oom_adj", which is given to each process, (the system determines which processes need to end according to "Oom_adj"), in general, the higher the value of "Oom_adj", the higher the likelihood that the process will be terminated by the system selection)
The "Oom_adj" value of the foreground program is 0, which means it will not be terminated by the system, once it is inaccessible, it will get a higher "Oom_adj", presumably the value of "Oom_adj" is determined by the location of the software in the LRU list; Android is different from Linux. Has its own unique process Management module, this module is more customizable, can be based on the "Oom_adj" value of the scope to determine the process management policy, such as can be set "when memory is less than X, the end of" Oom_adj "greater than Y process". This gives the process management script the option to write more.

What is the role of 22.Adapter? What are the common adapter?
Adapter is the adapter interface that connects the backend data to the front-end display. Common adapter are arrayadapter, Baseadapter, CursorAdapter, Headerviewlistadapter, ListAdapter, Resourcecursoradapter, Simpleadapter, Simplecursoradapter, Spinneradapter, Wrapperlistadapter, etc.

23. Start a program, you can click on the main interface icon to enter, you can also jump from a program in the past, what is the difference between the two?
is because the launcher (the main interface is also an app), found that there is a set of activity in the program, so the launcher will put the icon, put on the main interface. When the user clicks on icon, issue a intent:intent Intent = Mactivity.getpackagemanager (). Getlaunchintentforpackage (PackageName); Mactivity.startactivity (Intent); Jump past can jump to any allowed page, such as a program can be downloaded, then the actual download page may not be the homepage (also may be the homepage), at this time or construct a intent,startactivity. The action in this intent can be a variety of view,download. The system will select the program or page that can be opened for your intent according to the function that the third party program registers with the system. So the only thing that's different is that the intent action from the icon's click is relatively single, jumping from the program or booting may be more of a style. The essence is the same.

24.Android provides 5 ways of storing data
(1) using sharedpreferences to store data; it is a mechanism provided by Android to store some simple configuration information, using XML format to store data in the device. Can only be used within the same package and cannot be used between different packages. (2) file storage data; File storage is a more common method, the method of reading/writing files in Android is exactly the same as the program implementing I/O in Java, providing Openfileinput () and Openfileoutput () method to read the file on the device.
(3) SQLite database stores data; SQLite is a standard database with Android, it supports SQL statements, it is a lightweight embedded database.
(4) Use ContentProvider to store data, primarily for data exchange between applications, enabling other applications to save or read the various data types of this content provider.
(5) Network storage data, upload (store) and download (obtain) The data we store in cyberspace through the storage space provided to us on the network.

What scenarios are used in 25.AsyncTask? What is its flaw? How to solve?
The scenario that Asynctask uses is that we need to take some time-consuming actions, update the main thread when the operation is complete, or update the UI of the main thread during the operation. BUG: Asynctask maintains a thread pool of length 128, can execute 5 worker threads, and a buffer queue, when a thread pool already has 128 threads and the buffer queue is full, if the task is submitted to the thread at this time, Rejectedexecutionexception will be thrown. Workaround: The call from a control thread to handle the asynctask determines whether the thread pool is full, or if it is full, then request Asynctask to continue processing.

Android Classic face test summary (not to be continued)