webview的进度条的加载,webview的使用以及handle的理解与使用

Webview的几个关键方法要介绍一些:

谷歌官方文档是这么说的;

A WebView has several customization points where you can add your own behavior. These are:

• Creating and setting a WebChromeClient subclass. This class is called when something that might impact a browser UI happens, for instance, progress updates and JavaScript alerts are sent here (see Debugging Tasks).
• Creating and setting a WebViewClient subclass. It will be called when things happen that impact the rendering of the content, eg, errors or form submissions. You can also intercept URL loading here (via shouldOverrideUrlLoading()).
• Modifying the WebSettings, such as enabling JavaScript with setJavaScriptEnabled().
• Injecting Java objects into the WebView using the addJavascriptInterface(Object, String) method. This method allows you to inject Java objects into a page's JavaScript context, so that they can be accessed by JavaScript in the page.

Here's a more complicated example, showing error handling, settings, and progress notification:

 // Let's display the progress in the activity title bar, like the
  // browser app does.
  getWindow().requestFeature(Window.FEATURE_PROGRESS);

  webview.getSettings().setJavaScriptEnabled(true);

  final Activity activity = this;
  webview.setWebChromeClient(new WebChromeClient() {
    public void onProgressChanged(WebView view, int progress) {
      // Activities and WebViews measure progress with different scales.
      // The progress meter will automatically disappear when we reach 100%
      activity.setProgress(progress * 1000);
    }
  });
  webview.setWebViewClient(new WebViewClient() {
    public void onReceivedError(WebView view, int errorCode, String description, String failingUrl) {
      Toast.makeText(activity, "Oh no! " + description, Toast.LENGTH_SHORT).show();
    }
  });

  webview.loadUrl("http://developer.android.com/");

   webView1.loadUrl("http://stormzhang.com");//这个就不说了
         webView1.setWebViewClient(new WebViewClient() {//

必须记得,这个方法的创建的webviewclient的shouldOverrideUrlLoading必须实现,不然在一个网页
内中的链接会跳转到用本地的浏览器打开,而不是你自己的浏览器打开,使用其中的view.loadUrl(url)就可以实现

             public boolean shouldOverrideUrlLoading(WebView view, String url) {
                 view.loadUrl(url);

                 return super.shouldOverrideUrlLoading(view, url);
             }

             @Override
             public void onPageStarted(WebView view, String url, Bitmap favicon) {
                 // TODO Auto-generated method stub
                 super.onPageStarted(view, url, favicon);

             }

             @Override
             public void onPageFinished(WebView view, String url) {
                 // TODO Auto-generated method stub
                 super.onPageFinished(view, url);

             }

         });

         webView1.setWebChromeClient(new WebChromeClient() {
             @Override
             public void onProgressChanged(WebView view, int newProgress) {//
意思就是网页在不停的加载,本方法就在不停的进行,newProgress就是实际得到的
进度,可以根据此回调函数来完成进度条的控制.
                 super.onProgressChanged(view, newProgress);
                 if(newProgress==100){
                     progressBar.setVisibility(View.GONE);//加载完网页进度条消失
                 }
                 else{
                     progressBar.setVisibility(View.VISIBLE);//开始加载网页时显示进度条
                     progressBar.setProgress(newProgress);//设置进度值
                 }
             }
         });
具体的例子如下:

主界面布局文件:

     <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"
         tools:context=".MainActivity"
         android:orientation="vertical"
        >
         <RelativeLayout
         android:layout_width="match_parent"
         android:layout_height="40dp"
         android:background="#1B9A16"  

             />  

         <ProgressBar
             android:id="@+id/progressBar1"
             style="?android:attr/progressBarStyleHorizontal"
             android:layout_width="match_parent"
             android:layout_height="3dip"
             android:progressDrawable="@drawable/pg"
             android:visibility="gone"  

             />  

         <WebView
             android:id="@+id/webview1"
             android:layout_below="@id/progressBar1"
             android:layout_width="match_parent"
             android:layout_height="match_parent" />  

     </LinearLayout>  

