Android self-use -- asynctask implements asynchronous Processing Tasks

When developing Android applications, you must follow the single-thread model principle: Android UI operations are not thread-safe and must be executed in the UI thread. In a single-threaded model, you must always remember the following two rules:
1. Do not block the UI thread
2. Make sure to only access the android UI toolkit in the UI thread
When a program is started for the first time, Android starts a corresponding main thread at the same time. The main thread is mainly responsible for processing UI-related events, such as user key events, the user contacts screen events and Screen Drawing events, and distributes related events to corresponding components for processing. Therefore, the main thread is often called the UI thread.
For example, you can obtain a webpage from the Internet and display its source code in a textview. This kind of program involving network operations generally requires a thread to complete network access. However, after obtaining the page source code, yes. textview cannot be called directly in the Network Operation thread. settext. because other threads cannot directly access the main UI thread Member

Android provides several methods to access the UI thread in other threads.
Activity. runonuithread (runnable)
View. Post (runnable)
View. postdelayed (runnable, long)
Hanlder
These classes or methods also make your code complex and hard to understand. However, when you need to implement complex operations and frequently update the UI, this will become worse.

To solve this problem, Android 1.5 provides a tool class: asynctask, which makes it easier to create long-running tasks that need to interact with the user interface. It can be implemented without using threads and handler.
Asynctask is an abstract class. asynctask defines three generic types: Params, SS, and result.
Input parameters for Params startup task execution, such as the URL of the HTTP request.
Percentage of progress background tasks.
Result: The result returned when the task is executed in the background, such as string.

The execution of asynctask is divided into four steps. Each step corresponds to a callback method, which should not be called by the application. All developers need to do is implement these methods.
1) subclass asynctask
2) implement one or more of the following methods defined in asynctask
Onpreexecute (), this method will be called by the UI thread before the actual background operation is executed. You can make some preparations in this method, such as displaying a progress bar on the interface.
Doinbackground (Params...) will be executed immediately after the onpreexecute method is executed. This method runs in the background thread. Here, we will primarily perform those time-consuming background computing tasks. You can call publishprogress to update the real-time task progress. This method is an abstract method and must be implemented by sub-classes.
Onprogressupdate (Progress...), after the publishprogress method is called, UI thread will call this method to display the progress of the task on the interface, for example, display through a progress bar.
Onpostexecute (result). After doinbackground is executed, the onpostexecute method will be called by the UI thread, and the background computing result will be passed to the UI thread through this method.

To correctly use the asynctask class, the following guidelines must be followed:
1) The task instance must be created in the UI thread.
2) The execute method must be called in the UI thread.
3) do not manually call the onpreexecute (), onpostexecute (result), doinbackground (Params...), onprogressupdate (Progress...) methods.
4) The task can only be executed once. Otherwise, exceptions may occur during multiple calls.

Obtain a webpage from the Internet and display its source code in a textview.

Java code

1. Package test. List;
2. Import java. Io. bytearrayoutputstream;
3. Import java. Io. inputstream;
4. Import java. util. arraylist;
6. Import org. Apache. http. httpentity;
7. Import org. Apache. http. httpresponse;
8. Import org. Apache. http. Client. httpclient;
9. Import org. Apache. http. Client. Methods. httpget;
10. Import org. Apache. http. impl. Client. defaulthttpclient;
12. Import Android. App. activity;
13. Import Android. App. progressdialog;
14. Import Android. content. context;
15. Import Android. content. dialoginterface;
16. Import Android. OS. asynctask;
17. Import Android. OS. Bundle;
18. Import Android. OS. Handler;
19. Import Android. OS. message;
20. Import Android. View. view;
21. Import Android. widget. Button;
22. Import Android. widget. edittext;
23. Import Android. widget. textview;
25. Public class networkactivity extends activity {
26. Private textview message;
27. Private button open;
28. Private edittext URL;
30. @ Override
31. Public void oncreate (bundle savedinstancestate ){
32. Super. oncreate (savedinstancestate );
33. Setcontentview (R. layout. Network );
34. Message = (textview) findviewbyid (R. Id. Message );
35. Url = (edittext) findviewbyid (R. Id. url );
36. Open = (button) findviewbyid (R. Id. Open );
37. Open. setonclicklistener (New View. onclicklistener (){
38. Public void onclick (view arg0 ){
39. Connect ();
40. }
41. });
43. }
45. Private void connect (){
46. Pagetask task = new pagetask (this );
47. Task.exe cute (URL. gettext (). tostring ());
48. }
51. Class pagetask extends asynctask <string, integer, string> {
52. // Variable length input parameter, which corresponds to asynctask. exucute ()
53. Progressdialog pdialog;
54. Public pagetask (context ){
55. Pdialog = new progressdialog (context, 0 );
56. Pdialog. setbutton ("cancel", new dialoginterface. onclicklistener (){
57. Public void onclick (dialoginterface dialog, int I ){
58. Dialog. Cancel ();
59. }
60. });
61. Pdialog. setoncancellistener (New dialoginterface. oncancellistener (){
62. Public void oncancel (dialoginterface DIALOG ){
63. Finish ();
64. }
65. });
66. Pdialog. setcancelable (true );
67. Pdialog. setmax (100 );
68. Pdialog. setprogressstyle (progressdialog. style_horizontal );
69. Pdialog. Show ();
72. }
73. @ Override
74. Protected string doinbackground (string... Params ){
76. Try {
78. Httpclient client = new defaulthttpclient ();
79. // Params [0] indicates the URL of the connection.
80. Httpget = new httpget (Params [0]);
81. Httpresponse response = client.exe cute (get );
82. Httpentity entity = response. getentity ();
83. Long length = entity. getcontentlength ();
84. Inputstream is = entity. getcontent ();
85. String S = NULL;
86. If (is! = NULL ){
87. Bytearrayoutputstream baos = new bytearrayoutputstream ();
89. Byte [] Buf = new byte [1, 128];
91. Int CH =-1;
93. Int COUNT = 0;
95. While (CH = is. Read (BUF ))! =-1 ){
97. Baos. Write (BUF, 0, CH );
99. Count + = CH;
101. If (length> 0 ){
102. // If you know the response length, call publishprogress () to update the progress.
103. Publishprogress (INT) (count/(float) length) * 100 ));
104. }
106. // Sleep the thread for 100 ms
107. Thread. Sleep (100 );
108. }
109. S = new string (baos. tobytearray ());}
110. // Return results
111. Return S;
112. } Catch (exception e ){
113. E. printstacktrace ();
115. }
117. Return NULL;
119. }
121. @ Override
122. Protected void oncancelled (){
123. Super. oncancelled ();
124. }
126. @ Override
127. Protected void onpostexecute (string result ){
128. // Return the HTML page content
129. Message. settext (result );
130. Pdialog. Dismiss ();
131. }
133. @ Override
134. Protected void onpreexecute (){
135. // Start the task. A dialog box is displayed here, which is simple.
136. Message. settext (R. String. task_started );
137. }
139. @ Override
140. Protected void onprogressupdate (integer... values ){
141. // Update Progress
142. System. Out. println ("" + values [0]);
143. Message. settext ("" + values [0]);
144. Pdialog. setprogress (Values [0]);
145. }
147. }
149. }