MainActivity文件:

 package com.example.webview;  

 import android.os.Bundle;
 import android.app.Activity;
 import android.transition.Visibility;
 import android.view.KeyEvent;
 import android.view.Menu;
 import android.view.View;
 import android.view.Window;
 import android.webkit.WebChromeClient;
 import android.webkit.WebSettings;
 import android.webkit.WebView;
 import android.webkit.WebViewClient;
 import android.widget.ProgressBar;  

 public class MainActivity extends Activity {  

     private WebView webView;
     private ProgressBar pg1;
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         requestWindowFeature(Window.FEATURE_NO_TITLE);
         setContentView(R.layout.activity_main);
         init();
         webView.loadUrl("http://www.baidu.com");
     }  

     private void init() {
         // TODO 自动生成的方法存根
         webView=(WebView) findViewById(R.id.webview1);
         pg1=(ProgressBar) findViewById(R.id.progressBar1);  

         webView.setWebViewClient(new WebViewClient(){
             //覆写shouldOverrideUrlLoading实现内部显示网页
             @Override
             public boolean shouldOverrideUrlLoading(WebView view, String url) {
                 // TODO 自动生成的方法存根
                 view.loadUrl(url);
                 return true;
             }
         });
         WebSettings seting=webView.getSettings();
         seting.setJavaScriptEnabled(true);//设置webview支持javascript脚本
         webView.setWebChromeClient(new WebChromeClient(){
             @Override
             public void onProgressChanged(WebView view, int newProgress) {
                 // TODO 自动生成的方法存根  

                 if(newProgress==100){
                     pg1.setVisibility(View.GONE);//加载完网页进度条消失
                 }
                 else{
                     pg1.setVisibility(View.VISIBLE);//开始加载网页时显示进度条
                     pg1.setProgress(newProgress);//设置进度值
                 }  

             }
         });  

     }  

     //设置返回键动作（防止按返回键直接退出程序)
     @Override
     public boolean onKeyDown(int keyCode, KeyEvent event) {
         // TODO 自动生成的方法存根
         if(keyCode==KeyEvent.KEYCODE_BACK) {
             if(webView.canGoBack()) {//当webview不是处于第一页面时，返回上一个页面
                 webView.goBack();
                 return true;
             }
             else {//当webview处于第一页面时,直接退出程序
                 System.exit(0);
             }  

         }
         return super.onKeyDown(keyCode, event);
     }
       

知识延伸:

一、Handler的定义：

主要接受子线程发送的数据， 并用此数据配合主线程更新UI。

解释：当应用程序启动时，Android首先会开启一个主线程 (也就是UI线程) ， 主线程为管理界面中的UI控件， 进行事件分发， 比如说， 你要是点击一个 Button ，Android会分发事件到Button上，来响应你的操作。  如果此时需要一个耗时的操作，例如: 联网读取数据，    或者读取本地较大的一个文件的时候，你不能把这些操作放在主线程中，如果你放在主线程中的话，界面会出现假死现象， 如果5秒钟还没有完成的话，会收到Android系统的一个错误提示  "强制关闭"。  这个时候我们需要把这些耗时的操作，放在一个子线程中，因为子线程涉及到UI更新，，Android主线程是线程不安全的， 也就是说，更新UI只能在主线程中更新，子线程中操作是危险的。 这个时候，Handler就出现了。，来解决这个复杂的问题 ，由于Handler运行在主线程中(UI线程中)，  它与子线程可以通过Message对象来传递数据， 这个时候，Handler就承担着接受子线程传过来的(子线程用sedMessage()方法传弟)Message对象，(里面包含数据)  ， 把这些消息放入主线程队列中，配合主线程进行更新UI。

二、Handler一些特点

handler可以分发Message对象和Runnable对象到主线程中， 每个Handler实例，都会绑定到创建他的线程中(一般是位于主线程)，它有两个作用：

(1)安排消息或Runnable 在某个主线程中某个地方执行；

(2)安排一个动作在不同的线程中执行。

Handler中分发消息的一些方法

post(Runnable)

postAtTime(Runnable，long)

postDelayed(Runnable long)

sendEmptyMessage(int)

sendMessage(Message)

sendMessageAtTime(Message，long)

sendMessageDelayed(Message，long)

以上post类方法允许你排列一个Runnable对象到主线程队列中，

sendMessage类方法， 允许你安排一个带数据的Message对象到队列中，等待更新。

三、Handler实例

子类需要继承Hendler类，并重写handleMessage(Message msg) 方法， 用于接受线程数据。

以下为一个实例，它实现的功能为：通过线程修改界面Button的内容

1. public class MyHandlerActivity extends Activity {
2. Button button;
3. MyHandler myHandler;
4. protected void onCreate(Bundle savedInstanceState) {
5. super。onCreate(savedInstanceState);
6. setContentView(R。layout。handlertest);
7. button = (Button) findViewById(R。id。button);
8. myHandler = new MyHandler();
9. // 当创建一个新的Handler实例时， 它会绑定到当前线程和消息的队列中，开始分发数据
10. // Handler有两个作用， (1) : 定时执行Message和Runnalbe 对象
11. // (2): 让一个动作，在不同的线程中执行。
12. // 它安排消息，用以下方法
13. // post(Runnable)
14. // postAtTime(Runnable，long)
15. // postDelayed(Runnable，long)
16. // sendEmptyMessage(int)
17. // sendMessage(Message);
18. // sendMessageAtTime(Message，long)
19. // sendMessageDelayed(Message，long)
20. // 以上方法以 post开头的允许你处理Runnable对象
21. //sendMessage()允许你处理Message对象(Message里可以包含数据，)
22. MyThread m = new MyThread();
23. new Thread(m)。start();
24. }
25. /**
26. * 接受消息，处理消息 ，此Handler会与当前主线程一块运行
27. * */
28. class MyHandler extends Handler {
29. public MyHandler() {
30. }
31. public MyHandler(Looper L) {
32. super(L);
33. }
34. // 子类必须重写此方法，接受数据
35. @Override
36. public void handleMessage(Message msg) {
37. // TODO Auto-generated method stub
38. Log。d("MyHandler"， "handleMessage。。。。。。");
39. super。handleMessage(msg);
40. // 此处可以更新UI
41. Bundle b = msg。getData();
42. String color = b。getString("color");
43. MyHandlerActivity。this。button。append(color);
44. }
45. }
46. class MyThread implements Runnable {
47. public void run() {
48. try {
49. Thread。sleep(10000);
50. } catch (InterruptedException e) {
51. // TODO Auto-generated catch block
52. e。printStackTrace();
53. }
54. Log。d("thread。。。。。。。"， "mThread。。。。。。。。");
55. Message msg = new Message();
56. Bundle b = new Bundle();// 存放数据
57. b。putString("color"， "我的");
58. msg。setData(b);
59. MyHandlerActivity。this。myHandler。sendMessage(msg); // 向Handler发送消息，更新UI
60. }
61. }
62. }

---

progressbar与handle结合的一个例子:

谷歌官方的一个实例:

实现动态更新ProgressBar的水平进度条：

布局文件progressBar.xml如下：

1. <span style="font-size:18px;"><?xml version="1.0" encoding="utf-8"?>
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
3. android:orientation="vertical"
4. android:layout_width="match_parent"
5. android:layout_height="match_parent">
6. <LinearLayout
7. android:orientation="horizontal"
8. android:layout_width="wrap_content"
9. android:layout_height="wrap_content">
10. <!--大型环状进度条-->
11. <ProgressBar
12. android:id="@+id/bar1"
13. style="@android:style/Widget.ProgressBar.Large"
14. android:layout_width="wrap_content"
15. android:layout_height="wrap_content"/>
16. <!--中型环状进度条-->
17. <ProgressBar
18. android:id="@+id/bar2"
19. style="@android:style/Widget.ProgressBar"
20. android:layout_width="wrap_content"
21. android:layout_height="wrap_content"/>
22. <!--小型环状进度条-->
23. <ProgressBar
24. android:id="@+id/bar3"
25. style="@android:style/Widget.ProgressBar.Small"
26. android:layout_width="wrap_content"
27. android:layout_height="wrap_content"/>
28. </LinearLayout>
29. <TextView
30. android:id="@+id/tv1"
31. android:layout_width="match_parent"
32. android:layout_height="25dp"/>
33. <!--水平进度条-->
34. <ProgressBar
35. android:id="@+id/bar4"
36. style="@android:style/Widget.ProgressBar.Horizontal"
37. android:layout_width="match_parent"
38. android:layout_height="wrap_content"/>
39. </LinearLayout></span>

MyprogressBar.java代码如下：

1. <span style="font-size:18px;">package com.example.lenovo.photobrowse;
2. import android.os.Bundle;
3. import android.os.Handler;
4. import android.os.Message;
5. import android.support.annotation.Nullable;
6. import android.support.v7.app.AppCompatActivity;
7. import android.widget.ProgressBar;
8. import android.widget.TextView;
9. import android.widget.Toast;
10. import java.util.Random;
11. /**
12. * Created by lenovo on 2016/5/24.
13. */
14. public class MyprogessBar extends AppCompatActivity {
15. //该程序模拟填充长度为100的数组
16. private int[] data = new int[100];
17. private int hasData = 0;
18. //记录progressBar的完成程度
19. private int status = 0;
20. private ProgressBar bar1;
21. private ProgressBar bar2;
22. private TextView tv;
23. //创建一个负责更新进度的hander
24. Handler mHandler = new Handler(){
25. @Override
26. public void handleMessage(Message msg) {
27. if(msg.what == 0x111){
28. bar1.setProgress(status);
29. bar2.setProgress(status);
30. tv.setText("已完成"+status+"%");
31. if(status==100)
32. Toast.makeText(MyprogessBar.this,"以下载完成",Toast.LENGTH_SHORT).show();
33. }
34. }
35. };
36. @Override
37. protected void onCreate(@Nullable Bundle savedInstanceState) {
38. super.onCreate(savedInstanceState);
39. setContentView(R.layout.progresssbar_layout);
40. bar1 = (ProgressBar) findViewById(R.id.bar1);
41. bar2 = (ProgressBar) findViewById(R.id.bar4);
42. tv = (TextView) findViewById(R.id.tv1);
43. //启动线程来执行任务
44. new Thread(){
45. @Override
46. public void run() {
47. while(status<100) {
48. //获取耗时操作的完成百分比
49. status = doWork();
50. //发送消息
51. mHandler.sendEmptyMessage(status);
52. }
53. }
54. }.start();
55. }
56. //模拟一个耗时的操作
57. private int doWork() {
58. data[hasData++] = (int)(Math.random()*100);
59. try {
60. Thread.sleep(1000);
61. } catch (InterruptedException e) {
62. e.printStackTrace();
63. }
64. return hasData;
65. }

还有一个例子:

ProgressBar进度条，分为旋转进度条和水平进度条，进度条的样式根据需要自定义，之前一直不明白进度条如何在实际项目中使用，网上演示进度条的案例大多都是通过Button点击增加、减少进度值，使用方法incrementProgressBy(int)，最简单的做法是在xml布局文件中放置ProgressBar空间，然后再MainActivity中触发事件后执行incrementProgressBy(int)，代码如下：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

<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" tools:context="cn.teachcourse.www.MainActivity" android:orientation="vertical" android:gravity="center" android:id="@+id/onclick_ll" > <!--点击LinearLayout控件，改变ProgressBar进度--> <ProgressBar android:id="@+id/progressBar_horizontal" style="?android:attr/progressBarStyleHorizontal" android:layout_width="match_parent" android:layout_height="15dp" android:layout_marginTop="28dp"/>   </LinearLayout>

在Java代码中非常的简单，如下图：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

public class MainActivity extends ActionBarActivity implements View.OnClickListener{ private ProgressBar pb_large; private ProgressBar pb_normal; private ProgressBar pb_small; private ProgressBar pb_horizontal; private int readed; private int progressValue;   private LinearLayout onclick_ll;   @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); initView();   Drawable drawable = getResources().getDrawable( R.drawable.progress_bar_states);   pb_horizontal.setProgressDrawable(drawable);//设置水平滚动条的样式   pb_horizontal.setMax(100);//设置进度条的最大值 onclick_ll.setOnClickListener(this);//LinearLayout添加监视器 }   private void initView() { pb_horizontal = (ProgressBar) findViewById(R.id.progressBar_horizontal); onclick_ll=(LinearLayout)findViewById(R.id.onclick_ll); }   @Override public void onClick(View v) { pb_horizontal.incrementProgressBy(5); if(pb_horizontal.getProgress()==pb_horizontal.getMax()){ Toast.makeText(this, "进度条已经达到最大值,进度条消失", Toast.LENGTH_LONG).show(); pb_horizontal.setProgress(0); //当达到最大之后，进度值归0 } } }

我们这里展示的是ProgressBar读取文件字节流后，展示的读取进度条，上面的简单演示就不说了。

效果图：ProgressBar读取文件字节流演示

这里展示文件读取字节流过程中，ProgressBar进度变化情况，当读取完成，进度条刚好满，这在我们实际项目开发中，经常需要使用到，如何成为我写这篇文章的原因。
布局文件progress_horizontal_read_data.xml

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

<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" tools:context="cn.teachcourse.www.MainActivity" android:orientation="vertical" android:gravity="center" > <TextView android:layout_width="match_parent" android:layout_height="wrap_content" android:layout_weight="1" android:id="@+id/read_data_tv" android:text="@string/read_info" android:scrollbars="vertical" android:layout_marginLeft="10dp" android:layout_marginRight="10dp" android:lineSpacingExtra="10dp"/>   <ProgressBar android:id="@+id/progressBar_horizontal_read_data" style="?android:attr/progressBarStyleHorizontal" android:layout_width="match_parent" android:layout_height="15dp" android:layout_marginTop="28dp"/>   </LinearLayout>

Java代码ProgressBarActivity.java

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97

public class ProgressBarActivity extends ActionBarActivity { private ProgressBar pb_horizontal; private int readed; private int progressValue; private TextView mReadProgress_TV; private String mData; private StringBuffer sb;//每次读取到的字节数据存储 int length;//标记文件大小 private Thread thread;//读取文件线程 @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.progress_horizontal_read_data); initView();   Drawable drawable = getResources().getDrawable( R.drawable.progress_bar_states); String path = Environment.getExternalStorageDirectory() + "/ProgressMonitor.txt";// ProgressMonitor.txt是我存到sdcard中的一个文件，可以自定义文件名大小位置 final File file = new File(path);   if(file.exists()){ length=(int) file.length(); pb_horizontal.setMax(length);//设置进度条最大值 pb_horizontal.setProgressDrawable(drawable);//自定义进度条样式 } //启动一个线程读取文件内容 thread=new Thread() {   @Override public void run() { readFromFile(file.getAbsolutePath()); }   }; thread.start();   }   Handler handler = new Handler() {   @Override public void handleMessage(Message msg) { switch (msg.what) { case 110: progressValue += msg.arg1; pb_horizontal.setProgress(progressValue); mReadProgress_TV.setText(sb.toString()); if(progressValue==length){ Toast.makeText(ProgressBarActivity.this, "文件读取完成", Toast.LENGTH_LONG).show(); } Log.d("progressValue-------------->", progressValue + ""); break;   } }   };   public void readFromFile(String path) { FileInputStream fis; try { fis = new FileInputStream(path); DataInputStream dis = new DataInputStream(fis); sb=new StringBuffer(); byte b[] = new byte[10];// 每次读取1字节 while ((readed = dis.read(b)) != -1) { Message msg = new Message(); msg.arg1 = readed; msg.what = 110; mData=new String(b,0,readed); sb.append(mData); handler.sendMessage(msg); try { Thread.sleep(1000); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); }   }   dis.close(); fis.close(); } catch (Exception e) {   e.printStackTrace(); }   }   private void initView() { pb_horizontal = (ProgressBar) findViewById(R.id.progressBar_horizontal_read_data); mReadProgress_TV=(TextView)findViewById(R.id.read_data_tv); }   }

这里使用Handler消息处理，每次读取到数据后更新进度条，将读取的字节数据放置在arg1中，在Handler的handleMessage方法中设置进度值，同时刷新TextView显示的内容，这里难就难在如何获取每次读取的字节数，然后刷新进度条，在字节流的学习中，我们可以自定义每次读取字节大小，File类中可以获取到文件的总大小，最终我们得到上面图片中的效果。在这个例子里面，我们可以将读取手机卡的文件，换成下载文件，传输文件同样适应。