前言

为了防止遗忘这些知识点，写一篇博客加深自己的理解，方便忘记后再重新学习。

概述

AIDL是一个缩写，全称是Android Interface Definition Language，也就是Android接口定义语言。
AIDL是用于让某个Service与多个应用程序组件之间进行跨进程通信，从而可以实现多个应用程序共享同一个Service的功能。线程间通讯有多种方式，下面简单介绍下不同之间区别。

多种线程间通讯方式的不同：详情参考此博客

• Bundle:四大组件间的进程间通信方式，简单易用，但传输的数据类型受限。
• 文件共享： 不适合高并发场景，并且无法做到进程间的及时通信。
• Messenger: 数据通过Message传输，只能传输Bundle支持的类型
• ContentProvider：android 系统提供的。简单易用。但使用受限，只能根据特定规则访问数据。
• AIDL:功能强大，支持实时通信，但使用稍微复杂。
• Socket：网络数据交换的常用方式。不推荐使用。

关于AIDL语法

aidl的语法基本和java一样，仅有几点不同之处：

• 文件类型：AIDL文件的后缀是 .aidl，而不是 .java。
• 数据类型：AIDL默认支持一些数据类型，在使用这些数据类型的时候是不需要导包的，但是除了这些类型之外的数据类型，在使用之前必须导包，就算目标文件与当前正在编写的 .aidl 文件在同一个包下。（列：编写了两个文件，一个叫做 person.java ，另一个叫做PersonManager.aidl，它们都在 com.mumu.aidl包下 ，在 .aidl 文件里使用person对象我们就必须在 .aidl 文件里面写上 import com.mumu.aidl.person; ）
• 默认支持的数据类型包括：
  
  • Java中的八种基本数据类型，包括 byte，short，int，long，float，double，boolean，char。(实测short不支持)
  • String 类型。
  • CharSequence类型。
  • List类型：List中的所有元素必须是AIDL支持的类型之一，或者是一个其他AIDL生成的接口，或者是定义的parcelable。
  • Map类型：Map中的所有元素必须是AIDL支持的类型之一，或者是一个其他AIDL生成的接口，或者是定义的parcelable。
  • parcelable序列化的数据类型：parcelable所有元素必须是AIDL支持的类型之一，或者是一个其他AIDL生成的接口；
• 定向tag：AIDL中的定向 tag 表示了在跨进程通信中数据的流向，其中 in 表示数据只能由客户端流向服务端， out 表示数据只能由服务端流向客户端，而 inout 则表示数据可在服务端与客户端之间双向流通。Java 中的基本类型和 String ，CharSequence 的定向 tag 默认且只能是 in 。注意，不要全都用 inout ，工程大了系统的开销就会大很多，排列整理参数的开销很大。详细Tag使用方式参考此博客

dome实例（使用的studio工具）

简单实现基本数据类型（如图一个远程相加运算）

服务端

• 创建一个新的项目作为服务端
  
  1. 创建服务器端的aidl包
     
  2. 创建的aidl包下aidl文件
  3. 实现aidl文件接口

package ready.mumu.service;

interface MyAidl {
     int addnum(int num1 , int num2);
}

• 在java包下创建一个service并实现aidl接口

public class Myservice extends Service {

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return iBinder;
    }

    private final MyAidl.Stub iBinder  = new MyAidl.Stub(){

        @Override
        public int addnum(int num1, int num2) throws RemoteException {
            Log.v("MUMU","收到输入的远程请求，收到的值是num1:"+num1+"  num2:"+num2);
            return num1 + num2;
        }
}

• 注册表注册service

<service android:name=".Myservice" android:process=":remote">
            <intent-filter>
                <action android:name="ready.mumu.service.MyAidl"/>
            </intent-filter>
        </service>

这里说一下Android声明文件中的android:process属性可以为任意组件包括应用指定进程，如果我们需要让一个服务在一个远端进程中运行（而不是标准的它所在的apk的进程中运行），我们可以在声明文件中这个服务的标签中通过android:process属性为其指定一个进程。
“:remote”又是什么意思呢？“remote”不是关键，这个完全可以自己随意取名字，“:”冒号才是关键。
进程名以“:”开头的进程属于当前应用的私有进程，其他应用的组件不可以和它跑在同一个进程中。而进程名不以“:”开头的进程属于全局进程，其他应用可以通过某些方式和它跑在同一个进程中。

客户端

• 将服务端对应的aidl拷贝到客户端，要求aidl完全一致，所在的包名也完全一致
• 创建客户端的activity运行界面，并实现按钮点击事件（xml布局文件就不写了，简单的三个输入框一个按钮）

 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        initUI();

        //软件启动就绑定服务
        bindService();
    }

    private void initUI() {
        et_num1 = (EditText) findViewById(R.id.et_num1);
        et_num2 = (EditText) findViewById(R.id.et_num2);
        et_res = (EditText) findViewById(R.id.et_res);
        bt_add = (Button) findViewById(R.id.bt_add);

        bt_add.setOnClickListener(this);
    }

• 实现绑定服务方法

private void bindService() {
        //获取到服务端
        Intent intent = new Intent();
        //5.0之后必须显示intent启动 绑定服务 ， ComponentName两个参数对应是服务包名和服务文件名（文件名必须是包名+文件名）
        intent.setComponent(new ComponentName("ready.mumu.service","ready.mumu.service.Myservice"));
        bindService(intent,conn, Context.BIND_AUTO_CREATE);
    }

• 实现ServiceConnection（conn）绑定回调

MyAidl myaidl;

private ServiceConnection conn = new ServiceConnection() {

        //绑定上服务的时候执行
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            //拿到远程的服务
            myaidl = MyAidl.Stub.asInterface(iBinder);
        }

        //当服务断开的时候执行
        @Override
        public void onServiceDisconnected(ComponentName componentName) {

            //回收资源
            myaidl = null;
        }
    };

• 实现“远程计算”按钮onclick方法

@Override
    public void onClick(View view) {

        if(view == bt_add){
            int num1 = Integer.parseInt(et_num1.getText().toString());
            int num2 = Integer.parseInt(et_num2.getText().toString());

            try {
                //调用远程服务
                int res = myaidl.addnum(num1 , num2);
                et_res.setText(res+"");
            } catch (RemoteException e) {
                e.printStackTrace();
                et_res.setText("报错了");
            }
        }

• 在activity销毁的onDestroy方法中解绑服务

@Override
    protected void onDestroy() {
        super.onDestroy();
        unbindService(conn);
    }

如此简单的小dome就完成了。

相对复杂的序列化实现dome（如图）

这里在上边dome的基础上又添加了一个“序列化调用”按钮，点击之后输入传入的自定义的序列化数据，下面的步骤是在上个dome基础之上添加的。

服务端

方便看结构，先来一张服务端的代码结构图

• 创建一个java类myParcelable，定义数据类型、构造方法、get/set方法，实现Parcelable序列化（这个类的包名和aidl的包名要一致）

public class myParcelable implements Parcelable{

    String name;
    int age;
    String sex;


    //参数是一个Parcel,用它来存储与传输数据
    protected myParcelable(Parcel in) {
        //注意，此处的读值顺序应当是和writeToParcel()方法中一致的
        name = in.readString();
        age = in.readInt();
        sex = in.readString();
    }

    public static final Creator<myParcelable> CREATOR = new Creator<myParcelable>() {
        @Override
        public myParcelable createFromParcel(Parcel in) {
            return new myParcelable(in);
        }

        @Override
        public myParcelable[] newArray(int size) {
            return new myParcelable[size];
        }
    };

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        //数据存储至Parcel
        dest.writeString(name);
        dest.writeInt(age);
        dest.writeString(sex);
    }

    //方便数据清晰
    @Override
    public String toString() {
        return "myParcelable{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}

• 在aidl包下创建一个aidl文件（myParcelable.aidl）用于定义parcelable对象（非默认支持数据类型必须通过AIDL文件定义才能被使用）。这个myParcelable.aidl和myParcelable.java的包名要一致，所以上个类创建时才说要与aidl包名一致。

// myParcelable.aidl
package ready.mumu.service;

    parcelable myParcelable;

• 在原来的MyAidl.aidl中添加一个readText方法

// MyAidl.aidl
package ready.mumu.service;

//注意需要导入包
import  ready.mumu.service.myParcelable;

interface MyAidl {

     int addnum(int num1 , int num2);

     //传参时除了Java基本类型以及String，CharSequence之外的类型
    //都需要在前面加上定向tag，具体加什么量需而定
     String readText(in myParcelable par);
}

客户端

结构附图

• 将服务端的myParcelable.java和myParcelable.aidl拷贝过来，注意包名一致
• 将服务端的MyAidl.ail复制到客户端，此文件要保持客户端和服务端一致。
• 实现activity中“序列化调用”按钮onclick方法

if(view == bt_par){

            try {
                String msg = myaidl.readText(new myParcelable("张三",18,"男"));
                et_res.setText(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
                et_res.setText("序列化出错了");
            }

        }

如此，序列化数据的远程调用也就结束了。

结语

可能看起来会稍微混乱一点，实现一下就会发现其实aidl使用还是很简单的，最后留下dome地址，看dome可能会相对更容易理解一些。dome下载地址

手机安全卫士

1  初始化界面的搭建

1.1  界面UI

界面的ui主要完成的是背景图片的显示，以及版本号的显示，其中版本号是需要动态获取显示的。

主要实现：由于布局的特点选择相对布局，在RelativeLayout中设置背景图片，用一个textview显示版本信息。

1.2  界面activity需要重写的方法

界面需要完成的功能是在初始化页面的同时完成与服务器上的版本比对，看是否有新的版本，如果存在应该提醒用户是否进行更新。在完成相应的逻辑后进入到程序的主界面。

根据这些功能，可以知道页面只需要重写oncreate()方法。

1.3  activity里重写的相应的方法

onCreate()方法：

需要完成于服务器上的版本比对，也就是需要获取服务器上的相关数据，由于Android不能在主线程里进行耗时的操作，所以开启子线程完成网络的请求。

第一步：在activity里定义一个CheckVersionTask实现runnable接口重写里面的run()方法来实现子线程的开启。

第二步：在oncreate()方法中new Thread(new CheckVersionTask()).start();开启子线程完成访问服务器更新版本的操作。

1.4  CheckVersionTask()方法的实现

在方法中访问服务器，比较是否有新的版本，如果有新的版本就使用handle机制给主线程发送消息让主线程完成更新ui提示用户更新，如果没有新的版本则让主线程完成跳转到下一界面的操作。

第一步：访问服务器

在res资源文件夹下的values子文件夹下创建一个string.xml文件来保存访问的服务器的路径，这样做的好处是当服务器的地址发生变化时我们不需要在复杂的代码中去修改路径，只需要在这个配置文件里修改即可。

通过getResources().getString(R.string.resource);方法得到配置的路径，通过URL统一资源定位器包装路径，使它成为一个对应相应服务器的一个连接的对象，然后使用openconnction方法建立连接通过强制类型装换为http协议的连接方式（openconection支持有很多的连接协议，通过类型装换使他对应http的连接），得到连接后设置连接的时长，设置连接的方式，

（这里使用get方法，关于post方式及两种方式的区别在后面进行补充），然后得到程序的响应码，进行判断是否与服务器连接成功，如果连接成功则得到服务器返回的流数据，如果失败则返回给用户一个对应的错误码（也是通过handle机制交给主线程在界面上显示）。

第二步：处理服务器返回的数据

在成功连接得到服务器返回的数据后（json数据），由于数据的类型需要先把流转换为一个字符串，通过自定义的工具类的StreamTools.readStream(is);方法完成流的转换，在得到字符串后，服务器返回的是一个json的数据，对其进行解析得到相应的数据。通过解析得到的服务器上的最新的版本信息与本地的版本进行比较，如果不一致提醒更新。

补充一：关于流的转换

这里使用内存流进行转换，相关代码如下：

public class StreamTools {

public static String readStream(InputStream is) throws IOException{

ByteArrayOutputStream bos=new ByteArrayOutputStream();

int len=-1;

byte[] buffer=new byte[1024];

if((len=is.read(buffer))!=-1){

bos.write(buffer, 0, len);

}

is.close();

return bos.toString();

}

}

这里选择使用内存流是操作最方便效率最好的一种方式，关于流的读取是边读边取，定义的字节数组是每次搬运时的容器，字节数组的大小决定了每次搬运的多少，为了使不至于占用过多的内存空间，每次搬运时都不会直接把整个文件搬运过去，所以在拷贝一个文件时特别是一个大的文件时，一般都是读一个字节数组容量过去然后取出来，并不会全部放在内存中，由于整个原因字节数组也不会定义的特别大（会消耗内存空间）,也就是说每次读都需要有一个容器去接收，容器可以是一个流对应的本地文件，也可以是一个stringbuffer或stringbuild甚至是一个集合（一般不会用，因为集合拼接的问题的存在）（这些容器是可以自动扩展的相应的区别与原理在后文进行具体分析）。关于优化的缓冲流具体的原理差不多，只是每次搬运的更多。

显然在这里转换的不会是一个大的文件，（请求的是一些版本的信息）而且最好是能一次性读取，所以这里不用前面说的方法读取（后面会介绍相应的各种流的读取），而是采用内存本身作为容器，先把流的数据通过字节数组一点点搬运到内存中，当搬运完时直接一次性取出（bos.tostring），这样效率会高很多，而且由于文件本身的大小不会占用过多的内存。

补充二：json的解析

这里得json数据是很简单的结构，只有一层的json对象，没有夹杂json数组，所以在解析时很简单清晰；

得到一个jsonobject对象绑定对应的要解析的字符串，然后通过getString(“key”)方法取得对应的信息。（关于json解析的详细不在这里说明）

解析的核心代码如下：

String result = StreamTools.readStream(is);

// 解析得到的json字符串

JSONObject json = new JSONObject(result);

String version = json.getString("version");

String description = json.getString("description");

downloadPath = json.getString("apkurl");

补充三：得到版本信息的方法

PackageInfo packageInfo = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);

String version=packageInfo.versionName;

return version;

通过包管理器（Google为我们包装的框架）在介绍Android的结构时介绍。

第三步：通过handle机制给主线程发消息

通过message封装消息，通过handle发送。

Message msg = Message.obtain();取得message对象，也可以通过new 来创建，不过这里推荐使用前面的方法

msg.what = SUCCESS_UPDATE;标志是什么消息，方便handle进行处理，后面的是自定义的常量

msg.obj = description;发送的内容，object类型，可以接受任何内容

handler.sendMessage(msg);发送给主线程的handle处理

1.5  handle处理

关于handle机制的详细原理不在这里进行介绍，只介绍本程序的相应实现。

版本一致不更新，返回的各种错误码的，只需要在界面给一个toast提醒然后进入主界面，版本不一致提醒更新则需要先弹出一个对话框提醒用户，然后根据不同的点击，设置不同的逻辑判断，执行不同的方法。

第一步：页面的跳转，跳转到menu页面

（关于页面的跳转方式：分为显示意图和隐式意图）

这里使用显示意图（一般调用系统的一些activity时使用隐式意图，如后面使用的自动安装更新）

由于在很多地方都需要使用到这个页面的跳转，所以抽取成一个方法。创建意图，设置跳转的页面，开启意图的跳转，结束页面。

具体代码如下：

private void loadMainUi() {

Intent intent = new Intent(Activity_splash.this, Activity_menu.class);

startActivity(intent);

finish(); }

第二步：创建一个对话框提醒用户是否更新

通过AlertDialog.Builder builder = new Builder(context);方法来创建一个对话框，通过setXXX方法设置对话框的显示的信息。完成信息设置后设置对话框的两个点击事件：builder.setNegativeButton，builder.setPositiveButton。

这两个方法里有2个参数，

Parameters:

text The text to display in the negative button

listener The DialogInterface.OnClickListener to use.

第一个参数text代表对话框点击按钮的名称，第二个参数是一个点击事件的监听器，注意是Dialoginterface包下的，最好加上包名。

第三步：两个点击事件的处理

在builder.setNegativeButton（取消更新）中只需要调用方法进入menu界面即可，重点在builder.setPositiveButton（更新）的处理。

在确定更新时，需要完成两步，第一是用多线程断点下载下载服务器返回的指定路径里的apk安装包（在下载完成后完成自动更新），第二步，在界面上创建一个下载的进度条显示下载的状态。

1.6  多线程断点下载

本程序使用的是xutils开源框架完成多线程断点下载，关于多线程断点下载的源码实现与开源框架的包装设计的原理WHHHH

在使用开源框架前把相应的jar包导入到项目中，在使用时只需要创建对象，开启下载两步即可。

第一步：创建对象

HttpUtils httpUtils = new HttpUtils();

创建httpUtils对象，拿到这个对象去开启下载，在开启下载中有下载中，下载成功，下载完成三个回调事件，分别在3个事件里做对应的逻辑处理即可完成想要的交互与效果。

第二步：开启下载

在开启下载前（这里是用sd卡存储）先判断sd卡是否可用。

httpUtils.download(downloadPath,file.getAbsolutePath(),new RequestCallBack<File>() {});

3个参数分别是，下载的路径，下载完成后文件存放的路径，请求下载响应的事件，里面需要重写3个方法，分别是下载中，下载失败，下载完成；

在下载中显示下载的进度，在下载成功后通过隐式意图开启系统的自动更换apk的页面完成apk的替换。

1.7  apk的替换

Apk的替换实在多线程断点下载的onsuceess回调方法里完成的，方法的代码：

public void onSuccess(ResponseInfo<File> fileinfo) {

// 下载成功回调的方法

// 下载成功应该替换掉apk，这里使用的是隐式意图的方法来替换

pd.dismiss();//关闭下载进度条对话框

Intent intent = new Intent();

intent.setAction("android.intent.action.VIEW");

intent.addCategory("android.intent.category.DEFAULT");

intent.setDataAndType(Uri.fromFile(fileinfo.result),"application/vnd.android.package-archive");

// 如果activity已经运行到了task，再次跳转不会再运行这个activity

intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

startActivity(intent);}

上面的代码中有两点特殊的地方，第一点是setdataandtype方法里的data信息是由下载成功返回的responseinfo信息里提供的，第二点是设置了不同的activity在task栈里运行模式（和activity里4种开启模式有所不同，WHHHH）。

1.8  页面细节的处理

第一：初始化页面的显示时间（无论网络请求的快慢，都使页面显示一个固定的时长）

第二：无论网络连接是否成功以及下载的操作是否成功都应该在提示信息后进入主界面

2.  主页面menu页面的搭建

在完成初始化界面后，程序进入主界面菜单，在menu界面里显示各个功能模块的入口，显示一个比较好看绚丽的页面动画效果。

2.1  界面UI

界面的ui主要实现里标题框的布局以及各个模块入口的布局。其中标题框里面有一个旋转的图片做成动画效果，有一个标签可以在其中动态的显示文字，功能模块的入口布局使用网格布局，gridview。界面的ui主要是这3个部分完成。

2.2  图片旋转动画的实现（属性动画）

使用ObjectAnimator类完成。分为3步：创建实例，设置动画的显示信息，开启动画。

第一步：创建动画对象实例

ObjectAnimator oa = ObjectAnimator.ofFloat(iv_menu_heima, "rotationY",

45, 90, 135, 180, 225, 270, 315);

3个参数分别为，关联的控件（也就是操作的控件），旋转的中心轴，后面一串为一个可变参数的数组参数，记录的是每次旋转的角度。

第二步：设置动画的信息

主要是：设置动画执行一次的时长：oa.setDuration(3000);

动画重复的次数：oa.setRepeatCount(ObjectAnimator.INFINITE);

动画旋转的模式：oa.setRepeatMode(ObjectAnimator.RESTART);

第三步：开启动画

使用start方法开启。

2.3  动态文本的显示

动态文本的实现使用的是自定义的textview，它继承textview重写了里面的相应的一些方法，以欺骗Android系统的一些处理，从而达到想要的动态效果

第一步：页面的参数

除了宽高距离颜色这些普遍的信息以外，主要在页面中设置了两个特殊的属性，一个是focusableInTouchMode，设置这个属性为true，意思是页面获取焦点的事件是开启的，当页面获得焦点后就可以动态显示文本，然后除了设置文本一行显示以外，还要设置ellipsize属性，这样多余的文字不会以省略号的形式显示。

然而即使设置了这些属性还是不能动态显示，因为textview不像button那样通过点击事件可以获取焦点（当然这里可以设置属性使它是可以点击的），显然根据需求，是一直的动态显示，也就是textview是一直获取焦点的，所以需要重写方法欺骗系统这个textview是一直获取焦点的。

第二步：重写方法，欺骗系统页面一直在获取焦点的状态。

这个通过自定义的textview继承textview重写里面的isfocused方法实现。把该方法的返回值始终返回true，注意在重写时重写父类的所有构造方法.

2.4  gridview的布局

Gridview与listview类似，不同的地方是可以通过设置显示每行显示的模块数量，（通过numcolumns设置列的信息）通过适配器和inflator打气筒完成布局的显示。

第一步：适配器的设置

通过设置适配器显示每个条目，定义一个自己的适配器继承baseAdapter实现里面的4个方法，这里我们需要关注的是其中的两个方法：getview，getcount。

Getcount方法是返回页面总共需要显示的条目，一般与数组集合一起使用。

Getview方法返回每次打气好的view视图，返回视图，补充：无论是当重新new一个adapter适配器还是通过调用notifyDataSetChanged();方法刷新视图，都是重新执行一次getview方法，不同的是通过notifyDataSetChanged();方法刷新记录了上一次视图显示的信息，这样可以记录到用户正在操作的数据的位置。

对于类似的这些布局都是采用了使用适配器然后定义布局文件然后打气的一类操作，不同的是界面的布局不同，大气文件里的处理的逻辑不同。

3.  设置界面setting页面的搭建

在主界面中除了各功能模块的入口还有设置页面的实现，主要设置完成软件是否在启动时自动检测更新等功能，为方便起见应用程序都采用sharedperfrence来存储数据，关于Android中的几种存储操作在后面总结归纳（文件存储，首选项，sqilte数据库，内容提供者，sd卡存储等方式）

在页面布局中为了使界面交互性更好代码复用性更优使用了自定义的imageview以及状态选择器selector。

3.1  自定义的imageview

实现点击切换图片的功能，继承imageview在里面增加改变图片的方法，当每次点击事件发生时调用该方法，通过该方法实现图片的切换。点击事件的触发在整个相对布局上完成，把布局设置为可点击的，然后通过设置状态选择器实现点击击中时整个布局背景颜色改变实现好的交互性。

3.2  状态选择器

新建一个drawable文件夹（名称不可变），在文件夹下新建相应的xml文件，在文件中配置相应的状态信息。

<?xml version="1.0" encoding="utf-8"?>

<selector xmlns:android="http://schemas.android.com/apk/res/android">

    <item

android:drawable="@drawable/last_pressed" android:state_pressed="true">

</item>

    <item android:drawable="@drawable/last_normal"></item>

</selector>

在布局文件的background属性里配置该文件就可以实现。

4.  第一个功能模块：安全模块

4.1  密码设置

密码设置分为两部分，第一部分是第一次点击时也就是用户没有设置过密码时，这种情况弹出第一个自定义的对话框去提醒用户设置密码，如果用户设置好了密码或设置过了密码（也就是密码有过保存数据）就进入验证密码的对话框去验证，验证通过分两种情况进入页面，如果用户是第一次登录设置密码则进入第一个页面开始设置，如果不是则直接进入后面的界面。

4.1.1  设置密码的自定义对话框

在用户点击进入第一个安全模块的时候触发，通过AlertDialog.Builder创建对话框，然后通过打气筒打好一个自定义的view（类似于适配器里的操作），然后通过setview方法设置对话框的显示为这个view的布局，实现布局里的两个控件的点击监听事件，就完成了对话框的基本逻辑，不过有一点要注意，完成的事件是自定义的事件，如何去实现对话框的关闭涉及到作用域的问题，因为关闭的操作在点击事件中完成，也就是在一个方法的内部类中，而对话框的开启则是在点击事件发生前就应该开启，且对话框对象的关联是通过开启事件的操作完成（当调用show方法的时候会返回一个dialog对象，通过返回的这个对象就得到定义的对话框的实例，这样才可以进行关闭操作）。这样需要定义一个变量使方法中的和方法的内部类中的都可以访问到，最好的方式是在外部类中定义一个成员变量，因为在方法中定义变量最好是在定义的时候就赋值（如果不赋值在内部类中使用则需要定义为final，而final的值是不可改变的，这样就是一个矛盾），显然不符合需求，在内部类中定义外部方法又访问不到，所以在这里使用外部类的成员变量的定义方式（不然会有bug）。

密码确认的自定义对话框逻辑类似。

4.1.2  自定义对话框的优化

4.2  第一个activity页面：stepFirst

主要完成显示一些信息主要是布局代码的完成，里面涉及到一个style的设置，可以去帮助优化布局，使代码复用性高，且维护性好，当有很多页面使用类似的布局设置时应该去提取一个style。

在res/values/styles.xml文件里去添加style节点抽取布局。具体实现代码:

<style name="text_title">

    <item name="android:layout_width">match_parent</item>

    <item name="android:layout_height">48dp</item>

    <item name="android:background">#99CCFF</item>

    <item name="android:gravity">center_vertical</item>

    <item name="android:textColor">#ffffff</item>

    <item name="android:textSize">18sp</item>

</style>

4.2  第二个activity页面：step02

页面主要完成绑定sim卡的逻辑，当用户点击了绑定sim卡时应该把sim的信息进行保存，这样当手机被盗换卡时能够比较出sim信息的不同然后通知用户。如果用户没有设置绑定则提醒用户必须绑定才能进入下一步。

为了使页面的交互性更好，使用了屏幕的事件处理，判断用户手指在屏幕上的操作，然后通过Android提供的GestureDetector方法去处理这些事件，在该方法中重写一些方法的逻辑就可以完成用户对应事件的捕获与处理。而且在activity的切换效果中使用了自定义的动画效果，使画面的切换更美观。

4.2.1  屏幕事件的处理

因为在多个activity中都需要这样的效果所以在代码重构时把这逻辑抽取到一个activity里面，这个activity继承了activity，增加了一些公有的逻辑和方法，如果页面需要使用这些效果直接继承这个抽取过得activity即可，这样的操作大大提高了页面的维护性以及代码的复用性。关于代码的重构不在这里进行介绍。

关于屏幕事件的处理，采用重写ontouchevevt方法去处理得到的屏幕事件由于并没有采用过ontouch的事件的监听，所以不会因为优先级的关系影响到该方法的执行，并不会被截断。Android提供了很方便的api去方便开发者处理屏幕的事件：GestureDetector。

在实例化该对象时需要创建一个监听器，在该内部类里对应多种类型的事件处理，根据需要重写onfling方法，在里面完成手指怎样滑动会执行什么操作。

对于页面的切换，使用了自定义的动画效果，由于作为公共的父类，在其中的方法中并不提供具体的方法实现体。所以只给出方法的规范，定义出相应的抽象的方法，由子类去重写实现。

4.2.2  自定义的界面切换动画的实现

关于切换的动作是由子类去实现的，在finish或startxxx方法后（也就是跳转代码完成后）写overridePendingTransition(R.anim.anim_stepin, R.anim.anim_stepout);方法去实现自定义动画的效果，方法中的两个参数分别代表前一个页面的退出效果和后一个页面的进入的动画的效果，（通过xml文件去定义这些动画效果，有一定的格式，必须放在anim文件夹下（自定义的文件夹，名称不能改变））；

<?xml version="1.0" encoding="utf-8"?>

<translate xmlns:android="http://schemas.android.com/apk/res/android"

    android:duration="300"

    android:fromXDelta="100%p"

    android:fromYDelta="0"

    android:toXDelta="0"

    android:toYDelta="0" >

</translate>

4.2.3  保存sim卡的信息

通过首选项保存sim卡的信息，当用户锁定sim卡时就保存该信息，通过的到系统的telephony service来得到teleponymanager，通过teleponymanager中的getsimserialnumber方法得到数据通过首选项保存。（下次开启重启是会比较sim信息看是否有换卡的操作，如果有就给安全号码发短信）

4.3  第三个activity页面：step03

第3个页面完成安全号码的存储，由于是安全操作的关键部分，如果用户没有填写内容则不能进入下一个页面，（这里只需做一个判断即可）。用还可以选择通讯录里的号码来作为安全号码。安全号码的保存也是通过首选项来保存。

4.3.1  得到开启的页面返回的数据

通过点击页面上的安全号码按钮可以进入到联系人页面，通过startActivityForResult方式开启意图，到达contactactivity的页面（该页面完成联系人信息的展示），在该页面完成选择后，通过重写onactivityresult方法可以得到开启的那个页面里的选择的信息的内容。

（通过意图intent，以及bundle在底层完成数据的封装和传输）。再将得到的信息显示在编辑框里即可。

4.3.2  contactactivity里对于联系人信息的显示

通过内容提供者来得到联系人数据库里的数据，（Android4大组件之一，如果需要访问不同应用程序间的数据需要用到）

两句关键的代码:

ContentResolver resolver = context.getContentResolver();

        // 查询raw_contact表

Uri uri = Uri.parse("content://com.android.contacts/raw_contacts");

第一句代码得到解析工具的对象，第二句得到需要解析的资源的信息。（也就是要去解析哪一个资源）

然后利用面向对象的思想就可以直接拿着这个工具去采取查询操作，在对数据库进行持查询等操作前，先要清楚操作的表的结构。

利用sqlite的工具打开导出的数据库中联系人表，分析其中的结构（分析过程在小结中提供）可以知道要完成联系人数据的读取涉及到多张表，先得到id信息在去另外的表中遍历查询。

拿到的信息存储在cursor游标中，对游标进行遍历读取，得到每一个id，查询每个id对应的信息（这些信息依然保存在一个cursor中），遍历第二层的cursor得到具体的信息保存在集合中，再将保存有信息的集合数据通过适配器显示在界面上（listview）。

通过listview的条目点击事件返回选择的数据，这样就拿到了用户点击选择的联系人的信息。

4.4  第四个activity页面：step04

主要是页面的布局和利用首选项对配置信息的存储，方法类似。

4.5  第五个activity页面：最后配置信息完全显示

显示首选项中保存的相关的配置信息，提供一个可以点击文本可以返回到第一个step01界面进行重新的信息配置。然后显示相应的指令信息，当手机被盗后，利用安全号码给对应号码发送指定的指令让手机完成指定的操作（后面介绍）。

4.6  如何完成对被盗手机的远程操作

可以发送指定的短信完成：播放音乐，通过短信返回手机所在位置，锁屏，远程清理数据。

实现的原理:通过检测sim卡改变的信息来完成是否换卡，如果sim有改变，则给安全号码发送一条手机可能被盗的短信，这样安全手机也就获得了换卡后的号码，由于android手机的换卡手机需要重新启动，利用广播，当重新开机后就完成sim卡的对比。

写一个broadcast，在清单文件里配置意图过滤器监听开启启动的动作，当监听到事件的发生时，执行onreceiver里的方法（完成sim的对比），如果不相符合，给安全号码发送短信。

关键代码：

获取sim信息的api：

TelephonyManager tm=getSystemService(TELEPHONY_SERVICE);

tm.getSimSerialNumber;

发送短信的api：

SmsManager.getDefault().sendTextMessage();

4.6.1  解析短信

安全号码接受到了短信也就得到了相应的号码，给手机回复相应的短信，通过解析判断短信的内容选择对应的逻辑执行。

写一个brodcast，在清单文件里配置意图过滤器，把该意图过滤器的优先级设置为最高，当有短信发进来时，先在onreceive里进行判断，如果是指定的特定短信或者是垃圾信息就进行拦截，不让用户收到。（短信是有序广播，先由优先级高的处理，处理完了再交给低优先级的）

Object[] objects = (Object[]) intent.getExtras().get("pdus");

SmsMessage message = SmsMessage.createFromPdu((byte[]) obj);

String body = message.getMessageBody();

4.6.2  播放音乐

在res/目录下新建一个raw文件夹，存放需要播放的音乐，利用mediaplayer的api播放音乐。

MediaPlayer player=MediaPlayer.create(context, R.raw.zjwz);

player.start();

4.6.3  返回手机的位置

由于中国所用坐标系是不正确的（火星坐标系，国家对坐标进行了加偏）,返回的坐标需要进行进一步的处理才能得到真实的坐标，先得到手机返回的坐标。

由于位置是变化着的，就需要得到能够更新的数据，所以通过服务在后台进行位置信息的获取，当用户的位置发生了较大移动时就返回新的位置信息。

当短信中解析到该指令信息时开启一个服务，通过服务监测位置信息的改变，在把得到的信息通过一定的方法转换为真实的位置坐标，把坐标点通过短信发送给真实的手机。

服务的写法：

先得到locationManager，通过个体systemservice(locationservice)得到。

关键的代码：

lm.requestLocationUpdates("gps", 0, 0, locationListener);

locationListener是一个接口，写一个实现类去实现这个接口里某实现的方法，这个类的作用是监听位置信息。

重写里面的onLocationChanged方法，当位置信息改变时，执行该方法里的逻辑，通过短信发送位置信息。（关于火星坐标的转换在小结里叙述）

4.6.4  清楚数据和锁屏

通过系统的服务去获得超级管理员的权限（获得后还需要用户在手机设置里去开启该权限）

DevicePolicyManager dpm= (DevicePolicyManager)context.getSystemService(Context.DEVICE_POLICY_SERVICE);

配置超级管理员信息，要写一个特定的广播，系统通过该广播判断该程序是否配置了超级管理员的权限已经有哪些操作的权限。也就是当你要执行上面的语句时，会有相应的广播响应，如果没有配置该广播则会出错。

该广播继承DeviceAdminReceiver,在清单文件里完成一系列的文件信息的配置。（固定的写法）

<receiver

            android:name="com.itheima.mobilesoft.receiver.MyAdmin"

            android:description="@string/sample_device_admin_description"

            android:label="@string/sample_device_admin"

            android:permission="android.permission.BIND_DEVICE_ADMIN" >

            <meta-data

                android:name="android.app.device_admin"

                android:resource="@xml/device_admin_sample" />

            <intent-filter>

                <action android:name="android.app.action.DEVICE_ADMIN_ENABLED" />

            </intent-filter>

</receiver>

<string name="sample_device_admin">黑马手机安全卫士</string>

<device-admin xmlns:android="http://schemas.android.com/apk/res/android">

  <uses-policies>

    <limit-password />      

    <watch-login />         

    <reset-password />      

    <force-lock />          

    <wipe-data />           

    <expire-password />     

    <encrypted-storage />

    <disable-camera />      

  </uses-policies>

</device-admin>

在执行超级管理权限的相应代码时，会解析这些xml文件，看该程序的超级管理权限拥有哪些，只能执行权限里又得方法。该api里有修改密码，清除数据，锁屏的方法。

到此为止第一个功能模块手机防盗的功能结构大致介绍完了，下面介绍第二个功能模块。

5.   第二个功能模块：骚扰拦截

 （由于时间关系，在后期慢慢补上完善）

DataBinding是谷歌推出的一个官方的数据绑定框架，所以我们有必要学下怎么使用它。如果你英文足够好就可以去官网看。
https://developer.android.com/topic/libraries/data-binding/index.html

准备工作：
在 该Moudle下的build.gradle ，添加 ：

dataBinding{
        enabled true
    }

然后 ，rebuild project下；

然后我们再创建一个简单的javabean，Student类：

/**
 * Created by Administrator on 2016/11/7.
 */

public class Student {
    private String name;
    private int age;


    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

修改 activity_mian.xml:

<?xml version="1.0" encoding="utf-8"?>
<layout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    >
  <data>
      <variable
          name="student"
          type="com.example.edu.databindingsimple.Student"/>
  </data>
<LinearLayout
    android:id="@+id/activity_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="com.example.edu.databindingsimple.MainActivity">

    <!--显示学生姓名的textview-->
    <TextView
        android:gravity="center_horizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@{student.name}" />

    <!--显示学生年龄的textview-->
    <TextView
        android:gravity="center_horizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@{student.age}" />
</LinearLayout>
</layout>

必须是< layout >这个为根节点，< data >节点里的name 属性的值可以任取，必须跟下面的你使用的相同。type是你的类型，一般就是你的类名。@{这里面就是你text的值了}，我的理解这就是数据绑定吧。不需要去java代码中去setText（）了

MainActivity代码：

import android.databinding.DataBindingUtil;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

import com.example.edu.databindingsimple.databinding.ActivityMainBinding;

public class MainActivity extends AppCompatActivity {
   private  ActivityMainBinding mainBinding;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mainBinding= DataBindingUtil. setContentView(this,R.layout.activity_main);//这样就绑定了
        Student student=new Student("我不是程序员",22);
       //  mainBinding.setStudent(student);//赋值
         mainBinding.setVariable(BR.student,student);//这两种方法都行
    }
}

接下来运行：

运行会报错，因为我们的年龄是int型的，而text属性接受的是string，所以要把main_activity那个改下；

  <!--显示学生年龄的textview-->
    <TextView
        android:gravity="center_horizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@{String.valueOf(student.age)}" />

接下来再运行下：

是不是很简单，代码也变少了很多，没有findViewById操作，没有setText操作。

我们也可以为我们的控件绑定事件，接下来就演示下：

修改后的activity_main

<?xml version="1.0" encoding="utf-8"?>
<layout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    >
  <data>
      <variable
          name="student"
          type="com.example.edu.databindingsimple.Student"/>
     <variable
         name="myclick"
         type="com.example.edu.databindingsimple.MainActivity"/>
  </data>
<LinearLayout
    android:id="@+id/activity_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="com.example.edu.databindingsimple.MainActivity">

    <!--显示学生姓名的textview-->
    <TextView
        android:onClick="@{myclick.myClick}"
        android:gravity="center_horizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@{student.name}" />

    <!--显示学生年龄的textview-->
    <TextView
        android:gravity="center_horizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@{String.valueOf(student.age)}" />
</LinearLayout>
</layout>

修改后的MainActivity：

import android.databinding.DataBindingUtil;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.TextView;
import android.widget.Toast;

import com.example.edu.databindingsimple.databinding.ActivityMainBinding;

public class MainActivity extends AppCompatActivity {
   private  ActivityMainBinding mainBinding;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mainBinding= DataBindingUtil. setContentView(this,R.layout.activity_main);//这样就绑定了
        Student student=new Student("我不是程序员",22);
        //mainBinding.setStudent(student);
        mainBinding.setVariable(BR.student,student);//这两种方法都行
        mainBinding.setMyclick(this);
    }
    //这个是绑定到第一个textview 控件中
    public void myClick(View view){
        Toast.makeText(this,((TextView)view).getText(),Toast.LENGTH_SHORT).show();
    }
}

运行结果：

接下来我们在写另外一种方式，也可以绑定方法，

修改后的activity_main

<?xml version="1.0" encoding="utf-8"?>
<layout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    >
  <data>
      <variable
          name="student"
          type="com.example.edu.databindingsimple.Student"/>
     <variable
         name="myclick"
         type="com.example.edu.databindingsimple.MainActivity"/>
  </data>
<LinearLayout
    android:id="@+id/activity_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="com.example.edu.databindingsimple.MainActivity">

    <!--显示学生姓名的textview-->
    <TextView
        android:onClick="@{myclick.myClick}"
        android:gravity="center_horizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@{student.name}" />

    <!--显示学生年龄的textview-->
    <TextView
        android:onClick="@{()->myclick.myClick(student)}"
        android:gravity="center_horizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@{String.valueOf(student.age)}" />
</LinearLayout>
</layout>

修改后的activity_main

import android.databinding.DataBindingUtil;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.TextView;
import android.widget.Toast;

import com.example.edu.databindingsimple.databinding.ActivityMainBinding;

public class MainActivity extends AppCompatActivity {
   private  ActivityMainBinding mainBinding;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mainBinding= DataBindingUtil. setContentView(this,R.layout.activity_main);//这样就绑定了
        Student student=new Student("我不是程序员",22);
        //mainBinding.setStudent(student);
        mainBinding.setVariable(BR.student,student);//这两种方法都行
        mainBinding.setMyclick(this);
    }
    //这个是绑定到第一个textview 控件中
    public void myClick(View view){
        Toast.makeText(this,((TextView)view).getText(),Toast.LENGTH_SHORT).show();
    }
    //这个是绑定到第二个textview 控件中
    public void myClick(Student student){
        Toast.makeText(this,"你好啊",Toast.LENGTH_SHORT).show();
    }

}

运行效果：

可以看到两种方式都行，效果都是差不多的。我估计应该可以绑定任何方法到控件中都行。大家可以试试，

修改后的activity_main

import android.databinding.DataBindingUtil;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.TextView;
import android.widget.Toast;

import com.example.edu.databindingsimple.databinding.ActivityMainBinding;

public class MainActivity extends AppCompatActivity {
   private  ActivityMainBinding mainBinding;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mainBinding= DataBindingUtil. setContentView(this,R.layout.activity_main);//这样就绑定了
        Student student=new Student("我不是程序员",22);
        //mainBinding.setStudent(student);
        mainBinding.setVariable(BR.student,student);//这两种方法都行
        mainBinding.setMyclick(this);
    }
    //这个是绑定到第一个textview 控件中
    public void myClick(View view){
        Toast.makeText(this,((TextView)view).getText(),Toast.LENGTH_SHORT).show();
    }
    //这个是绑定到第二个textview 控件中
    public void myClick(Student student){
        Toast.makeText(this,"你好啊",Toast.LENGTH_SHORT).show();
    }
    //这个是绑定到第三个textview 控件中
    public void myClick(){
        Toast.makeText(this,"HelloWorld",Toast.LENGTH_SHORT).show();
    }
}

修改后的activity_main

<?xml version="1.0" encoding="utf-8"?>
<layout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    >
  <data>
      <variable
          name="student"
          type="com.example.edu.databindingsimple.Student"/>
     <variable
         name="myclick"
         type="com.example.edu.databindingsimple.MainActivity"/>
  </data>
<LinearLayout
    android:id="@+id/activity_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="com.example.edu.databindingsimple.MainActivity">

    <!--显示学生姓名的textview-->
    <TextView
        android:onClick="@{myclick.myClick}"
        android:gravity="center_horizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@{student.name}" />

    <!--显示学生年龄的textview-->
    <TextView
        android:onClick="@{()->myclick.myClick(student)}"
        android:gravity="center_horizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@{String.valueOf(student.age)}" />

    <TextView
        android:onClick="@{()->myclick.myClick()}"
        android:gravity="center_horizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="@{String.valueOf(student.age)}" />
</LinearLayout>
</layout>

运行效果：

好了，最基础最基础的学完了，还有很多高级特性，高级特性我就不讲了，我讲的不是很清楚。高级部分我也只是会用部分而已，

写博客目的只是记录自己学习的过程

**我参照了NFC实战详解(赵波的一本书),没有NFC基本知识了解的推荐去看这本书的前3章,1-2小时就看完了**

**步骤1. 我定义了一个方法,进行了NFC是否开启的判断**

private void checkNFCFunction() {
    //  获取NFCAdapter(这个是全局的,参数是一个Context)
    mNfcAdapter = NfcAdapter.getDefaultAdapter(this);
    //  mNfcAdapter为Null表示机器没有NFC功能
    if (mNfcAdapter == null) {
        //  提示      (这里是自定义的Log日志类,没有定义过可以用Log.I进行替换或者直接吐司,我也会上传代码)
        DebugUtils.LogI("没有NFC功能", getClass());
    } else {
        //  表示NFC功能未打开,就要弹出Dialog提示用户打开了
        if (!mNfcAdapter.isEnabled()) {
            Dialog dialog = null;
            AlertDialog.Builder builder = new AlertDialog.Builder(this);
            builder.setTitle("警告!");
            builder.setMessage("NFC功能未开启,是否前往开启(不开启将无法继续)");
            builder.setPositiveButton("开启", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    dialog.dismiss();
                    //  ACTION_WIRELESS_SETTINGS(即跳入NFC功能开启界面)
                    Intent setnfc = new Intent(Settings.ACTION_WIRELESS_SETTINGS);
                    startActivity(setnfc);

                }
            }).setNegativeButton("不开启", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    dialog.dismiss();
                    finish();
                }
            });
            dialog = builder.create();
            dialog.setCancelable(false);
            dialog.setCanceledOnTouchOutside(false);
            setDialogWidth(dialog).show();
            return;
        //  NFC功能开启之后 判断NFC_Beam功能是否开启
        } else if (!mNfcAdapter.isNdefPushEnabled()) {
            Dialog dialog = null;
            AlertDialog.Builder builder = new AlertDialog.Builder(this);
            builder.setTitle("警告!");
            builder.setMessage("NFC_Beam功能未开启,是否前往开启(不开启将无法继续)");
            builder.setPositiveButton("开启", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    dialog.dismiss();
                    //  同理 ACTION_NFCSHARING_SETTINGS跳入NFC_Beam设置界面
                    Intent setnfc = new Intent(Settings.ACTION_NFCSHARING_SETTINGS);
                    startActivity(setnfc);

                }
            }).setNegativeButton("不开启", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    dialog.dismiss();
                    finish();
                }
            });
            dialog = builder.create();
            dialog.setCancelable(false);
            dialog.show();
            return;
        }
    }

}

注意: 在Activity被加载的时候 需要首先调用这个方法,就是说需要放在onCreate中,当然 在onStart之前就可以

步骤2. 创建信息并且发送,NFC消息需要通过NdefMessage来装(就类似四大组件之间的消息需要用Intent来装一样)需要用到NdefMessage类,Android自带的- -,还需要一个BobNdefMessage类,不自带,一百度一大把,我这里也上传- -在下面

mButton.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            //  步骤1 : 创建NDEF Msg (三个参数,源码在,请自查)
            NdefMessage message = BobNdefMessage.getNdefMsg_from_RTD_TEXT("我是要发送的消息", false, false);
            //  步骤2 : 发送信息
            mNfcAdapter.setNdefPushMessage(message, ActNfc2.this);
        }
    });

@Override
    protected void onNewIntent(Intent intent) {
        setIntent(intent);
    }

@Override
    	protected void onResume() {
    	    super.onResume();
    	    //   消息判别(判别是不是NDEF类型的消息)
    	    if (NfcAdapter.ACTION_NDEF_DISCOVERED.equals(getIntent().getAction())) {
    	        //  处理接受到的数据(同样定义了方法)
    	        resolveIntent(getIntent());
    	    }
    	}

private void resolveIntent(Intent intent) {
        String action = intent.getAction();
		//	程序的严谨性,再判断一遍
        if (NfcAdapter.ACTION_NDEF_DISCOVERED.equals(action)) {

            NdefMessage[] messages = null;
			//	通过EXTRA_NDEF_MESSAGES_Key就能得到NFC发过来的Message数组了  -_-  就是数据转移- -
            Parcelable[] rawMsgs = intent.getParcelableArrayExtra(NfcAdapter.EXTRA_NDEF_MESSAGES);
            if (rawMsgs != null) {
                messages = new NdefMessage[rawMsgs.length];
                for (int i = 0; i < rawMsgs.length; i++) {
                    messages[i] = (NdefMessage) rawMsgs[i];
                }
            } else {
                //  未知TagType
                byte[] empty = new byte[]{};
                NdefRecord record = new NdefRecord(NdefRecord.TNF_UNKNOWN, empty, empty, empty);
                NdefMessage msg = new NdefMessage(new NdefRecord[]{record});
                messages = new NdefMessage[]{msg};
            }
            //  从Message中取出Record(又定义了一个方法,)
            progressNDEFMsg(messages);
        } else if (NfcAdapter.ACTION_TECH_DISCOVERED.equals(action)) {
            DebugUtils.LogI(Tag_ASSIST + "ACTION_TECH_DISCOVERED", getClass());
        } else if (NfcAdapter.ACTION_TAG_DISCOVERED.equals(action)) {
            DebugUtils.LogI(Tag_ASSIST + "ACTION_TAG_DISCOVERED", getClass());
        } else {
            DebugUtils.LogI(Tag_ASSIST + "UnKnown TAG", getClass());
            finish();
            return;
        }

    }

private void progressNDEFMsg(NdefMessage[] messages) {
		//	非空
        if (messages == null || messages.length == 0) {
            return;
        }
        for (int i = 0; i < messages.length; i++) {
            int length = messages[i].getRecords().length;
            NdefRecord[] records = messages[i].getRecords();
            //  几个记录(书上这里有点问题,我改了改- -具体可以看书)
            for (NdefRecord record : records) {
				//	首先需要确定是文字
                if (isTextRecord(record)) {
					//	然后 取出最后的数据
                    parseRTD_TEXTRecord(record);
                }
            }
        }
    }

private void parseRTD_TEXTRecord(NdefRecord record) {
        //  记录格式验证
        Preconditions.checkArgument(record.getTnf() == NdefRecord.TNF_WELL_KNOWN);
        //  记录类型验证
        Preconditions.checkArgument(Arrays.equals(record.getType(), NdefRecord.RTD_TEXT));

        String payloadStr = "";
        byte[] payload = record.getPayload();
        Byte statusByte = record.getPayload()[0];
		//	这一块我就不懂了 start-----
        String textEncoding = ((statusByte & 0200) == 0) ? "UTF-8" : "UTF-16";
        //  0x80=0200 ,获取状态字节编码
        //  获取语言码长度
        int languageCodeLength = statusByte & 0077;//   & 0x3F=0077(bit 5 to 0)
		//	不懂 end -----
        String languageCode = new String(payload, 1, languageCodeLength, Charset.forName("UTF-8"));
        try {
            payloadStr = new String(payload, languageCodeLength + 1, payload.length - languageCodeLength - 1, textEncoding);
        } catch (UnsupportedEncodingException e) {
            DebugUtils.LogI("异常信息" + e.getMessage(), getClass());
        }
    }

private boolean isTextUri(NdefRecord record) {
        if (NdefRecord.TNF_WELL_KNOWN == record.getTnf()) {
            if (Arrays.equals(NdefRecord.RTD_TEXT, record.getType())) {
                return true;
            } else {
                return false;
            }
        } else {
            return false;
        }
    }

/**
    	* 提供打印日志的功能
    	*/
	public class DebugUtils {
	    private static boolean logIsOpen = true;     //  是否开启Log日志打印
	
    	public static void LogI(Object obj, Class clazz) {
    	    if (logIsOpen) {
    	        Log.i("RedWolf", "["+clazz.getSimpleName() + "]- " + obj);
    	    }
    	}
	}

public class BobNdefMessage {

    /**
     * @About:create a TNF_WELL_KNOW NDEF record as RTD_URI
     * @param uriFiledStr , The rest of the URI, or the entire URI (if
     *            identifier code is 0x00).
     * @param identifierCode = prefixes(URI identifier code), 0x01=http://www.
     *            ,0x02=https://www. , 0x03=http://
     * @param flagAddAAR, true means add AAR
     * @return NdefMessage
     * @Ref: NFCForum-TS-RTD_URI_1.0
     * @By SkySeraph-2013
     */
    public static NdefMessage getNdefMsg_from_RTD_URI(String uriFiledStr, byte identifierCode,
                                                      boolean flagAddAAR) {
        byte[] uriField = uriFiledStr.getBytes(Charset.forName("US-ASCII"));
        byte[] payLoad = new byte[uriField.length + 1]; // add 1 for the URI
        // Prefix
        payLoad[0] = identifierCode; // 0x01 = prefixes http://www. to the URI
        // appends URI to payload
        System.arraycopy(uriField, 0, payLoad, 1, uriField.length);

        // Method1:
        NdefRecord rtdUriRecord1 = new NdefRecord(NdefRecord.TNF_WELL_KNOWN, NdefRecord.RTD_URI,
                new byte[0], payLoad);

        // Method2:only in API 14
        String prefix = URI_PREFIX_MAP.get(identifierCode);
        NdefRecord rtdUriRecord2 = NdefRecord.createUri(prefix + uriFiledStr);

        // Method3:only in API 14
        NdefRecord rtdUriRecord3 = NdefRecord.createUri(Uri.parse(prefix + uriFiledStr));

        if (flagAddAAR) {
            // note: returns AAR for different app (nfcreadtag)
            return new NdefMessage(new NdefRecord[] {
                    rtdUriRecord1, NdefRecord.createApplicationRecord("skyseraph.nfc_demo")
            }); // packageName
        } else {
            return new NdefMessage(new NdefRecord[] {
                    rtdUriRecord1
            });
        }
    }

    /**
     * @About:create a TNF_WELL_KNOW NDEF record as RTD_TEXT
     * @param text , the really text data
     * @param encodeInUtf8 , false means TEXT encoded by UTF-8
     * @param flagAddAAR , true means add AAR
     * @return NdefMessage
     * @Ref: NFCForum-TS-RTD_Text_1.0
     * @By SkySeraph-2013
     */
    public static NdefMessage getNdefMsg_from_RTD_TEXT(String text, boolean encodeInUtf8,
                                                       boolean flagAddAAR) {

        Locale locale = new Locale("en", "US"); // a new Locale is created with
        // US English.
        byte[] langBytes = locale.getLanguage().getBytes(Charset.forName("US-ASCII"));
        // boolean encodeInUtf8 = false;
        Charset utfEncoding = encodeInUtf8 ? Charset.forName("UTF-8") : Charset.forName("UTF-16");
        int utfBit = encodeInUtf8 ? 0 : (1 << 7);
        char status = (char)(utfBit + langBytes.length);
        // String text = "This is an RTD_TEXT exp";
        byte[] textBytes = text.getBytes(utfEncoding);
        byte[] data = new byte[1 + langBytes.length + textBytes.length];
        data[0] = (byte)status;
        System.arraycopy(langBytes, 0, data, 1, langBytes.length);
        System.arraycopy(textBytes, 0, data, 1 + langBytes.length, textBytes.length);
        NdefRecord textRecord = new NdefRecord(NdefRecord.TNF_WELL_KNOWN, NdefRecord.RTD_TEXT,
                new byte[0], data);

        if (flagAddAAR) {
            // note: returns AAR for different app (nfcreadtag)
            return new NdefMessage(new NdefRecord[] {
                    textRecord, NdefRecord.createApplicationRecord("skyseraph.nfc_demo")
            });
        } else {
            return new NdefMessage(new NdefRecord[] {
                    textRecord
            });
        }
    }

    /**
     * @About: create a TNF_ABSOLUTE_URI NDEF record
     * @param absoluteUri ,the absolute Uri
     * @param flagAddAAR , true means add AAR
     * @return NdefMessage
     * @Note: TNF_ABSOLUTE_URI indicates the absolute form of a URI that follows
     *        the absolute-URI rule defined by RFC 3986
     * @Note: Recommend that you use the RTD_URI type instead of
     *        TNF_ABSOLUTE_URI, because it is more efficient
     * @By SkySeraph-2013
     */
    public static NdefMessage getNdefMsg_from_ABSOLUTE_URI(String absoluteUri, boolean flagAddAAR) {
        // String absoluteUri = "http://developer.android.com/index.html";
        byte[] absoluteUriBytes = absoluteUri.getBytes(Charset.forName("US-ASCII"));
        NdefRecord uriRecord = new NdefRecord(NdefRecord.TNF_ABSOLUTE_URI, new byte[0],
                new byte[0], absoluteUriBytes);
        if (flagAddAAR) {
            // note: returns AAR for different app (nfcreadtag)
            return new NdefMessage(new NdefRecord[] {
                    uriRecord, NdefRecord.createApplicationRecord("skyseraph.nfc_demo")
            });
        } else {
            return new NdefMessage(new NdefRecord[] {
                    uriRecord
            });
        }
    }

    /**
     * @About:create a TNF_MIME_MEDIA NDEF record
     * @param payLoad,the MIME data
     * @param mimeType,the MIME Type
     * @param flagAddAAR, true means add AAR
     * @return NdefMessage
     * @By SkySeraph-2013
     */
    @SuppressLint("NewApi")
    public static NdefMessage getNdefMsg_from_MIME_MEDIA(String payLoad, String mimeType,
                                                         boolean flagAddAAR) {
        byte[] payLoadBytes = payLoad.getBytes(Charset.forName("US-ASCII"));
        // String mimeType = "application/skyseraph.nfc_demo";

        // method1:Creating the NdefRecord manually
        NdefRecord mimeRecord1 = new NdefRecord(NdefRecord.TNF_MIME_MEDIA,
                mimeType.getBytes(Charset.forName("US-ASCII")), new byte[0], payLoadBytes);
        // the identfier of the record is given as 0, since it will be the first
        // record in the NdefMessage

        // method2:Using the createMime() method, in API-16
        NdefRecord mimeRecord2 = NdefRecord.createMime(mimeType, payLoadBytes);

        if (flagAddAAR) {
            // note: returns AAR for different app (nfcreadtag)
            return new NdefMessage(new NdefRecord[] {
                    mimeRecord1, NdefRecord.createApplicationRecord("skyseraph.nfc_demo")
            });
        } else {
            return new NdefMessage(new NdefRecord[] {
                    mimeRecord1
            });
        }
    }

    /**
     * @About:create a TNF_EXTERNAL_TYPE NDEF record
     * @param payLoad,the EXTERNAL data
     * @param flagAddAAR, true means add AAR
     * @return NdefMessage
     * @By SkySeraph-2013
     */
    @SuppressLint("NewApi")
    public static NdefMessage getNdefMsg_from_EXTERNAL_TYPE(String payLoad, boolean flagAddAAR) {
        byte[] payLoadBytes = payLoad.getBytes();
        String domain = "skyseraph.nfc_demo"; // usually your app's package name
        String type = "externalType";
        String externalType = domain + ":" + type;

        // method1:Creating the NdefRecord manually
        NdefRecord exteralRecord1 = new NdefRecord(NdefRecord.TNF_EXTERNAL_TYPE,
                externalType.getBytes(), new byte[0], payLoadBytes);

        // method2:Using the createExternal() method, in API-16
        NdefRecord exteralRecord2 = NdefRecord.createExternal(domain, type, payLoadBytes);

        if (flagAddAAR) {
            // note: returns AAR for different app (nfcreadtag)
            return new NdefMessage(new NdefRecord[] {
                    exteralRecord1, NdefRecord.createApplicationRecord("skyseraph.nfc_demo")
            });
        } else {
            return new NdefMessage(new NdefRecord[] {
                    exteralRecord1
            });
        }
    }

    /**
     * checkSystemVersion()
     */
    private boolean flagVersion = false;

    private void checkSystemVersion() {
        // TODO Auto-generated method stub
        // if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN)

        String systemModel;
        String releaseVersion;
        String sdkVersion;
        systemModel = android.os.Build.MODEL;
        sdkVersion = android.os.Build.VERSION.SDK;
        releaseVersion = android.os.Build.VERSION.RELEASE;
        if (Integer.parseInt(sdkVersion) > 15) {
            flagVersion = true;
        } else {
            flagVersion = false;
        }
    }

    /**
     * NFC Forum "URI Record Type Definition" This is a mapping of
     * "URI Identifier Codes" to URI string prefixes, per section 3.2.2 of the
     * NFC Forum URI Record Type Definition document.
     */
    private static final BiMap<Byte, String> URI_PREFIX_MAP = ImmutableBiMap
            .<Byte, String> builder().put((byte)0x00, "").put((byte)0x01, "http://www.")
            .put((byte)0x02, "https://www.").put((byte)0x03, "http://").put((byte)0x04, "https://")
            .put((byte)0x05, "tel:").put((byte)0x06, "mailto:")
            .put((byte)0x07, "ftp://anonymous:anonymous@").put((byte)0x08, "ftp://ftp.")
            .put((byte)0x09, "ftps://").put((byte)0x0A, "sftp://").put((byte)0x0B, "smb://")
            .put((byte)0x0C, "nfs://").put((byte)0x0D, "ftp://").put((byte)0x0E, "dav://")
            .put((byte)0x0F, "news:").put((byte)0x10, "telnet://").put((byte)0x11, "imap:")
            .put((byte)0x12, "rtsp://").put((byte)0x13, "urn:").put((byte)0x14, "pop:")
            .put((byte)0x15, "sip:").put((byte)0x16, "sips:").put((byte)0x17, "tftp:")
            .put((byte)0x18, "btspp://").put((byte)0x19, "btl2cap://").put((byte)0x1A, "btgoep://")
            .put((byte)0x1B, "tcpobex://").put((byte)0x1C, "irdaobex://")
            .put((byte)0x1D, "file://").put((byte)0x1E, "urn:epc:id:")
            .put((byte)0x1F, "urn:epc:tag:").put((byte)0x20, "urn:epc:pat:")
            .put((byte)0x21, "urn:epc:raw:").put((byte)0x22, "urn:epc:")
            .put((byte)0x23, "urn:nfc:").build();
	}

/**
 * 触屏发送订单信息
 */
//  NfcAdapter.CreateNdefMessageCallBack 接口 应该是在两个Nfc设备接触的时候 被调用的..
public class ActNfc3 extends BaseActivity implements BaseInterface, NfcAdapter.CreateNdefMessageCallback {
    //  NfcAdapter
    private NfcAdapter mNfcAdapter;
    //  EditText 发送
    private EditText etSend;
    //  TextView 接收
    private TextView tvReceive;

    private Context mContext;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.act_nfc3);
        mContext = this;
        checkNFCFunction();
        initViews();
        initDatas();
        initEvent();
    }

    @Override
    public void initViews() {
        etSend = (EditText) findViewById(R.id.et_send);
        tvReceive = (TextView) findViewById(R.id.tv_receive);
    }

    @Override
    public void initDatas() {
        mNfcAdapter.setNdefPushMessageCallback(this, this);
    }

    @Override
    public void initEvent() {

    }


    private void checkNFCFunction() {
        mNfcAdapter = NfcAdapter.getDefaultAdapter(this);
        //  机器不支持Nfc功能
        if (mNfcAdapter == null) {
            ToastUtils.showToastFroce(mContext, "抱歉,本机不支持NFC功能");
            return;
        } else {
            //  检查机器NFC是否开启
            if (!mNfcAdapter.isEnabled()) {
                //  机器Nfc未开启 提示用户开启 这里采用对话框的方式<PS:这个开启了  可以进行对NFC的信息读写>
                AlertDialog.Builder builder = new AlertDialog.Builder(mContext);
                builder.setTitle("警告").setMessage("本机NFC功能未开启,是否开启(不开启将无法继续)").setNegativeButton("开启", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        Intent setNfc = new Intent(Settings.ACTION_NFC_SETTINGS);
                        startActivity(setNfc);
                    }
                }).setPositiveButton("不开启", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        finish();
                    }
                }).setCancelable(false).create().show();
                return;
            } else {
                //  NFC 已开启  检查NFC_Beam是否开启  只有这个开启了  才能进行p2p的传输
                if (!mNfcAdapter.isNdefPushEnabled()) {
                    // NFC_Beam未开启  点击开启
                    new AlertDialog.Builder(mContext).setTitle("警告!").setMessage("NFC_Beam功能未开启,是否开启(不开启将无法继续)").setNegativeButton("开启", new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialog, int which) {
                            Intent setNfc = new Intent(Settings.ACTION_NFCSHARING_SETTINGS);
                            startActivity(setNfc);
                        }
                    }).setPositiveButton("不开启", new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialog, int which) {
                            finish();
                        }
                    }).setCancelable(false).create().show();
                    return;
                }
            }
        }
    }

    //  在Nfc设备相互接触的时候 调用这个方法  进行消息的发送
    @Override
    public NdefMessage createNdefMessage(NfcEvent event) {
        DebugUtils.LogI("createNdefMessage", getClass());
        //  1.创建NdefMessage
        NdefMessage message = BobNdefMessage.getNdefMsg_from_RTD_TEXT(etSend.getText().toString(), false, false);
        return message;
    }

    @Override
    protected void onNewIntent(Intent intent) {
        //  接收到消息的第一步
        setIntent(intent);
    }

    @Override
    protected void onResume() {
        super.onResume();
        //  需要从Intent中读出信息
        //  消息判别
        if (NfcAdapter.ACTION_NDEF_DISCOVERED.equals(getIntent().getAction())) {
            resolveIntent(getIntent());
        }
    }

    private void resolveIntent(Intent intent) {
        String action = intent.getAction();
        if (NfcAdapter.ACTION_NDEF_DISCOVERED.equals(action)) {
            NdefMessage[] messages = null;
            Parcelable[] rawMsg = intent.getParcelableArrayExtra(NfcAdapter.EXTRA_NDEF_MESSAGES);
            if (rawMsg != null) {
                messages = new NdefMessage[rawMsg.length];
                for (int i = 0; i < messages.length; i++) {
                    messages[i] = (NdefMessage) rawMsg[i];
                }
            } else {
                //  未知Action
                byte[] empty = new byte[]{};
                NdefRecord ndefRecord = new NdefRecord(NdefRecord.TNF_UNKNOWN, empty, empty, empty);
                NdefMessage ndefMessage = new NdefMessage(ndefRecord);
                messages = new NdefMessage[]{ndefMessage};
            }
            //  将Message中的Record解析出来
            progressNdefMessage(messages);
        } else if (NfcAdapter.ACTION_TAG_DISCOVERED.equals(action)) {

        } else if (NfcAdapter.ACTION_TECH_DISCOVERED.equals(action)) {

        } else {
            return;
        }
    }

    private void progressNdefMessage(NdefMessage[] messages) {
        if (messages == null || messages.length == 0) {
            DebugUtils.LogI("progressNdefMessage-message==null", getClass());
            return;
        }
        for (int i = 0; i < messages.length; i++) {
            NdefRecord records[] = messages[i].getRecords();
            for (NdefRecord record : records) {
                DebugUtils.LogI("progressNdefMessage - record", getClass());
                if (isTextUri(record)) {
                    parseTextUri(record);
                }
            }
        }
    }

    private void parseTextUri(NdefRecord record) {
        DebugUtils.LogI("isTextUri", getClass());
        //  记录格式验证
        Preconditions.checkArgument(record.getTnf() == NdefRecord.TNF_WELL_KNOWN);
        //  记录类型验证
        Preconditions.checkArgument(Arrays.equals(record.getType(), NdefRecord.RTD_TEXT));
        //  读出所有的PayLoad
        String payLoadStr = "";
        byte[] payloads = record.getPayload();
        byte statusByte = payloads[0];
        //  得到编码方式
        String textEncoding = ((statusByte & 0200) == 0) ? "UTF-8" : "UTF-16";
        //  获取语言码的长度
        int languageCodeLength = statusByte & 0077;
        String languageCode = new String(payloads, 1, languageCodeLength, Charset.forName("UTF-8"));
        //  payloadStr = new String(payload, languageCodeLength + 1, payload.length - languageCodeLength - 1, textEncoding);

        //  真正的解析??
        payLoadStr = new String(payloads, languageCodeLength + 1, payloads.length - languageCodeLength - 1, Charset.forName(textEncoding));
        //  解析完毕,加载
        tvReceive.setText("接收完毕!-->" + payLoadStr);
    }

    private boolean isTextUri(NdefRecord record) {
        if (NdefRecord.TNF_WELL_KNOWN == record.getTnf()) {
            if (Arrays.equals(NdefRecord.RTD_TEXT, record.getType())) {
                return true;
            } else {
                return false;
            }
        } else {
            return false;
        }
    }
	}

Android NFC开发实战详解 赵波

http://download.csdn.net/detail/redwolfchao/9663054

从本节开始，就正式进入移植过程，首先进行u-boot-spl.bin的移植。

一、因为第一步要移植u-boot-spl.bin，所以我们需要先在头文件里添加宏CONFIG_SPL

u-boot-2016.09$ vim include/configs/tq210.h 

#define CONFIG_SPL

二、时钟初始化
由上节分析，由于我们没有定义宏CONFIG_SKIP_LOWLEVEL_INIT，所以进入board/samsung/tq210/lowlevel_init.S进行硬件初始化。

首先添加S5PV210的时钟相关寄存器：

u-boot-2016.09$ vim arch/arm/mach-s5pv210/include/mach/clock.h

由于现在的操作只需要在 u-boot-spl.bin 中进行，因此这里使用 CONFIG_SPL_BUILD 宏来控制，当编译u-boot-spl.bin 才会将这些初始化代码编译进 u-boot-spl.bin，而编译 u-boot.bin 时就不会。修改lowlevel_init.S如下：

并在tq210.c中加入clock头文件并实现clock_init（这里也如lowlevel_init.S使用CONFIG_SPL_BUILD 来控制编译顺序）：

在clock_init的实现函数中，使用了struct s5pv210_clock const clock = (struct s5pv210_clock )samsung_get_base_clock()，其中samsung_get_base_clock，在arch/arm/mach-s5pv210/include/mach/cpu.h中实现：

将其修改为

三、DDR初始化

u-boot-2016.09$ vim board/samsung/tq210/lowlevel_init.S 

添加DMC信息，参考《嵌入式Linux学习笔记（基于s5pv210、tq210）》，这里就不详细贴出来了。

在tq210.c中添加dmc的头文件并实现ddr_init。

#include <asm/arch/dmc.h>

在arch/arm/mach-s5pv210/include/mach/cpu.h中添加宏

#define S5PV210_DMC0_BASE       0xF0000000
#define S5PV210_DMC1_BASE       0xF1400000   

SAMSUNG_BASE(dmc0, DMC0_BASE)
SAMSUNG_BASE(dmc1, DMC1_BASE)

S5PV210_DMC0_BASE与S5PV210_DMC1_BASE在第一节我们已经定义了，如果没有定义，这里自己定义

接着执行到_main函数,

由于u-boot-spl.bin文件比较小，使用SRAM提供栈内存就好，所以可以将栈指针屏蔽掉，修改为：
五、拷贝BL2到SDRAM
在tq210.c中实现拷贝函数，拷贝完成后，直接跳转到DDR的起始地址执行 BL2。

CONFIG_SYS_SDRAM_BASE 在 u-boot-2014.04/include/configs/smdkv210.h 中定义，我们将其修改为我们实际 DDR 的起始地址0x20000000，CopySDMMCtoMem实现从SD的34扇区复制BL2到到DDR的起始地址0x20000000。

注：
因为BL1最大只能到16K，而每个扇区的大小为512B，16K正好是32个扇区，所以为了安全起见，我们将BL2的起始扇区设置为34。这个值并不固定，只要比u-boot-spl.bin的大小大就可以了。

四、编译

u-boot-2016.09$ make tq210_defconfig
u-boot-2016.09$ make spl/u-boot-spl.bin

发现会出现No rule to make target ‘checkarmreloc’, needed by ‘all’，修改arch/arm/mach-s5pv210/Kconfig，添加SPL选项

修改configs/tq210_defconfig，添加CONFIG_SPL=y

再次编译，发现出现mkexynosspl：Command not find。分析scripts/Makefile.spl

如果定义了CONFIG_SUMSANG，就会添加目标(obj)/$(BOARD)-spl.bin，展开即为spl/tq210-spl.bin，这里需要一个添加头文件的工具。
我这里的工具是使用的国嵌的mkv210，将其复制到tool下，将名字改为mktq210spl，修改
scripts/Makefile.spl

再次编译，发现已经产生了我们需要的spl/tq210-spl.bin。

五、烧录与测试
单独的.bin文件启动看不到现象，这里我在board/samsung/tq210/lowlevel_init.S中添加了蜂鸣器鸣叫的片段。

    .globl lowlevel_init
lowlevel_init:
mov r9, lr

#ifdef CONFIG_SPL_BUILD 

    bl clock_init      /* 时钟初始化 */

    bl beep_asm_init    
    bl delay
    bl beep_asm_off

    bl ddr_init        /* DDR初始化 */

    bl uart_asm_init
#endif

mov pc, r9

/*
     * beep_asm_init: 初始化蜂鸣器，并让其发声 
     */
    beep_asm_init: 
        ldr r0, = 0xE02000A0
        ldr r1, = 0x00000010
        str r1, [r0]

        ldr r0, = 0xE02000A4
            ldr r1, = 0x2
        str r1, [r0]

        mov pc, lr

    /*
     * delay: 延时
     */   
    delay:
        mov r0, #0x2000000

    delay_loop:
        sub r0, r0, #1
        cmp r0, #0
        bne delay_loop

        mov pc, lr

    /*
     * beep_asm_off: 关闭蜂鸣器
     */
    beep_asm_off:
        ldr r0, = 0xE02000A4
        ldr r1, = 0x0
        str r1, [r0]

        mov pc, lr

为了偷懒，我直接使用了网上搜索的TQ210的裸机LED程序，编译得到led.bin。

烧录测试：
使用DD_for_win7.exe将tq210-spl.bin与led.bin分别烧入1和34扇区


然后将SD卡插入开发板，打开电源，发现蜂鸣器鸣叫一声，并且LED不停闪烁，表示我们tq210-spl.bin移植成功。

注：
DD_for_win7.exe有添加头字节选项，如果我们使用tq210-spl.bin就不需要选择这个选项，如果使用u-boot-spl.bin就必须将这个选项勾上。

一、UI显示
日常生活中，我们经常会看到应用中那些提示框，有在正中的，有在底部的，这篇文章我来学习一下这两类提示框UI，主要是dialog和popuwindow。
首先上图：
1、dialog

2、popuwindow

二、代码的编写（dialog）
dialog
1、首先我们来构思一下所要显示的样式，基本上是分三个部分，①标题②内容③取消确认键。这里我使用的是layout_weight，是为了控制显示比例，易于适配屏幕。

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">

        <TextView
            android:id="@+id/view_custom_alter_dialog_title"
            android:layout_width="match_parent"
            android:layout_height="0dp"
            android:layout_weight="1"
            android:gravity="center"
            android:text="@string/view_load_gif_dialog_title"
            android:textSize="@dimen/view_load_gif_title_text_size" />

        <TextView
            android:id="@+id/view_custom_alter_dialog_content"
            android:layout_width="match_parent"
            android:layout_height="0dp"
            android:text="@string/view_load_gif_dialog_message"
            android:layout_weight="2"
            android:gravity="center"
            android:layout_marginLeft="@dimen/view_load_gif_content_margin_left_right"
            android:layout_marginRight="@dimen/view_load_gif_content_margin_left_right"
            android:layout_marginBottom="@dimen/view_load_gif_content_margin_bottom"
            android:textSize="@dimen/view_load_gif_content_text_size"
            android:lineSpacingExtra="@dimen/view_load_gif_line_space_extra"
            />

        <View
            android:layout_width="match_parent"
            android:layout_height="1dp"
            android:background="@color/activity_main_bottom_controller_bg" />

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="0dp"
            android:layout_weight="1.5"
            android:orientation="horizontal">

            <TextView
                android:id="@+id/view_custom_alter_dialog_cancel"
                android:layout_width="0dp"
                android:layout_height="match_parent"
                android:layout_weight="1"
                android:gravity="center"
                android:textColor="@color/app_main_color"
                android:text="@string/view_random_code_dialog_cancel"
                android:textSize="@dimen/view_load_gif_cancel_sure_textsize" />

            <View
                android:layout_width="1dp"
                android:layout_height="match_parent"
                android:background="@color/activity_main_bottom_controller_bg" />

            <TextView
                android:id="@+id/view_custom_alter_dialog_sure"
                android:layout_width="0dp"
                android:layout_height="match_parent"
                android:layout_weight="1"
                android:gravity="center"
                android:textColor="@color/app_main_color"
                android:text="@string/view_random_code_dialog_sure"
                android:textSize="@dimen/view_load_gif_cancel_sure_textsize" />
        </LinearLayout>

    </LinearLayout>
</RelativeLayout>

2、这里我们就已经有一个基本的布局了，然后是自定义这个布局。创建一个类来继承Dialog，实现重写构造函数，然后绑定一些控件。
这里我使用的是按照获取到的手机的屏幕，来控制这个dialog的显示比例，这样可以适配的更加方便。

public class CustomAlertDialog extends Dialog {

    protected View mView;

    //ui
    protected TextView mTextTitle,mTextContent,mTextCancel,mTextSure;

    public CustomAlertDialog(Context context) {
        this(context,0);
    }

    public CustomAlertDialog(Context context, int themeResId) {
        super(context, themeResId);
        mView = LayoutInflater.from(context).inflate(R.layout.view_custom_alert_dialog,null);
        setContentView(mView);
        initView();
        //setting size
        Window dialogWindow = this.getWindow();
        WindowManager m = getWindow().getWindowManager();
        Display d = m.getDefaultDisplay(); // 获取屏幕宽、高用
        WindowManager.LayoutParams p = dialogWindow.getAttributes(); // 获取对话框当前的参数值
        //手机横竖屏时候
        if (context.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT){
            p.height = (int) (d.getHeight() * 0.25); // 高度设置为屏幕的
            p.width = (int) (d.getWidth() * 0.7); // 宽度设置为屏幕的
        }else if (context.getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE){
            p.height = (int) (d.getHeight() * 0.3); // 高度设置为屏幕的
            p.width = (int) (d.getWidth() * 0.4); // 宽度设置为屏幕的
        }
        dialogWindow.setAttributes(p);
    }

    private void initView() {
        try{
            mTextTitle = (TextView) mView.findViewById(R.id.view_custom_alter_dialog_title);
            mTextContent = (TextView) mView.findViewById(R.id.view_custom_alter_dialog_content);
            mTextCancel = (TextView) mView.findViewById(R.id.view_custom_alter_dialog_cancel);
            mTextSure = (TextView) mView.findViewById(R.id.view_custom_alter_dialog_sure);
        }catch(Exception _e){
            ExceptionHandler.onException(_e);
        }
    }


    public void setText(String _title,String _content,String _cancel,String _sure){
        try{
            if (null != _title)
                mTextTitle.setText(_title);
            if (null != _content)
                mTextContent.setText(_content);
            if (null != _cancel)
                mTextCancel.setText(_cancel);
            if (null != _sure)
                mTextSure.setText(_sure);
        }catch(Exception _e){
            ExceptionHandler.onException(_e);
        }
    }

    public void setLeftOnclick(View.OnClickListener _onclick){
        try{
            mTextCancel.setOnClickListener(_onclick);
        }catch(Exception _e){
            ExceptionHandler.onException(_e);
        }
    }

    public void setRightOnclick(View.OnClickListener _onclick){
        try{
            mTextSure.setOnClickListener(_onclick);
        }catch(Exception _e){
            ExceptionHandler.onException(_e);
        }
    }

}

3、然后在代码中使用这个控件，这里我们注意一下，还要传入hemeResId的值，因为如果不传入，效果就不会那么好。

public void reDownloadResourceDialog(){
        try{
            final CustomAlertDialog _customAlterDialog = new CustomAlertDialog(this,R.style.random_code_dialog);
            _customAlterDialog.show();
            _customAlterDialog.setLeftOnclick(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    _customAlterDialog.dismiss();
                }
            });
            _customAlterDialog.setRightOnclick(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    _customAlterDialog.dismiss();
                    ActivityActionList.this.reDownloadResources();
                }
            });
        }catch(Exception _e){
            ExceptionHandler.onException(_e);
        }
    }

4、使用themeResId的样式，styles.xml文件中

<!--view_random_dialog-->
    <style name="random_code_dialog" parent="@android:style/Theme.Dialog">
        <item name="android:background">@drawable/dialog_random_code_shape</item>
        <item name="android:windowIsFloating">true</item>
        <item name="android:windowIsTranslucent">false</item>
        <item name="android:windowNoTitle">true</item>
        <item name="android:windowContentOverlay">@null</item>
        <item name="android:windowBackground">@android:color/transparent</item>
    </style>
    <!--view_random_dialog end-->

外加background的样式，主要是周围显示的圆角，dialog_random_code_shape.xml文件

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android">

    <corners android:radius="10dp" />

    <solid android:color="@color/common_white" />
</shape>

这里dialog的自定义先告一段落。

三、代码的编写（popuwindow）
popuwindow
1、我们也还是先定义一个布局

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:orientation="vertical"
    android:padding="@dimen/activity_exercise_plan_xml_padding">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="@dimen/activity_exercise_plan_xml_height"
        android:orientation="vertical">

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="0dp"
            android:layout_weight="1"
            android:background="@drawable/plan_more_show_shape"
            android:orientation="vertical">

            <TextView
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:gravity="center"
                android:text="@string/activity_quit_plan_xml_show"
                android:textSize="@dimen/activity_exercise_plan_xml_show_sp" />

        </LinearLayout>

        <View
            android:layout_width="match_parent"
            android:layout_height="@dimen/activity_exercise_plan_xml_splitor"
            android:background="@color/activity_main_bottom_controller_bg" />

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="0dp"
            android:layout_weight="1.5"
            android:background="@drawable/plan_more_quit_shape"
            android:orientation="vertical">

            <TextView
                android:id="@+id/exercise_plan_more_quit"
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:gravity="center"
                android:text="@string/activity_quit_plan_xml_quit"
                android:textColor="@android:color/holo_red_light"
                android:textSize="@dimen/activity_exercise_plan_xml_text_sp" />

        </LinearLayout>

        <Space
            android:layout_width="match_parent"
            android:layout_height="@dimen/activity_exercise_plan_xml_space" />

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="0dp"
            android:layout_weight="1.5"
            android:background="@drawable/plan_more_cancel_shape"
            android:orientation="vertical">

            <TextView
                android:id="@+id/exercise_plan_more_cancel"
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:gravity="center"
                android:text="@string/activity_quit_plan_xml_cancel"
                android:textColor="@android:color/holo_blue_light"
                android:textSize="@dimen/activity_exercise_plan_xml_text_sp" />

        </LinearLayout>

    </LinearLayout>
</LinearLayout>

布局的样式：

2、有了布局的样式之后，就开始为布局添加绑定。
① mPopWindowMore.showAtLocation(_view, Gravity.BOTTOM, 0, 0);是设置此popuwindow要显示的位置，这里显示在底部
②setBackgroundAlpha()的方法来使得显示popuwindow的时候，会有变暗的效果，当popuwindow消失的时候，又会恢复。bgAlpha取值为0.0-1.0
③使用mPopWindowMore.setOnDismissListener(）来监听popuwindow的消失

public void showPopwindowQuitPlan(View _view) {
        View _viewPopwindow = null;
        TextView _quitTextView,_cancelTextView;
        try {
            _viewPopwindow = LayoutInflater.from(this).inflate(R.layout.view_exercise_plan_more,null);
            _quitTextView = (TextView) _viewPopwindow.findViewById(R.id.exercise_plan_more_quit);
            _cancelTextView = (TextView) _viewPopwindow.findViewById(R.id.exercise_plan_more_cancel);
            if (null != _viewPopwindow){
                mPopWindowMore = new PopupWindow(_viewPopwindow,
                        ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT, true);
                mPopWindowMore.setTouchable(true);
                mPopWindowMore.showAtLocation(_view, Gravity.BOTTOM, 0, 0);
                mPopWindowMore.setOnDismissListener(new PopupWindow.OnDismissListener() {
                    @Override
                    public void onDismiss() {
                        setBackgroundAlpha(1f);
                    }
                });
            }

            if (null != _quitTextView){
                _quitTextView.setOnClickListener(new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        //确认点击
                        }
                });
            }
            if (null != _cancelTextView){
                _cancelTextView.setOnClickListener(new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        //取消点击
                    }
                });
            }

        }catch (Exception _e){
            ExceptionHandler.onException(_e);
        }
    }

设置背景颜色的方法

public void setBackgroundAlpha(float bgAlpha) {
        WindowManager.LayoutParams lp = getWindow().getAttributes();
        lp.alpha = bgAlpha; //0.0-1.0
        getWindow().setAttributes(lp);
    }

第一步：爆结果照，让你有坚持下去的信心

二、NDK解释

（a）Project->Properties->Builders->New，新建一个FirstBuilder。 
（b）在弹出的【Choose configuration type】对话框，选择【Program】，点击【OK】： 
（c）在弹出的【Edit Configuration】对话框中，配置选项卡【Main】。 
在“Name“中输入新builders的名称（这个名字可以任意取）。

在“Location”中输入nkd-build.cmd的路径(这个是下载完ndkr10e后解压后的路径，这个建议放在根目录下面，路径不能有空格和中文)。根据各自的ndk路径设置，也可以点击“Browser File System…”来选取这个路径。 
在“Working Diretcoty”中输入TestNdk位置（也可以点击“Browse Workspace”来选取TestNdk目录）。如图1

第一个箭头是ndk目录下面的ndk-build.cmd

第二个箭头是选自己的项目

（d）继续在这个【Edit Configuration】对话框中，配置选项卡【Refresh】。如图2 
勾选“Refresh resources upon completion”， 
勾选“The entire workspace”， 
勾选“Recuresively include sub-folders”。

图2

（e）继续在【Edit Configuration】对话框中，配置选项卡【Build options】。 
勾选“After a “Clean””，(勾选这个操作后，如果你想编译ndk的时候，只需要clean一下项目 就开始交叉编译) 
勾选“During manual builds”， 
勾选“During auto builds”， 
勾选“Specify working set of relevant resources”。如图3

‘

图3

点击“Specify Resources…”勾选FirstJni工程，点击”finish“。 点击“OK“，完成配置。 如图4

编译环境以及成功搭建完

四、demo的简单实现

 1.在FirstJni工程中新建一个JniClient.java

package com.example.firstjni;

public class JniClient {
	    static public native String AddStr(String strA, String strB);
	    static public native int AddInt(int a, int b);
}

2.生成 .h 的c++头文件

(1)用cmd命令定位到JniClient.class 所在目录，输入“javac JniClient.java“后回车，生成JniClinet.class文件（如果是用的Eclipse建的工程，在TestNdk\bin\classes\com\ndk\test目录下就已经有JniClinet.class文件了）。com.example.firstjni

(2)将JniClinet.class拷贝到FirstJni\bin\classes\com\example\firstjni目录，将cmd命令定位到FirstJni\bin\classes目录，输入”javah com.example.firstjni.JniClient“后回车，在FirstJni\bin\classes目录下就生成了C++头文件com_example_firstjni_JniClient.h

图片讲解如下：

com_example_firstjni_JniClient.h的文件内容如下：

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class com_example_firstjni_JniClient */

#ifndef _Included_com_example_firstjni_JniClient
#define _Included_com_example_firstjni_JniClient
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     com_example_firstjni_JniClient
 * Method:    AddStr
 * Signature: (Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_example_firstjni_JniClient_AddStr
  (JNIEnv *, jclass, jstring, jstring);

/*
 * Class:     com_example_firstjni_JniClient
 * Method:    AddInt
 * Signature: (II)I
 */
JNIEXPORT jint JNICALL Java_com_example_firstjni_JniClient_AddInt
  (JNIEnv *, jclass, jint, jint);

#ifdef __cplusplus
}
#endif
#endif

3.在jni目录下新建一个Android.mk文件，其内容如下(关于mk文件需要注意,很重要,还有c和c++文件的mk文件还不一样，此处是调用c语言的mk文件，至于其他的怎么调用，这个自己去百度吧，在此就不多说了)

# Copyright (C) 2009 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE    := FirstJni
LOCAL_SRC_FILES := com_example_firstjni_JniClient.c

include $(BUILD_SHARED_LIBRARY)

4. 将刚刚手动生成的com_example_firstjni_JniClient.h拷贝到FirstJni工程的jni目录下，

然后新建一个com_example_firstjni_JniClient.c文件完成头文件中函数的实现，其内容如下（本来想写两个方法的，现在只讲解第一个方法，返回一个字符串“HelloWorld from JNI ”,另一个方法是一个a+b的运算，方法写到这里，感兴趣的可以自己去研究）：

com_example_firstjni_JniClient.c

#include "com_example_firstjni_JniClient.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#ifdef __cplusplus
extern "C"
{
#endif
/*
 * Class:     com_ndk_test_JniClient
 * Method:    AddStr
 * Signature: (Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_example_firstjni_JniClient_AddStr
  (JNIEnv *env, jclass arg, jstring instringA, jstring instringB)
{
    jstring str = (*env)->NewStringUTF(env, "I am chenyu, This is my first ubuntu jni!!!!");
    return str;
}

/*
* Class:     com_ndk_test_JniClient
* Method:    AddInt
* Signature: (II)I
*/
JNIEXPORT jint JNICALL Java_com_example_firstjni_JniClient_AddInt
  (JNIEnv *env, jclass arg, jint a, jint b)
{
    return a + b;
}

#ifdef __cplusplus
}
#endif

此刻,当编辑com_ndk_test_JniClient.c并保存后，project下的—clean  一下工程，然后再去ndk-build项目，就可以生存响应的so文件

5.在MainActivity.java中完成对JniClient.java中函数的调用(首先静态加载动态链接so库)：

package com.example.firstjni;

import android.support.v7.app.ActionBarActivity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.TextView;

public class MainActivity extends ActionBarActivity {

	 public String string1 = "I am chenyu ";
	 public String string2 = "this is my first ubuntu jni";
	 public int a = 3;
	 public int b = 5;
	 static {
		 System.loadLibrary("FirstJni");
	 }

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
        TextView  tv = new TextView(this);
        tv.setText(JniClient.AddStr(string1, string2)+"3 + 5 = " + JniClient.AddInt(a, b));
        setContentView(tv);
	}

	@Override
	public boolean onCreateOptionsMenu(Menu menu) {
		// Inflate the menu; this adds items to the action bar if it is present.
		getMenuInflater().inflate(R.menu.main, menu);
		return true;
	}

	@Override
	public boolean onOptionsItemSelected(MenuItem item) {
		// Handle action bar item clicks here. The action bar will
		// automatically handle clicks on the Home/Up button, so long
		// as you specify a parent activity in AndroidManifest.xml.
		int id = item.getItemId();
		if (id == R.id.action_settings) {
			return true;
		}
		return super.onOptionsItemSelected(item);
	}
}

6.运行FirstJni工程,就出现了上面的爆图。

五、demo已经上传，需要的猛搓下面的地址

ubuntu上面使用jni例子  http://download.csdn.net/detail/u011068702/9675559   

从2016年7月份开始，坚持写ReactNative系列博客，记录工作中遇到的点滴。

今天把博客汇如下：

1. 《React-Native系列》1、初探React-Native
   
2. 《React-Native系列》2、RN与native交互与数据传递
   
3. 《React-Native系列》3、RN与native交互之Callback、Promise
   
4. 《React-Native系列》4、表单界面代码编写
   
5. 《React-Native系列》5、RN实现弹出选择界面与动画效果
   
6. 《React-Native系列》6、Navigator语法介绍及经典应用
   
7. 《React-Native系列》7、bundle文件的加载和维护
   
8. 《React-Native系列》8、RN如何打离线包
   
9. 《React-Native系列》9、 Networking之fetch
   
10. 《React-Native系列》10、 RN组件之Text和TextInput以及注意要点
    
11. 《React-Native系列》11、 图解RN布局之FlexBox，三分钟上手写RN界面
    
12. 《React-Native系列》12、 API模块之PixelRatio和Dimensions
    
13. 《React-Native系列》13、 组件封装之Dialog（iOS和Android通用）
    
14. 《React-Native系列》14、 RN学习之NodeJS
    
15. 《React-Native系列》15、 RN之可触摸组件
    
16. 《React-Native系列》16、 RN组件之ListView
    
17. 《React-Native系列》17、 RN中this所引起的undefined is not an object错误
    
18. 《React-Native系列》18、 RN之定时器Timer
    
19. 《React-Native系列》19、 ListView组件之上拉刷新（iOS和Android通用）
    
20. 《React-Native系列》20、 RN数据流之Flux概览
    
21. 《React-Native系列》21、 解决RN在Android下不支持gif问题
    
22. 《React-Native系列》22、 Flux框架Demo详解
    
23. 《React-Native系列》23、 js实现下拉刷新效果（Android和iOS通用）
    
24. 《React-Native系列》24、 结合Demo学习Redux框架
    
25. 《React-Native系列》25、 详解Redux的connect方法
    
26. 《React-Native系列》26、 ReactNative实现图片上传功能
    
27. 《React-Native系列》27、 Redux的异步数据流
    
28. 《React-Native系列》28、 RN之AsyncStorage
    
29. 《React-Native系列》29、 RN组件之WebView
    
30. 《React-Native系列》30、 RN组件间通信
    
31. 《React-Native系列》31、 Fetch发送POST请求的坑与解决方案
    
32. 《React-Native系列》32、 基于Fetch封装HTTPUtil工具类
    
33. 《React-Native系列》33、 键盘遮挡问题处理
    
34. 《React-Native系列》34、 ReactNative的那些坑
    
35. 《React-Native系列》35、 RN在Android下支持gif的另一种方案
    
36. 《React-Native系列》36、 ReactNative地图组件
    
37. 《React-Native系列》37、 ReactNative百度地图开源组件使用
    
38. 《React-Native系列》38、 ReactNative混合组件封装
    
39. 《React-Native系列》39、 ReactNative之键盘Keyboard
    
40. 《React-Native系列》40、 ReactNative之bundle文件瘦身
    
41. 《React-Native系列》41、刨根问底Picker组件
    

今天在讲解Flexbox之前，我们先讲解一下高度和宽度的问题。因为Height and Width的问题很简单，就不单独写一篇文章了。顺带说一下即可。

Height and Width

一个组件的高度和宽度，决定了它在屏幕上显示的大小。

固定尺寸

最简单的设置组件的尺寸的方法就是通过添加一个固定的宽度和高度。所有尺寸大小在React Native没有单位的,代表着独立的像素密度。

官网例子

import React, { Component } from 'react';
import { AppRegistry, View } from 'react-native';

class FixedDimensionsBasics extends Component {
  render() {
    return (
      <View>
        <View style={{width: 50, height: 50, backgroundColor: 'powderblue'}} />
        <View style={{width: 100, height: 100, backgroundColor: 'skyblue'}} />
        <View style={{width: 150, height: 150, backgroundColor: 'steelblue'}} />
      </View>
    );
  }
};

AppRegistry.registerComponent('AwesomeProject', () => FixedDimensionsBasics);

效果图：

这样设置尺寸大小的方式，比较适合于要求不同的屏幕上显示相同大小的View或者组件。写固定的尺寸大小，死值。

弹性宽高

我们可以在组件样式中使用flex让组件根据可用空间动态的收缩和扩展。通常情况下我们可以使用flex: 1，告诉某个组件来填充剩余的所有的空间，如果是多个组件的话，则是所有的这些组件去平分父容器中的剩余的所有空间。。如果这些并列的子组件的flex值不一样，则谁的值更大，谁占据剩余空间的比例就更大（跟我们android中weight的用法差不多）。

官网例子

import React, { Component } from 'react';
import { AppRegistry, View } from 'react-native';

class FlexDimensionsBasics extends Component {
  render() {
    return (
      // Try removing the `flex: 1` on the parent View.
      // The parent will not have dimensions, so the children can't expand.
      // What if you add `height: 300` instead of `flex: 1`?
      <View style={{flex: 1}}>
        <View style={{flex: 1, backgroundColor: 'powderblue'}} />
        <View style={{flex: 2, backgroundColor: 'skyblue'}} />
        <View style={{flex: 3, backgroundColor: 'steelblue'}} />
      </View>
    );
  }
};

AppRegistry.registerComponent('AwesomeProject', () => FlexDimensionsBasics);

效果图：

关于高度和宽度就讲这些吧，其实内容都是翻译与官网的docs，地址：
https://facebook.github.io/react-native/docs/height-and-width.html#height-and-width

Flexbox

一个组件可以使用Flexbox指定其子组件或元素之间的布局。Flexbox旨在为不同的屏幕上提供一致的布局。

通常情况下，我们结合使用flexDirection、alignItems和 justifyContent三个样式属性就已经能够实现我们所需的布局。

注意：Flexbox在React Native的工作原理和使用方式与css在web上的方式基本一样，当然也有一些例外：比如flexDirection的默认值是column而不是row，alignItems的默认值是stretch而不是flex-start，以及flex只能指定一个数字值。

Flex Direction

向一个组件的样式中添加Flex Direction可以决定一个布局的主轴。子元素应该沿着水平方向(row)排列，还是沿着竖直方向(column)排列呢？默认值是竖直(column)方向。

官网例子

import React, { Component } from 'react';
import { AppRegistry, View } from 'react-native';

class FlexDirectionBasics extends Component {
  render() {
    return (
      // Try setting `flexDirection` to `column`.
      <View style={{flex: 1, flexDirection: 'row'}}>
        <View style={{width: 50, height: 50, backgroundColor: 'powderblue'}} />
        <View style={{width: 50, height: 50, backgroundColor: 'skyblue'}} />
        <View style={{width: 50, height: 50, backgroundColor: 'steelblue'}} />
      </View>
    );
  }
};

AppRegistry.registerComponent('AwesomeProject', () => FlexDirectionBasics);

效果图：

Justify Content

向组件的样式中添加Justify Content可以决定其子元素沿着主轴的排列方式。子元素应该分布在主轴的开始端，还是中间，最后，还是均匀分布？可用的选项有：flex-start、center、flex-end、space-around以及space-between。

• flex-start：弹性盒子元素将与行起始位置对齐。该行的第一个子元素的主起始位置的边界将与该行的主起始位置的边界对齐，同时所有后续的伸缩盒项目与其前一个项目对齐。
• flex-end：弹性盒子元素将与行结束位置对齐。该行的第一个子元素的主结束位置的边界将与该行的主结束位置的边界对齐，同时所有后续的伸缩盒项目与其前一个项目对齐。
• center：弹性盒子元素将与行中间位置对齐。该行的子元素将相互对齐并在行中居中对齐，同时第一个元素与行的主起始位置的边距等同与最后一个元素与行的主结束位置的边距（如果剩余空间是负数，则保持两端相等长度的溢出）。
• space-between：弹性盒子元素会均匀分布在行里。如果最左边的剩余空间是负数，或该行只有一个子元素，则该值等效于’flex-start’。在其它情况下，第一个元素的边界与行的主起始位置的边界对齐，同时最后一个元素的边界与行的主结束位置的边距对齐，而剩余的伸缩盒项目则平均分布，并确保两两之间的空白空间相等。
• space-around：弹性盒子元素会均匀分布在行里，两端保留子元素与子元素之间间距大小的一半。如果最左边的剩余空间是负数，或该行只有一个伸缩盒项目，则该值等效于’center’。在其它情况下，伸缩盒项目则平均分布，并确保两两之间的空白空间相等，同时第一个元素前的空间以及最后一个元素后的空间为其他空白空间的一半。

官网例子

import React, { Component } from 'react';
import { AppRegistry, View } from 'react-native';

class JustifyContentBasics extends Component {
  render() {
    return (
      // Try setting `justifyContent` to `center`.
      // Try setting `flexDirection` to `row`.
      <View style={{
        flex: 1,
        flexDirection: 'column',
        justifyContent: 'space-between',
      }}>
        <View style={{width: 50, height: 50, backgroundColor: 'powderblue'}} />
        <View style={{width: 50, height: 50, backgroundColor: 'skyblue'}} />
        <View style={{width: 50, height: 50, backgroundColor: 'steelblue'}} />
      </View>
    );
  }
};

AppRegistry.registerComponent('AwesomeProject', () => JustifyContentBasics);

效果图：

Align Items

向组件的样式（style）中添加alignItems可以决定其子元素沿着次轴（就是与主轴垂直的轴，比如若主轴方向为row，则次轴方向为column）的排列方式。子元素是应该靠近次轴的开始端还是中间，还是末端，亦或是拉伸来填补呢？可用选项有：flex-start、center、flex-end以及stretch。

• flex-start：弹性盒子元素的次轴起始位置的边界紧靠该行的次轴起始边界。
• flex-end：弹性盒子元素的次轴起始位置的边界紧靠住该行的次轴结束边界。
• center：弹性盒子元素在该行的次轴）上居中放置。（如果该行的尺寸小于弹性盒子元素的尺寸，则会向两个方向溢出相同的长度）。
• stretch：如果指定次轴大小的属性值为’auto’，则其值会使项目的边距盒的尺寸尽可能接近所在行的尺寸，但同时会遵照’min/max-width/height’属性的限制。

注意：要使stretch选项生效的话，子元素在次轴方向上不能有固定的尺寸。在下面的例子中：只有将子元素样式中的width: 50去掉之后，alignItems: ‘stretch’才能生效。

官网例子

import React, { Component } from 'react';
import { AppRegistry, View } from 'react-native';

class AlignItemsBasics extends Component {
  render() {
    return (
      // Try setting `alignItems` to 'flex-start'
      // Try setting `justifyContent` to `flex-end`.
      // Try setting `flexDirection` to `row`.
      <View style={{
        flex: 1,
        flexDirection: 'column',
        justifyContent: 'center',
        alignItems: 'center',
      }}>
        <View style={{width: 50, height: 50, backgroundColor: 'powderblue'}} />
        <View style={{width: 50, height: 50, backgroundColor: 'skyblue'}} />
        <View style={{width: 50, height: 50, backgroundColor: 'steelblue'}} />
      </View>
    );
  }
};

AppRegistry.registerComponent('AwesomeProject', () => AlignItemsBasics);

效果图：

文章翻译并参考于Flexbox官方文档，地址：
https://facebook.github.io/react-native/docs/flexbox.html

好了，到这里关于Flexbox的讲解就讲到这里了，关于Flexbox运用，上面的例子只是冰山一角，要想真正熟练掌握，还得靠自己亲自动手去写，去实践，才能够真正来理解各个属性的意思。赶紧动手去实践吧。

欢迎关注微信公众号：非著名程序员（smart_android），每天每周定时推送原创技术文章。所有技术文章， 均会在微信订阅号首发，关注微信公众号可以及时获得技术文章推送。

原文地址：http://godcoder.me

版本：unity 5.3.4  语言：C#

今天又研究了一个脚本。

刚体的第一人称，不过这个脚本没有像之前的FPS脚本一样，加那么多另外的脚本，唯一一个就是MouseLook，这个脚本我们之前分析过了，就不再赘述了。

所以整个看下来都是一个比较完整的FPS模型，个人喜欢用这个刚体实现，因为以后用其他什么力都比较方便。

下面上代码：

// 刚体FPS移动主脚本，用刚体和胶囊组件代替了Character Controller组件
// 提醒一下，这个脚本有两百多行，稍微有点混乱的，建议先看看都有些什么属性留个印象，然后按照Start、Update、FixedUpdate一步步按照逻辑执行顺寻看过去会轻松很多
[RequireComponent(typeof (Rigidbody))]
[RequireComponent(typeof (CapsuleCollider))]
public class RigidbodyFirstPersonController : MonoBehaviour
{
    // 内部类，移动设置
    [Serializable]
    public class MovementSettings
    {
        public float ForwardSpeed = 8.0f;   // 向前走的最大速度
        public float BackwardSpeed = 4.0f;  // 后退的最大速度
        public float StrafeSpeed = 4.0f;    // 倾斜走的最大速度
        public float RunMultiplier = 2.0f;   // 奔跑速度跟行走速度的比例

	    public KeyCode RunKey = KeyCode.LeftShift;  //跑步的按键

        public float JumpForce = 30f;   //起跳的力

        public AnimationCurve SlopeCurveModifier = new AnimationCurve(new Keyframe(-90.0f, 1.0f), new Keyframe(0.0f, 1.0f), new Keyframe(90.0f, 0.0f));  //斜面移动的调节曲线，默认是0到90，从1减到0
        [HideInInspector] public float CurrentTargetSpeed = 8f; //当前的目标速度

#if !MOBILE_INPUT
        private bool m_Running; //当前是否在跑步状态，只有在非手机平台上有效
#endif
        // 更新目标的速度。
        public void UpdateDesiredTargetSpeed(Vector2 input)
        {
	        if (input == Vector2.zero) return;  //没有输入不处理

			if (input.x > 0 || input.x < 0)     //x轴(即水平方向)有输入，速度为倾斜速度
			{
				CurrentTargetSpeed = StrafeSpeed;
			}
			if (input.y < 0)    //y小于0，速度为后退速度
			{
				CurrentTargetSpeed = BackwardSpeed;
			}
			if (input.y > 0)    //y大于0，前进速度，这个写在最后，使其优先级最高，即如果即倾斜又前进，则为前进速度
			{
				CurrentTargetSpeed = ForwardSpeed;
			}
#if !MOBILE_INPUT
	        if (Input.GetKey(RunKey))   //奔跑状态下，速度默认乘以2
	        {
		        CurrentTargetSpeed *= RunMultiplier;
		        m_Running = true;
	        }
	        else
	        {
		        m_Running = false;
	        }
#endif
        }

#if !MOBILE_INPUT
        public bool Running
        {
            get { return m_Running; }
        }
#endif
    }

    // 内部类，高级设置
    [Serializable]
    public class AdvancedSettings
    {
        public float groundCheckDistance = 0.01f; //判断当前是否着陆离地面的距离(设置为0.01f应该是比较好的)
        public float stickToGroundHelperDistance = 0.5f; // stops the character //停止角色运动的距离
        public float slowDownRate = 20f; //当没有输入时，控制器缓慢停下时的比例
        public bool airControl; //当角色在空中时，用户是否能控制角色
        [Tooltip("set it to 0.1 or more if you get stuck in wall")] //鼠标悬停在下面属性上会显示该提示，当然中文是不行的
        public float shellOffset; //减小半径用于减少墙面对卡住角色的影响(值为0.1f是比较好的)
    }

    // 这边开始是主类的代码
    public Camera cam;  //当前的相机，组件组织结构跟非刚体的PFS脚本是一样的，分为角色层和镜头层
    public MovementSettings movementSettings = new MovementSettings();  //内部类，移动设置
    public MouseLook mouseLook = new MouseLook();   //我们的老朋友，鼠标控制角色和镜头旋转
    public AdvancedSettings advancedSettings = new AdvancedSettings();  //内部类，高级设置

    private Rigidbody m_RigidBody;  //角色的刚体
    private CapsuleCollider m_Capsule;  //胶囊碰撞体
    private float m_YRotation;  //y轴的旋转，这个变量好像并没有什么用
    private Vector3 m_GroundContactNormal;      //与地面接触的法线向量
    private bool m_Jump, m_PreviouslyGrounded, m_Jumping, m_IsGrounded; //当前跳跃、着陆等的一些状态bool变量

    // 获取当前的速度
    public Vector3 Velocity
    {
        get { return m_RigidBody.velocity; }
    }

    // 当前的状态是否着陆了
    public bool Grounded
    {
        get { return m_IsGrounded; }
    }

    // 是否在跳跃中
    public bool Jumping
    {
        get { return m_Jumping; }
    }

    // 是否在奔跑状态
    public bool Running
    {
        get
        {
#if !MOBILE_INPUT  //只有在非手机平台上才能奔跑
			return movementSettings.Running;
#else
	        return false;
#endif
        }
    }

    // 初始化
    private void Start()
    {
        m_RigidBody = GetComponent<Rigidbody>();
        m_Capsule = GetComponent<CapsuleCollider>();
        mouseLook.Init (transform, cam.transform);  //给入角色层transform和相机transform
    }

    // 每帧更新
    private void Update()
    {
        RotateView();   //旋转角色和镜头

        if (CrossPlatformInputManager.GetButtonDown("Jump") && !m_Jump)
        {
            m_Jump = true;
        }
    }

    // 固定更新
    private void FixedUpdate()
    {
        GroundCheck();  //判断当前是否在陆地上
        Vector2 input = GetInput(); //获取输入

        // input有输入，并且可以控制的情况，处理速度
        if ((Mathf.Abs(input.x) > float.Epsilon || Mathf.Abs(input.y) > float.Epsilon) && (advancedSettings.airControl || m_IsGrounded))
        {
            // 总是以Camera的正方向作为前进方向
            Vector3 desiredMove = cam.transform.forward*input.y + cam.transform.right*input.x;
            desiredMove = Vector3.ProjectOnPlane(desiredMove, m_GroundContactNormal).normalized;    //将速度投射到法线的斜面，并将其单位化

            desiredMove.x = desiredMove.x*movementSettings.CurrentTargetSpeed;  //计算各轴的速度
            desiredMove.z = desiredMove.z*movementSettings.CurrentTargetSpeed;
            desiredMove.y = desiredMove.y*movementSettings.CurrentTargetSpeed;

            if (m_RigidBody.velocity.sqrMagnitude <
                (movementSettings.CurrentTargetSpeed*movementSettings.CurrentTargetSpeed))  //当前速度小于目标速度，则加个冲力，我最初的实现是直接该刚体的速度，导致损失了其他的力，比如重力、炸弹爆炸对角色的冲力
            {
                m_RigidBody.AddForce(desiredMove*SlopeMultiplier(), ForceMode.Impulse); //斜率跟冲力做计算
            }
        }

        if (m_IsGrounded)
        {
            m_RigidBody.drag = 5f;  //在地上把空气阻力设置为5f

            // 要跳跃了，空气阻力设置为0，着陆状态到跳跃状态的一个中间状态
            if (m_Jump) 
            {
                m_RigidBody.drag = 0f;
                m_RigidBody.velocity = new Vector3(m_RigidBody.velocity.x, 0f, m_RigidBody.velocity.z); //保存x、z轴速度
                m_RigidBody.AddForce(new Vector3(0f, movementSettings.JumpForce, 0f), ForceMode.Impulse);   //在y轴上使用一个冲力
                m_Jumping = true;   //正式进入jump状态
            }

            // 没有速度，不在跳跃，并且刚体的速度小于1，则使刚体休眠，节约cpu运算
            if (!m_Jumping && Mathf.Abs(input.x) < float.Epsilon && Mathf.Abs(input.y) < float.Epsilon && m_RigidBody.velocity.magnitude < 1f)
            {
                m_RigidBody.Sleep();
            }
        }
        else
        {
            m_RigidBody.drag = 0f;  //空中，空气阻力设置为0，否则跳得很矮
            if (m_PreviouslyGrounded && !m_Jumping)
            {
                StickToGroundHelper();  //跳跃完成后把刚体粘到地上
            }
        }
        m_Jump = false;
    }

    // 斜率跟冲力做计算
    private float SlopeMultiplier()
    {
        float angle = Vector3.Angle(m_GroundContactNormal, Vector3.up); //计算地面斜面法线和z轴正方向的角度
        return movementSettings.SlopeCurveModifier.Evaluate(angle); //根据斜率曲线，计算出当前应该给与物体冲力的比例，斜面斜率到90的时候，即使按了方向键也没有冲力
    }

    // 粘到地上助手
    private void StickToGroundHelper()
    {
        RaycastHit hitInfo;
        if (Physics.SphereCast(transform.position, m_Capsule.radius * (1.0f - advancedSettings.shellOffset), Vector3.down, out hitInfo,
                                ((m_Capsule.height/2f) - m_Capsule.radius) +
                                advancedSettings.stickToGroundHelperDistance, ~0, QueryTriggerInteraction.Ignore))   //丢球到地上
        {
            if (Mathf.Abs(Vector3.Angle(hitInfo.normal, Vector3.up)) < 85f)
            {
                m_RigidBody.velocity = Vector3.ProjectOnPlane(m_RigidBody.velocity, hitInfo.normal);    //刚体的速度映射到斜面上
            }
        }
    }

    // 获取输入
    private Vector2 GetInput()
    {
            
        Vector2 input = new Vector2
            {
                x = CrossPlatformInputManager.GetAxis("Horizontal"),
                y = CrossPlatformInputManager.GetAxis("Vertical")
            };
		movementSettings.UpdateDesiredTargetSpeed(input);
        return input;
    }

    // 旋转镜头和角色
    private void RotateView()
    {
        // 当游戏暂停时忽略鼠标移动的影响
        if (Mathf.Abs(Time.timeScale) < float.Epsilon) return;
        /* 这边引用宏哥1995的总结：
            * 1.timeScale不影响Update和LateUpdate，会影响FixedUpdate
            * 2.timeScale不影响Time.realtimeSinceStartup，会影响Time.timeSinceLevelLoad和Time.time
            * 3.timeScale不影响Time.fixedDeltaTime和Time.unscaleDeltaTime，会影响Time.deltaTime
            */

        // 在旋转之前获取一下旋转角度
        float oldYRotation = transform.eulerAngles.y;

        mouseLook.LookRotation (transform, cam.transform);  //MouseLook处理角色镜头旋转

        // 只有在方向键可以控制角色时，才进入判断，其他情况反正xz平面速度为0嘛
        if (m_IsGrounded || advancedSettings.airControl)
        {
            // 旋转刚体的速度，以符合新的角色旋转角度
            Quaternion velRotation = Quaternion.AngleAxis(transform.eulerAngles.y - oldYRotation, Vector3.up);  //获取旋转角度差
            m_RigidBody.velocity = velRotation*m_RigidBody.velocity;    //相乘即旋转增加该角度，这个之前计算出欧拉角相乘是一样的(严格来说是用一个欧拉角来计算出一个Quaternion对象)
        }
    }

    // 用一个球从胶囊中间丢下，看看是否碰撞陆地，来判断是否在陆地上，这跟非刚体的FPS脚本是一样的
    private void GroundCheck()
    {
        m_PreviouslyGrounded = m_IsGrounded;
        RaycastHit hitInfo;
        if (Physics.SphereCast(transform.position, m_Capsule.radius * (1.0f - advancedSettings.shellOffset), Vector3.down, out hitInfo,
                                ((m_Capsule.height/2f) - m_Capsule.radius) + advancedSettings.groundCheckDistance, ~0, QueryTriggerInteraction.Ignore))  //有一些不同的是这边用到了几个高级属性，用于减少球的半径，增加投球的距离，使其倾向于判断胶囊底部的碰撞，而非侧边的碰撞
        {
            m_IsGrounded = true;
            m_GroundContactNormal = hitInfo.normal; //获取法线
        }
        else
        {
            m_IsGrounded = false;
            m_GroundContactNormal = Vector3.up;
        }

        // 前个固定一帧的状态是不在地上，现在在地上的情况，跳跃状态结束
        if (!m_PreviouslyGrounded && m_IsGrounded && m_Jumping)
        {
            m_Jumping = false;
        }
    }
}

嗯嗯，今天分析了4个脚本，感觉前途还很遥远。

下边是我自己的一些心情，没兴趣的读者玩家们可以跳过了。

很多时候描绘自己的梦想很轻松，自己想要成为什么，但实际上做起来又是另一会事，总会抱怨自己的环境有那些欠缺，但就是不肯自己动手做些什么，拖沓的病、以及大量的计划也让我应接不暇，然而这些东西也只能自己在博文中发一发，说自己未来一定有一个团队的，但是……

刚刚看了一圈独立游戏的开发者，发现那些游戏我大部分都玩过，说来惭愧，有些我自己都奉为神作的作品自己一分钱也没有花。

多数作品是一些团队完成的，分工明确、目标一致，资金上可能缺一点，不过挺过来的相对都是成功的。有几句话挺触动我的，说是团队的核心成员基本上是最要好的朋友，有不同的技能，但有相同的梦想。

想起一个用虚幻引擎做鹿的一个游戏的小青年，初中？反正10几岁吧，就跟着自己的同学组建了一个三人的团队，令人惊叹。

感慨自己没有这样一起怀有相同梦想人的同时，认真思考，可能最终只能一个人来做。

不过美术、音乐、策划都是相当需要时间的一件事情，自己除了程序以外又什么也没接触过。

我自己的创作作品的计划一拖再拖，美其名曰没有时间，现在还有很多前置的计划，不过谁知道是不是内心的恐惧抓住了我，让我不敢开始。我经历过太多太多的失败了，从来也不是那些成功者的一员，或许将来会好一些吧。

每次借口说自己没认真做，但是认真做了就能成功吗？我的眼光、能力和性格始终摆在那里，不进不退。我觉得最现实的就是磨练好自己unity技术，拿个还算不错的工资，能够自己生活就行了，过得平凡一些。

有时候确实会疑惑，为什么没有超人的能力，还成天想着那些不切实际的梦想。如果没有会不会幸福很多。

Webview模块管理应用窗口界面，实现多窗口的逻辑控制管理操作。通过plus.webview可获取应用界面管理对象。
方法：

all: 获取所有Webview窗口
close: 关闭Webview窗口
create: 创建新的Webview窗口
currentWebview: 获取当前窗口的WebviewObject对象
getWebviewById: 查找指定标识的WebviewObject窗口
getLaunchWebview: 获取应用首页WebviewObject窗口对象
getTopWebview: 获取应用显示栈顶的WebviewObject窗口对象
hide: 隐藏Webview窗口
open: 创建并打开Webview窗口
show: 显示Webview窗口
defaultHardwareAccelerated: 获取Webview默认是否开启硬件加速

对象：

AnimationTypeShow: 一组用于定义页面或控件显示动画效果
AnimationTypeClose: 一组用于定义页面或控件关闭的动画效果
WebviewObject: Webview窗口对象，用于操作加载HTML页面的窗口
WebviewBounceStyle: Webview窗口回弹样式
WebviewDock: 原生控件在窗口中停靠的方式
WebviewEvent: Webview窗口事件
WebviewRefreshStyle: Webview窗口下拉刷新样式
WebviewPosition: 原生控件在窗口中显示的位置
WebviewStyles: JSON对象，原生窗口设置参数的对象
WebviewExtraOptions: JSON对象，原生窗口扩展参数
WebviewTransform: 一组用于定义页面或控件变形的属性
WebviewTransition: 一组用于定义页面或控件转换效果的属性
WebviewOverridResourceOptions: 拦截Webview窗口资源请求的参数
WebviewOverrideUrlOptions: 拦截Webview窗口URL请求的属性
WebviewListenResourceOptions: 监听Webview窗口资源加载的属性

回调方法：

BounceEventCallback: Webview窗口回弹事件的回调函数
EventCallback: Webview窗口事件的回调函数
PopGestureCallback: Webview窗口侧滑事件的回调函数
HistoryQueryCallback: 历史记录记录查询的回调函数
ListenResourceLoadingCallback: Webview窗口加载资源事件的回调函数
OverrideUrlLoadingCallback: Webview窗口拦截URL链接跳转的回调函数
TitleUpdateCallback: Webview窗口加载页面标题更新的回调函数
SuccessCallback: Webview窗口操作成功回调函数
ErrorCallback: Webview窗口操作失败回调函数

权限：

功能模块（permissions）

{
// ...
"permissions":{
    // ...
    "Webview": {
        "description": "窗口管理"
    }
}
}

all

获取所有Webview窗口

Array[WebviewObject] plus.webview.all();

说明：

获取应用中已创建的所有Webview窗口，包括所有未显示的Webview窗口。 返回WebviewObject对象在数组中按创建的先后顺序排列，即数组中第一个WebviewObject对象用是加载应用的入口页面。
参数：

无
返回值：
Array[ WebviewObject ] : 应用中创建的所有Webview窗口对象数组。
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
// H5 plus事件处理
function plusReady(){
    // 获取所有Webview窗口
    var wvs=plus.webview.all();
    for(var i=0;i<wvs.length;i++){
        console.log("webview"+i+": "+wvs[i].getURL());
    }
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
    </script>
    </head>
    <body>
    获取所有Webview窗口
    </body>
</html>

close

关闭Webview窗口

void plus.webview.close( id_wvobj, aniClose, duration, extras );

说明：

关闭已经打开的Webview窗口，需先获取窗口对象或窗口id，并可指定关闭窗口的动画及动画持续时间。
参数：

id_wvobj: ( String | WebviewObject ) 必选 要关闭Webview窗口id或窗口对象
若操作窗口对象已经关闭，则无任何效果。 使用窗口id时，则查找对应id的窗口，如果有多个相同id的窗口则操作最先打开的窗口，若没有查找到对应id的WebviewObject对象，则无任何效果。
aniClose: ( AnimationTypeClose ) 可选 关闭Webview窗口的动画效果
如果没有指定关闭窗口动画，则使用默认值“auto”，即使用显示时设置的窗口动画相对应的关闭动画。
duration: ( Number ) 可选 关闭Webview窗口动画的持续时间
单位为ms，如果没有设置则使用显示窗口动画时间。
extras: ( WebviewExtraOptions ) 可选 关闭Webview窗口扩展参数
可用于指定Webview窗口动画是否使用图片加速。

返回值：
void : 无
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
// H5 plus事件处理
function plusReady(){
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}

// 关闭自身窗口
function closeme(){
    var ws=plus.webview.currentWebview();
    plus.webview.close(ws);
}
    </script>
    </head>
    <body>
        关闭Webview窗口<br/>
        <button onclick="closeme()">close</button>
    </body>
</html>

create

创建新的Webview窗口

WebviewObject plus.webview.create( url, id, styles, extras );

说明：

创建Webview窗口，用于加载新的HTML页面，可通过styles设置Webview窗口的样式，创建完成后需要调用show方法才能将Webview窗口显示出来。
参数：

url: ( String ) 可选 新窗口加载的HTML页面地址
新打开Webview窗口要加载的HTML页面地址，可支持本地地址和网络地址。
id: ( String ) 可选 新窗口的标识
窗口标识可用于在其它页面中通过getWebviewById来查找指定的窗口，为了保持窗口标识的唯一性，应该避免使用相同的标识来创建多个Webview窗口。 如果传入无效的字符串则使用url参数作为WebviewObject窗口的id值。
styles: ( WebviewStyles ) 可选 创建Webview窗口的样式（如窗口宽、高、位置等信息）
extras: ( JSON ) 可选 创建Webview窗口的额外扩展参数
值为JSON类型，设置扩展参数后可以直接通过Webview的点（“.”）操作符获取扩展参数属性值，如： var w=plus.webview.create('url.html','id',{},{preload:"preload webview"}); // 可直接通过以下方法获取preload值 console.log(w.preload); // 输出值为“preload webview”

返回值：
WebviewObject : Webview窗口对象
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
// H5 plus事件处理
function plusReady(){
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}

// 创建并显示新窗口
function create(){
    var w = plus.webview.create( "http://weibo.com/dhnetwork" );
    w.show(); // 显示窗口
}
    </script>
    </head>
    <body>
        创建新的Webview窗口<br/>
        <button onclick="create()">Create</button>
    </body>
</html>

currentWebview

获取当前窗口的WebviewObject
WebviewObject plus.webview.currentWebview();

说明：

获取当前页面所属的Webview窗口对象。
参数：

无
返回值：
WebviewObject : Webview窗口对象
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
// H5 plus事件处理
function plusReady(){
    var ws=plus.webview.currentWebview();
    console.log( "当前Webview窗口："+ws.getURL() );
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
    </script>
    </head>
    <body>
        获取自身Webview窗口
    </body>
</html>

getWebviewById

查找指定标识的WebviewObject窗口

WebviewObject plus.webview.getWebviewById( id );

说明：

在已创建的窗口列表中查找指定标识的Webview窗口并返回。 若没有查找到指定标识的窗口则返回null，若存在多个相同标识的Webview窗口，则返回第一个创建的Webview窗口。 如果要获取应用入口页面所属的Webview窗口，其标识为应用的%APPID%，可通过plus.runtime.appid获取。
参数：

id: ( String ) 必选 要查找的Webview窗口标识

返回值：
WebviewObject : WebviewObject窗口对象
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
// H5 plus事件处理
function plusReady(){
    // 查找应用首页窗口对象
    var h=plus.webview.getWebviewById( plus.runtime.appid );
    console.log( "应用首页Webview窗口："+h.getURL() );
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
    </script>
    </head>
    <body>
        查找指定标识的窗口
    </body>
</html>

getLaunchWebview

获取应用首页WebviewObject窗口对象

WebviewObject plus.webview.getLaunchWebview();

参数：

无
返回值：
WebviewObject : WebviewObject窗口对象
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
// H5 plus事件处理
function plusReady(){
    // 获取应用首页窗口对象
    var h=plus.webview.getLaunchWebview();
    console.log( "应用首页Webview窗口："+h.getURL() );
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
    </script>
    </head>
    <body>
        获取应用首页WebviewObject窗口对象
    </body>
</html>

getTopWebview

获取应用显示栈顶的WebviewObject窗口对象

WebviewObject plus.webview.getTopWebview();

参数：

无
返回值：
WebviewObject : WebviewObject窗口对象
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
// H5 plus事件处理
function plusReady(){
    // 获取应用首页窗口对象
    var h=plus.webview.getTopWebview();
    console.log( "应用显示栈顶的Webview窗口："+h.getURL() );
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
    </script>
    </head>
    <body>
        获取应用显示栈顶的WebviewObject窗口对象
    </body>
</html>

hide

隐藏Webview窗口

void plus.webview.hide( id_wvobj, aniHide, duration, extras );

说明：

根据指定的WebviewObject对象或id隐藏Webview窗口，使得窗口不可见。
参数：

id_wvobj: ( String | WebviewObject ) 必选 要隐藏的Webview窗口id或窗口对象
使用窗口对象时，若窗口对象已经隐藏，则无任何效果。 使用窗口id时，则查找对应id的窗口，如果有多个相同id的窗口则操作最先打开的，若没有查找到对应id的WebviewObject对象，则无任何效果。
aniHide: ( AnimationTypeClose ) 可选 隐藏Webview窗口的动画效果
如果没有指定窗口动画，则使用默认动画效果“none”。
duration: ( Number ) 可选 隐藏Webview窗口动画的持续时间
单位为ms，如果没有设置则使用默认窗口动画时间。
extras: ( WebviewExtraOptions ) 可选 隐藏Webview窗口扩展参数
可用于指定Webview窗口动画是否使用图片加速。

返回值：
void : 无
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
// H5 plus事件处理
function plusReady(){
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}

// 隐藏自身窗口
function hideeme(){
    plus.webview.hide( plus.webview.currentWebview() );
}
    </script>
    </head>
    <body>
        隐藏Webview窗口<br/>
        <button onclick="hideeme()">Hide</button>
    </body>
</html>

open

创建并打开Webview窗口

WebviewObject plus.webview.open( url, id, styles, aniShow, duration, showedCB );

说明：

创建并显示Webview窗口，用于加载新的HTML页面，可通过styles设置Webview窗口的样式，创建完成后自动将Webview窗口显示出来。
参数：

url: ( String ) 可选 打开窗口加载的HTML页面地址
新打开Webview窗口要加载的HTML页面地址，可支持本地地址和网络地址。
id: ( String ) 可选 打开窗口的标识
窗口标识可用于在其它页面中通过getWebviewById来查找指定的窗口，为了保持窗口标识的唯一性，应该避免使用相同的标识来创建多个Webview窗口。 如果传入无效的字符串则使用url参数作为WebviewObject窗口的id值。
styles: ( WebviewStyles ) 可选 创建Webview窗口的样式（如窗口宽、高、位置等信息）
aniShow: ( AnimationTypeShow ) 可选 显示Webview窗口的动画效果
如果没有指定窗口动画，则使用默认无动画效果“none”。
duration: ( Number ) 可选 显示Webview窗口动画的持续时间
单位为ms，如果没有设置则使用默认窗口动画时间600ms。
showedCB: ( SuccessCallback ) 可选 Webview窗口显示完成的回调函数
当指定Webview窗口显示动画执行完毕时触发回调函数，窗口无动画效果（如"none"动画效果）时也会触发此回调。

返回值：
WebviewObject : WebviewObject窗口对象
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
// H5 plus事件处理
function plusReady(){
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}

// 创建并显示新窗口
function openWebview(){
    var w = plus.webview.open( "http://weibo.com/dhnetwork" );
}
    </script>
    </head>
    <body>
        打开Webview窗口<br/>
        <button onclick="openWebview()">Open</button>
    </body>
</html>

show

显示Webview窗口

void plus.webview.show( id_wvobj, aniShow, duration, showedCB, extras );

说明：

显示已创建或隐藏的Webview窗口，需先获取窗口对象或窗口id，并可指定显示窗口的动画及动画持续时间。
参数：

id_wvobj: ( String | WebviewObject ) 必选 要显示Webview窗口id或窗口对象
若操作Webview窗口对象显示，则无任何效果。 使用窗口id时，则查找对应id的窗口，如果有多个相同id的窗口则操作最先创建的窗口，若没有查找到对应id的WebviewObject对象，则无任何效果。
aniShow: ( AnimationTypeShow ) 可选 显示Webview窗口的动画效果
如果没有指定窗口动画类型，则使用默认值“auto”，即自动选择上一次显示窗口的动画效果，如果之前没有显示过，则使用“none”动画效果。
duration: ( Number ) 可选 显示Webview窗口动画的持续时间
单位为ms，如果没有设置则使用默认窗口动画时间600ms。
showedCB: ( SuccessCallback ) 可选 Webview窗口显示完成的回调函数
当指定Webview窗口显示动画执行完毕时触发回调函数，窗口无动画效果（如"none"动画效果）时也会触发此回调。
extras: ( WebviewExtraOptions ) 可选 显示Webview窗口扩展参数
可用于指定Webview窗口动画是否使用图片加速。

返回值：
WebviewObject : Webview窗口对象
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
// H5 plus事件处理
function plusReady(){
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}

// 创建并显示新窗口
function create(){
    var w = plus.webview.create( "http://weibo.com/dhnetwork" );
    plus.webview.show( w ); // 显示窗口
}
    </script>
    </head>
    <body>
        显示Webview窗口<br/>
        <button onclick="create()">Create</button>
    </body>
</html>

defaultHardwareAccelerated

获取Webview默认是否开启硬件加速

Boolean plus.webview.defaultHardwareAccelerated();

说明：

由于不同设备对硬件加速的支持情况存在差异，开启硬件加速能加速HTML页面的渲染，但也会消耗更多的系统资源，从而导致在部分设备上可能出现闪屏、发虚、分块渲染等问题， 因此5+ Runtime会根据设备实际支持情况自动选择是否开启硬件加速。 关闭硬件加速则可能会导致Webview页面无法支持Video标签播放视频等问题，如果在特定情况下需要调整修改默认开启硬件加速的行为，则可通过plus.webview.defaultHardwareAccelerated()方法获取当前设备默认是否开启硬件加速状态，从而决定是否需要显式开启或关闭指定Webview的硬件加速功能（通过WebviewStyles的hardwareAccelerated属性设置）。
参数：

无
返回值：
Boolean : Webview窗口默认开启硬件加速则返回true，否则返回false。
平台支持：

Android - 2.3+ (支持): 返回当前设备默认是否开启硬件加速。
iOS - 5.1+ (不支持): 返回固定值true。

示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
// H5 plus事件处理
function plusReady(){
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}

// 创建新窗口并设置开启硬件加速
function create(){
    var styles={};
    // 在Android5以上设备，如果默认没有开启硬件加速，则强制设置开启
    if(!plus.webview.defaultHardwareAccelerated()&&parseInt(plus.os.version)>=5){
        styles.hardwareAccelerated=true;
    }
    var w = plus.webview.create( "http://weibo.com/dhnetwork", "test", styles );
    plus.webview.show( w ); // 显示窗口
}
    </script>
    </head>
    <body>
        开启硬件加速显示Webview窗口<br/>
        <button onclick="create()">Create</button>
    </body>
</html>

AnimationTypeShow

一组用于定义页面或控件显示动画效果
常量：

"auto": (String 类型 )自动选择动画效果

自动选择动画效果，使用上次显示窗口设置的动画效果，如果是第一次显示则默认动画效果“none”。
"none": (String 类型 )无动画效果

立即显示页面，无任何动画效果，页面显示默认的动画效果。 此效果忽略动画时间参数，立即显示。 对应关闭动画"none"。
"slide-in-right": (String 类型 )从右侧横向滑动效果

页面从屏幕右侧外向内横向滑动显示。 对应关闭动画"slide-out-right"。
平台支持
    Android - 2.2+ (支持): 默认动画时间为200ms。
    iOS - 5.1.1+ (支持): 默认动画时间为300ms。
"slide-in-left": (String 类型 )从左侧横向滑动效果

页面从屏幕左侧向右横向滑动显示。 对应关闭动画"slide-out-left"。
平台支持
    Android - 2.2+ (支持): 默认动画时间为200ms。
    iOS - 5.1.1+ (支持): 默认动画时间为300ms。
"slide-in-top": (String 类型 )从上侧竖向滑动效果

页面从屏幕上侧向下竖向滑动显示。 对应关闭动画"slide-out-top"。
平台支持
    Android - 2.2+ (支持): 默认动画时间为200ms。
    iOS - 5.1.1+ (支持): 默认动画时间为300ms。
"slide-in-bottom": (String 类型 )从下侧竖向滑动效果

页面从屏幕下侧向上竖向滑动显示。 对应关闭动画"slide-out-bottom"。
平台支持
    Android - 2.2+ (支持): 默认动画时间为200ms。
    iOS - 5.1.1+ (支持): 默认动画时间为300ms。
"fade-in": (String 类型 )从透明到不透明逐渐显示效果

页面从完全透明到不透明逐渐显示。 对应关闭动画"fade-out"。
平台支持
    Android - 2.2+ (支持): 默认动画时间为200ms。
    iOS - 5.1.1+ (支持): 默认动画时间为300ms。
"zoom-out": (String 类型 )从小到大逐渐放大显示效果

页面在屏幕中间从小到大逐渐放大显示。 对应关闭动画"zoom-in"。
平台支持
    Android - 2.2+ (支持): 默认动画时间为100ms。
    iOS - 5.1.1+ (支持): 默认动画时间为100ms。
"zoom-fade-out": (String 类型 )从小到大逐渐放大并且从透明到不透明逐渐显示效果

页面在屏幕中间从小到大逐渐放大并且从透明到不透明逐渐显示。 对应关闭动画"zoom-fade-in"。
平台支持
    Android - 2.2+ (支持): 默认动画时间为100ms。
    iOS - 5.1.1+ (支持): 默认动画时间为100ms。
"pop-in": (String 类型 )从右侧平移入栈动画效果

页面从屏幕右侧滑入显示，同时上一个页面带阴影效果从屏幕左侧滑出隐藏。 对应关闭动画"pop-out"。
平台支持
    Android - 2.2+ (支持): 默认动画时间为200ms。 此动画是新开窗口侧滑挤压当前屏幕窗口特效，必须是两个Webview窗口的组合动画， 如果当前屏幕已显示多个Webview窗口，则显示新窗口不支持此动画类型，自动转成“slide-in-right”。
    iOS - 5.1.1+ (支持): 默认动画时间为300ms。

AnimationTypeClose

一组用于定义页面或控件关闭的动画效果
常量：

"auto": (String 类型 )自动选择动画效果

自动选择显示窗口相对于的动画效果。
"none": (String 类型 )无动画

立即关闭页面，无任何动画效果。 此效果忽略动画时间参数，立即关闭。
"slide-out-right": (String 类型 )横向向右侧滑出屏幕动画

页面从屏幕中横向向右侧滑动到屏幕外关闭。
平台支持
    Android - 2.2+ (支持): 默认动画时间为200ms。
    iOS - 5.1.1+ (支持): 默认动画时间为300ms。
"slide-out-left": (String 类型 )横向向左侧滑出屏幕动画

页面从屏幕中横向向左侧滑动到屏幕外关闭。
平台支持
    Android - 2.2+ (支持): 默认动画时间为200ms。
    iOS - 5.1.1+ (支持): 默认动画时间为300ms。
"slide-out-top": (String 类型 )竖向向上侧滑出屏幕动画

页面从屏幕中竖向向上侧滑动到屏幕外关闭。
平台支持
    Android - 2.2+ (支持): 默认动画时间为200ms。
    iOS - 5.1.1+ (支持): 默认动画时间为300ms。
"slide-out-bottom": (String 类型 )竖向向下侧滑出屏幕动画

页面从屏幕中竖向向下侧滑动到屏幕外关闭。
平台支持
    Android - 2.2+ (支持): 默认动画时间为200ms。
    iOS - 5.1.1+ (支持): 默认动画时间为300ms。
"fade-out": (String 类型 )从不透明到透明逐渐隐藏动画

页面从不透明到透明逐渐隐藏关闭。
平台支持
    Android - 2.2+ (支持): 默认动画时间为200ms。
    iOS - 5.1.1+ (支持): 默认动画时间为300ms。
"zoom-in": (String 类型 )从大逐渐缩小关闭动画

页面逐渐向页面中心缩小关闭。
平台支持
    Android - 2.2+ (支持): 默认动画时间为100ms。
    iOS - 5.1.1+ (支持): 默认动画时间为100ms。
"zoom-fade-in": (String 类型 )从大逐渐缩小并且从不透明到透明逐渐隐藏关闭动画

页面逐渐向页面中心缩小并且从不透明到透明逐渐隐藏关闭。
平台支持
    Android - 2.2+ (支持): 默认动画时间为100ms。
    iOS - 5.1.1+ (支持): 默认动画时间为100ms。
"pop-out": (String 类型 )从右侧平移出栈动画效果

页面从屏幕右侧滑出消失，同时上一个页面带阴影效果从屏幕左侧滑入显示。
平台支持
    Android - 2.2+ (支持): 默认动画时间为200ms。
    iOS - 5.1.1+ (支持): 默认动画时间为300ms。

WebviewObject

Webview窗口对象，用于操作加载HTML页面的窗口
属性：

id: Webview窗口的标识

方法：

addEventListener: 添加事件监听器
append: 在Webview窗口中添加子窗口
appendJsFile: 添加Webview窗口预加载js文件
back: 后退到上次加载的页面
canBack: 查询Webview窗口是否可后退
canForward: 查询Webview窗口是否可前进
children: 获取Webview窗口的所有子Webview窗口
clear: 清空原生Webview窗口加载的内容
close: 关闭Webview窗口
draw: 截屏绘制
evalJS: 在Webview窗口中执行JS脚本
forward: 前进到上次加载的页面
getStyle: 获取Webview窗口的样式
getTitle: 获取Webview窗口加载HTML页面的标题
getURL: 获取Webview窗口加载HTML页面的地址
hide: 隐藏Webview窗口
isHardwareAccelerated: 查询Webview窗口是否开启硬件加速
isVisible: 查询Webview窗口是否可见
listenResourceLoading: 监听页面开始加载资源
loadData: 加载新HTML数据
loadURL: 加载新URL页面
nativeInstanceObject: 获取Webview窗口对象的原生（Native.JS）实例对象
opened: 获取在当前Webview窗口中创建的所有窗口
opener: 获取当前Webview窗口的创建者
overrideResourceRequest: 拦截Webview窗口的资源加载
overrideUrlLoading: 拦截Webview窗口的URL请求
parent: 获取当前Webview窗口的父窗口
reload: 重新加载Webview窗口显示的HTML页面
resetBounce: 重置Webview窗口的回弹位置
remove: 移除子Webview窗口
removeEventListener: 移除Webview窗口事件监听器
removeFromParent: 从父窗口中移除
setBounce: 设置Webview窗口的回弹效果
setBlockNetworkImage: 设置Webview窗口是否阻塞加载页面中使用的网络图片
setContentVisible: 设置HTML内容是否可见
setPullToRefresh: 设置Webview窗口的下拉刷新效果
setStyle: 设置Webview窗口的样式
setJsFile: 设置预加载的JS文件
show: 显示Webview窗口
stop: 停止加载HTML页面内容

事件：

onclose: Webview窗口关闭事件
onerror: Webview窗口错误事件
onloaded: Webview窗口页面加载完成事件
onloading: Webview窗口页面开始加载事件

id

Webview窗口的标识
说明：

String 类型

在打开或创建Webview窗口时设置，如果没有设置窗口标识，此属性值为undefined。
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
// H5 plus事件处理
function plusReady(){
    // 获取自身webview窗口
    var ws=plus.webview.currentWebview();
    console.log( "窗口标识: "+ws.id );
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
    </script>
    </head>
    <body>
        Webview窗口的标识<br/>
    </body>
</html>

addEventListener

添加事件监听器

wobj.addEventListener( event, listener, capture );

说明：

向Webview窗口添加事件监听器，当指定的事件发生时，将触发listener函数的执行。 可多次调用此方法向Webview添加多个监听器，当监听的事件发生时，将按照添加的先后顺序执行。
参数：

event: ( WebviewEvent ) 必选 Webview窗口事件类型
listener: ( EventCallback ) 必选 监听事件发生时执行的回调函数
capture: ( Boolean ) 可选 捕获事件流顺序，暂无效果

返回值：
void : 无
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
// H5 plus事件处理
function plusReady(){
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}

var nw=null;
// 监听Webview窗口事件
function eventTest() {
    if(nw){return;}
    var w=plus.nativeUI.showWaiting()
    // 打开新窗口
    nw=plus.webview.create( "http://weibo.com/dhnetwork" );
    nw.addEventListener( "loaded", function(){
        console.log( "New Window loaded!" );
        nw.show(); // 显示窗口
        w.close();
        w=null;
    }, false );
}
    </script>
    </head>
    <body>
        添加事件监听器<br/>
        <button onclick="eventTest()">Event Listener</button>
    </body>
</html>

append

在Webview窗口中添加子窗口

void wobj.append( webview );

说明：

将另一个Webview窗口作为子窗口添加到当前Webview窗口中，添加后其所有权归父Webview窗口，当父窗口关闭时子窗口自动关闭。
参数：

webview: ( plus.nativeObj.View | WebviewObject ) 必选 被添加的子Webview窗口或View控件对象
被添加的Webview窗口需通过plus.webview.create方法创建，并且不能调用其show方法进行显示。 父窗口显示时子窗口会自动显示，父窗口隐藏时子窗口也会自动隐藏。 被添加的View控件需通过new plus.nativeObj.View()创建，添加到Webview窗口后所有权一起转移（即Webview关闭后View控件也自动关闭）。 

返回值：
void : 无
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var embed=null;
// H5 plus事件处理
function plusReady(){
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    plus.webview.currentWebview().append( embed );
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
    </script>
    </head>
    <body>
        在Webview窗口中添加子窗口
        <button onclick="plus.webview.currentWebview().close();">Back</button>
    </body>
</html>

appendJsFile

添加Webview窗口预加载js文件

wobj.appendJsFile( file );

说明：

对于一些网络HTML页面，在无法修改HTML页面时可通过此方法自动加载本地js文件。 当Webview窗口跳转到新页面时也会自动加载指定的js执行，添加多个js文件将按照添加的先后顺序执行。
参数：

file: ( String ) 必选 窗口预加载的js文件地址
js文件路径只支持本地文件，应该使用扩展相对路径类型的文件，如"_www/preload.js"。 

返回值：
void : 无
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
// H5 plus事件处理
function plusReady(){
    var nw=plus.webview.create("http://weibo.com/dhnetwork");
    nw.appendJsFile("_www/preload.js");
    nw.show();
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
    </script>
    </head>
    <body>
        添加Webview窗口预加载js文件
    </body>
</html>

back

后退到上次加载的页面

void wobj.back()

说明：

Webview窗口历史记录操作，后退到窗口上次加载的HTML页面。 如果窗口历史记录中没有可后退的页面则不触发任何操作。
参数：

无
返回值：
void : 无
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var embed=null;
// H5 plus事件处理
function plusReady(){
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    plus.webview.currentWebview().append( embed );
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 返回上次页面
function goBack() {
    embed.back();
}
// 前进到上次页面
function goForward() {
    embed.forward();
}
    </script>
    </head>
    <body>
        后退到上次加载的页面
        <button onclick="goBack()">Back</button>
        <button onclick="goForward()">Forward</button>
    </body>
</html>

canBack

查询Webview窗口是否可后退

void wobj.canBack( queryCallback );

说明：

Webview窗口历史记录查询操作，获取Webview是否可后退到历史加载的页面，结果通过queryCallback回调方法返回。
参数：

queryCallback: ( HistoryQueryCallback ) 必选 查询历史记录操作回调函数

返回值：
void : 无
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var embed=null;
// H5 plus事件处理
function plusReady(){
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    plus.webview.currentWebview().append( embed );
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 是否可后退
function canBack() {
    embed.canBack( function(e){
        console.log( "是否可返回："+e.canBack );
    });
}
    </script>
    </head>
    <body>
        查询Webview窗口是否可后退
        <button onclick="canBack()">canBack</button>
    </body>
</html>

canForward

查询Webview窗口是否可前进

void wobj.canForward( queryCallback );

说明：

Webview窗口历史记录查询操作，获取Webview是否可前进到历史加载的页面，结果通过queryCallback回调方法返回。
参数：

queryCallback: ( HistoryQueryCallback ) 必选 查询历史记录操作回调函数

返回值：
void : 无
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var embed=null;
// H5 plus事件处理
function plusReady(){
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    plus.webview.currentWebview().append( embed );
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 是否可前进
function canForward() {
    embed.canForward( function(e){
        console.log( "是否可前进："+e.canForward );
    });
}
    </script>
    </head>
    <body>
        查询Webview窗口是否可前进
        <button onclick="canForward()">canForward</button>
    </body>
</html>

children

获取Webview窗口的所有子Webview窗口

Array[WebviewObject] wobj.children();

说明：

获取添加到Webview窗口中的所有子Webview窗口，如果没有子Webview窗口则返回空数组。
参数：

无
返回值：
Array[ WebviewObject ] : 包含的子Webview窗口对象数组，没有则返回空数组。
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var embed=null;
// H5 plus事件处理
function plusReady(){
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    plus.webview.currentWebview().append( embed );
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 获取子Webview窗口
function listChildren() {
    var list=plus.webview.currentWebview().children();
    for(var i=0;i<list.length;i++){
        console.log( "Children["+i+"]: "+list[i].getURL() );
    }
}
    </script>
    </head>
    <body>
        获取Webview窗口的所有子Webview窗口
        <button onclick="listChildren()">Children</button>
    </body>
</html>

clear

清空原生Webview窗口加载的内容

void wobj.clear();

说明：

清除原生窗口的内容，用于重置原生窗口加载的内容，清除其加载的历史记录等内容。
参数：

无
返回值：
void : 无
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var embed=null;
// H5 plus事件处理
function plusReady(){
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    plus.webview.currentWebview().append( embed );
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 清空Webview窗口
function webviewClear() {
    embed.clear();
}
    </script>
    </head>
    <body>
        清空原生Webview窗口加载的内容
        <button onclick="webviewClear()">Clear</button>
    </body>
</html>

close

关闭Webview窗口

void wobj.close( aniClose, duration, extras );

说明：

关闭并销毁Webview窗口，可设置关闭动画和动画持续时间。
参数：

aniClose: ( AnimationTypeClose ) 可选 关闭Webview窗口动画效果
如果没有指定关闭窗口动画，则使用默认值“auto”，即使用显示时设置的窗口动画相对应的关闭动画。
duration: ( Number ) 可选 关闭Webview窗口的动画持续时间
单位为ms，默认为窗口show方法设定的动画时间。
extras: ( WebviewExtraOptions ) 可选 关闭Webview窗口扩展参数
可用于指定Webview窗口动画是否使用图片加速。

返回值：
void : 无
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 关闭窗口
function closeMe() {
    ws.close();
}
    </script>
    </head>
    <body>
        关闭Webview窗口
        <button onclick="closeMe()">Close</button>
    </body>
</html>

draw

截屏绘制

void wobj.draw( bitmap, successCallback, errorCallback );

说明：

将Webview窗口的可视区域截屏并绘制到Bitmap图片对象中。
参数：

bitmap: ( plus.nativeObj.Bitmap ) 可选 要绘制的图片对象
如果图片中已经存在内容则覆盖，如果截屏绘制失败则保留之前的图片内容。
successCallback: ( SuccessCallback ) 可选 截屏绘制操作成功回调
截屏绘制操作成功时调用。
errorCallback: ( NativeObjErrorCallback ) 必选 截屏绘制操作失败回调
截屏绘制操作失败时调用，并返回失败信息。

返回值：
void : 无
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 截屏绘制
var bitmap=null;
function captureWebview() {
    bitmap = new plus.nativeObj.Bitmap("test");
    // 将webview内容绘制到Bitmap对象中
    ws.draw(bitmap,function(){
        console.log('截屏绘制图片成功');
    },function(e){
        console.log('截屏绘制图片失败：'+JSON.stringify(e));
    });
}
    </script>
    </head>
    <body>
        截屏绘制Webview窗口<br/>
        <button onclick="captureWebview()">Draw</button>
    </body>
</html>

evalJS

在Webview窗口中执行JS脚本

void wobj.evalJS( js );

说明：

将JS脚本发送到Webview窗口中运行，可用于实现Webview窗口间的数据通讯。
参数：

js: ( String ) 必选 要在窗口中运行的脚本字符串

返回值：
void : 无
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null,embed=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    ws.append( embed );
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 在Webview窗口中执行JS脚本
function evalJS() {
    embed.evalJS("alert('evalJS: '+location.href);");
}
    </script>
    </head>
    <body>
        在Webview窗口中执行JS脚本
        <button onclick="evalJS()">evalJS</button>
    </body>
</html>

forward

前进到上次加载的页面

void wobj.forward();

说明：

Webview窗口历史记录操作，前进到窗口上次加载的HTML页面。 如果窗口历史记录中没有可前进的页面则不触发任何操作。
参数：

无
返回值：
void : 无
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var embed=null;
// H5 plus事件处理
function plusReady(){
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    plus.webview.currentWebview().append( embed );
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 返回上次页面
function goBack() {
    embed.back();
}
// 前进到上次页面
function goForward() {
    embed.forward();
}
    </script>
    </head>
    <body>
        前进到上次加载的页面
        <button onclick="goBack()">Back</button>
        <button onclick="goForward()">Forward</button>
    </body>
</html>

getStyle

获取Webview窗口的样式

WebviewStyles wobj.getStyle();

说明：

获取Webview窗口的样式属性，如窗口位置、大小等信息。
参数：

无
返回值：
WebviewStyles : WebviewStyles对象
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 获取Webview窗口的样式
function getStyle() {
    var style=ws.getStyle();
    alert( JSON.stringify(style) );
}
    </script>
    </head>
    <body>
        获取Webview窗口的样式
        <button onclick="getStyle()">getStyle</button>
    </body>
</html>

getTitle

获取Webview窗口加载HTML页面的标题

String wobj.getTitle();

说明：

标题为HTML页面head节点下title节点中的文本内容，当窗口内容发生页面内跳转时可通过窗口触发的“loaded”事件中调用此方法来获取跳转后页面的标题。 如果HTML页面没有使用title节点来设置标题，则返回空字符串。
参数：

无
返回值：
String : 窗口加载页面的标题
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null,embed=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    embed.show();
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 获取Webview窗口的标题
function getTitle() {
    alert( "标题为："+embed.getTitle() );
}
    </script>
    </head>
    <body>
        获取Webview窗口加载HTML页面的标题
        <button onclick="getTitle()">getTitle</button>
    </body>
</html>

getURL

获取Webview窗口加载HTML页面的地址

String wobj.getURL();

说明：

当窗口内容发生页面内跳转时可通过窗口触发的“loaded”事件中调用此方法来获取跳转后页面的地址。
参数：

无
返回值：
String : 窗口加载页面的URL地址
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null,embed=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    embed.show();
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 获取Webview窗口加载HTML页面的地址
function getURL() {
    alert( "页面地址为："+embed.getURL() );
}
    </script>
    </head>
    <body>
        获取Webview窗口加载HTML页面的地址
        <button onclick="getURL()">getURL</button>
    </body>
</html>

hide

隐藏Webview窗口

void wobj.hide( aniHide, duration, extras );

说明：

隐藏Webview窗口可保存已加载HTML页面的上下文数据，能降低应用使用的系统资源，通过show方法可将隐藏的Webview窗口显示出来。
参数：

aniHide: ( AnimationTypeClose ) 可选 隐藏Webview窗口动画效果
如果没有指定隐藏窗口动画，则使用默认动画效果“none”。
duration: ( Number ) 可选 隐藏Webview窗口的动画持续时间
单位为ms，默认为窗口show方法设定的动画时间。
extras: ( WebviewExtraOptions ) 可选 隐藏Webview窗口扩展参数
可用于指定Webview窗口动画是否使用图片加速。

返回值：
void : 无
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null,embed=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    embed.show();
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 隐藏Webview窗口
function hideWebview() {
    embed.hide();
}
    </script>
    </head>
    <body>
        隐藏Webview窗口
        <button onclick="hideWebview()">hide</button>
    </body>
</html>

isHardwareAccelerated

查询Webview窗口是否开启硬件加速

Boolean wobj.isHardwareAccelerated();

说明：

若Webview窗口已经开启硬件加速则返回true，否则返回false。
参数：

无
返回值：
Boolean : Webview窗口是否开启硬件加速
平台支持：

Android - 3.0+ (支持): 5+ Runtime会根据当前设备环境来决定是否开启硬件加速，也可通过WebviewStyles对象的hardwareAccelerated属性来强制设置是否开启硬件加速。 

示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 查询Webview窗口是否开启硬件加速
function isHardwareAccelerated() {
    alert( "是否开启硬件加速："+ws.isHardwareAccelerated() );
}
    </script>
    </head>
    <body>
        查询Webview窗口是否开启硬件加速
        <button onclick="isHardwareAccelerated()">isHardwareAccelerated</button>
    </body>
</html>

isVisible

查询Webview窗口是否可见

Boolean wobj.isVisible();

说明：

若Webview窗口已经显示则返回true，若Webview窗口被隐藏则返回false。
参数：

无
返回值：
Boolean : Webview窗口是否可见
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null,embed=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    embed.show();
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 查询Webview窗口是否可见
function visibleWebview() {
    alert( "是否可见："+embed.isVisible() );
}
// 隐藏Webview窗口
function hideWebview() {
    embed.hide();
}
    </script>
    </head>
    <body>
        查询Webview窗口是否可见
        <button onclick="visibleWebview()">isVisible</button>
        <button onclick="hideWebview()">hide</button>
    </body>
</html>

listenResourceLoading

监听页面开始加载资源

void wobj.listenResourceLoading(options, callback);

说明：

Webview加载资源时，如果满足options参数中定义的条件，则触发callback回调。 此方法仅触发回调事件，不会阻止资源的加载。
参数：

options: ( WebviewListenResourceOptions ) 可选 监听加载资源的参数
callback: ( ListenResourceLoadingCallback ) 可选 监听加载资源的回调函数

返回值：
void : 无
平台支持：

Android - ALL (支持): 5+APP需要选择“解压资源后运行”模式后才能监听加载资源。
iOS - ALL (支持)

示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null,nw=null;
// H5 plus事件处理
function plusReady(){
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 监听页面加载资源
function listenResourceLoading() {
    var wv=plus.webview.create("http://weibo.com/dhnetwork");
    // 监听到页面加载图片资源时显示（{match:".*\.(jpg|png|jpeg|bmp)\b"}）
    wv.listenResourceLoading({match:".*\\.(jpg|png|jpeg|bmp)\\b"}, function(e){
        console.log("loading resource: "+e.url);
        wv.show();
    });
    console.log("create webview");
}
    </script>
    </head>
    <body>
        监听页面开始加载资源
        <button onclick="listenResourceLoading()">加载图片资源时显示窗口</button>
    </body>
</html>

loadData

加载新HTML数据

void wobj.loadData( data );

说明：

触发Webview窗口加载HTML页面数据，如果HTML数据无效将导致页面加载失败。
参数：

data: ( String ) 必选 要加载的HTML数据

返回值：
void : 无
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null,embed=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    embed.show();
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 加载新HTML数据
function loadHtmlData() {
    embed.loadData( '<html><body>Hello! loadData!</body></html>' );
}
    </script>
    </head>
    <body>
        加载新HTML数据
        <button onclick="loadHtmlData()">loadData</button>
    </body>
</html>

loadURL

加载新URL页面

void wobj.loadURL( url );

说明：

触发Webview窗口从新的URL地址加载页面，如果url地址无效将导致页面显示失败。
参数：

url: ( String ) 必选 要加载的页面URL地址

返回值：
void : 无
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null,embed=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    embed.show();
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 加载新URL页面
function loadHtmlUrl() {
    embed.loadURL( 'http://m.csdn.net/' );
}
    </script>
    </head>
    <body>
        加载新URL页面
        <button onclick="loadHtmlUrl()">loadURL</button>
    </body>
</html>

nativeInstanceObject

获取Webview窗口对象的原生（Native.JS）实例对象

InstanceObject wobj.nativeInstanceObject();

说明：

Android平台返回Webview窗口对象的android.webkit.Webview实例对象， iOS平台返回Webview窗口对象的UIWebview实例对象。
参数：

无
返回值：
InstanceObject : Webview窗口对象的原生（Native.JS）实例对象。
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var nws=null;
// H5 plus事件处理
function plusReady(){
    // 获取当前Webview实例的原生（Native.JS）实例对象
    nws=plus.webview.currentWebview().nativeInstanceObject();
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
    </script>
    </head>
    <body>
        获取Webview窗口对象的原生（Native.JS）实例对象
    </body>
</html>

opened

获取在当前Webview窗口中创建的所有窗口

Array[WebviewObject] wobj.opened();

说明：

返回从当前Webview中调用plus.webview.open或plus.webview.create创建的所有Webview窗口数组。
参数：

无
返回值：
Array[ WebviewObject ] : 此窗口创建的Webview窗口对象数组，没有则返回空数组。
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null,embed=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    embed.show();
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 获取在当前Webview窗口中创建的所有窗口
function openedWebview() {
    var list=ws.opened();
    for(var i=0;i<list.length;i++){
        alert( "opened["+i+"]: "+list[i].getURL() );
    }
}
    </script>
    </head>
    <body>
        获取在当前Webview窗口中创建的所有窗口
        <button onclick="openedWebview()">opened</button>
    </body>
</html>

opener

获取当前Webview窗口的创建者

WebviewObject wobj.opener();

说明：

创建者为调用plus.webview.open或plus.webview.create方法创建当前窗口的Webview窗口。
参数：

无
返回值：
WebviewObject : 创建当前窗口的Webview窗口对象
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null,embed=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    embed.show();
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 取当前Webview窗口的创建者
function openerWebview() {
    var wo=embed.opener();
    alert( "opener: "+wo.getURL() );
}
    </script>
    </head>
    <body>
        获取当前Webview窗口的创建者
        <button onclick="openerWebview()">opener</button>
    </body>
</html>

overrideResourceRequest

拦截Webview窗口的资源加载

void wobj.overrideResourceRequest(options);

说明：

根据区配规则拦截Webview窗口加载资源的URL地址，重定向到其它资源地址（暂仅支持本地地址）。 注意：多次调用overrideResourceRequest时仅以最后一次调用设置的参数值生效。
参数：

options: ( Array[ WebviewOverridResourceOptions ] ) 可选 拦截URL资源加载的参数

返回值：
void : 无
平台支持：

Android - ALL (支持): 5+APP需要选择“解压资源后运行”模式后才能截获应用资源的URL请求。
iOS - ALL (不支持)

示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null,nw=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    // 拦截Webview窗口的资源请求
    nw=plus.webview.create("http://weibo.com/dhnetwork");
    nw.overrideResourceRequest([{match:"http://tva3.sinaimg.cn/crop.121.80.980.980.180/be8dcc14gw1e7lz65y6g3j20uo0uoq4r.jpg",redirect:"_www/logo.png"}]);
    nw.show();
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
    </script>
    </head>
    <body>
        拦截Webview窗口的资源加载
    </body>
</html>

overrideUrlLoading

拦截Webview窗口的URL请求

void wobj.overrideUrlLoading(options, callback);

说明：

拦截URL请求后，Webview窗口将不会跳转到新的URL地址，此时将通过callback回调方法返回拦截的URL地址（可新开Webview窗口加载URL页面等）。 此方法只能拦截窗口的网络超链接跳转（包括调用loadURL方法触发的跳转），不可拦截页面请求资源请求（如加载css/js/png等资源的请求）。 注意：多次调用overrideUrlLoading时仅以最后一次调用设置的参数值生效。
参数：

options: ( WebviewOverrideUrlOptions ) 可选 拦截URL请求的参数
callback: ( OverrideUrlLoadingCallback ) 可选 拦截URL请求的回调函数

返回值：
void : 无
平台支持：

Android - ALL (支持): 5+APP需要选择“解压资源后运行”模式后才能截获应用资源的URL请求。
iOS - ALL (支持)

示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null,nw=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    nw=plus.webview.create("http://weibo.com/dhnetwork");
    nw.show();
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 拦截Webview窗口的URL请求
function overrideUrl() {
    // 拦截所有页面跳转，可使用参数拦截weibo.com域名之外的跳转（{mode:"allow",match:".*weibo\.com/.*"}）
    nw.overrideUrlLoading({mode:"reject"}, function(e){
        console.log("reject url: "+e.url);
    });
}
    </script>
    </head>
    <body>
        拦截Webview窗口的URL请求
        <button onclick="overrideUrl()">overrideUrlLoading</button>
    </body>
</html>

parent

获取当前Webview窗口的父窗口

WebviewObject wobj.parent();

说明：

Webview窗口作为子窗口添加（Webview.append）到其它Webview窗口中时有效，这时其它Webview窗口为父窗口。
参数：

无
返回值：
WebviewObject : 父Webview窗口对象，没有则返回null。
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null,embed=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    ws.append(embed);
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 获取当前Webview窗口的父窗口
function parentWebview() {
    var wp=embed.parent();
    alert( "parent: "+wp.getURL() );
}
    </script>
    </head>
    <body>
        获取当前Webview窗口的父窗口
        <button onclick="parentWebview()">parent</button>
    </body>
</html>

reload

重新加载Webview窗口显示的HTML页面

void wobj.reload( force );

说明：

触发Webview窗口重新加载当前显示的页面内容。 如果当前HTML页面未加载完则停止并重新加载，如果当前Webview窗口没有加载任何页面则无响应。
参数：

force: ( Boolean ) 必选 是否强制不使用缓存
为加速HTML页面加载速度，默认在重新加载时会使用缓存，若force设置为true则不使用缓存，重新从URL地址加载所有页面内容。 

返回值：
void : 无
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null,embed=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    embed.show();
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 重新加载Webview窗口显示的HTML页面
function reloadWebview() {
    embed.reload(true);
}
    </script>
    </head>
    <body>
        重新加载Webview窗口显示的HTML页面
        <button onclick="reloadWebview()">reload</button>
    </body>
</html>

resetBounce

重置Webview窗口的回弹位置

void wobj.resetBounce();

说明：

开启窗口回弹效果后，当窗口中展现的内容滚动到头（顶部或底部）时，再拖拽时窗口整体内容将跟随移动，松开后自动回弹到停靠位置。 这时需要调用此方法来重置窗口的回弹位置，窗口将采用动画方式回弹到其初始显示的位置。
参数：

无
返回值：
void : 无
平台支持：

Android - 2.2+ (支持)
iOS - ALL (不支持)

示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    ws.setBounce({position:{top:"100px"},changeoffset:{top:"44px"}});
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 重置窗口回弹位置
function resetBounce(){
    ws.resetBounce();
}
    </script>
    </head>
    <body style="text-align:center;">
        <br/><br/><br/>
        设置Webview窗口的回弹效果<br/>
        回弹后显示停靠到44px的位置<br/><br/>
        <button onclick="resetBounce()">重置回弹位置</button>
        <br/><br/><br/>
        *暂仅支持顶部的回弹效果*
    </body>
</html>

remove

移除子Webview窗口

void wobj.remove( webview );

说明：

从当前Webview窗口移除指定的子Webview窗口，若指定的webview对象不是当前窗口的子窗口则无任何作用。 移除后子Webview窗口不会关闭，需要调用其close方法才能真正关闭并销毁。
参数：

webview: ( plus.nativeObj.View | WebviewObject ) 必选 要移除的Webview窗口

返回值：
void : 无
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null,embed=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    ws.append(embed);
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 移除子Webview窗口
function removeWebview() {
    ws.remove(embed);
    embed.close();
}
    </script>
    </head>
    <body>
        移除子Webview窗口
        <button onclick="removeWebview()">remove</button>
    </body>
</html>

removeEventListener

移除Webview窗口事件监听器

void wobj.removeEventListener( event, listener );

说明：

从Webview窗口移除通过addEventListener方法添加的事件监听器，若没有查找到对应的事件监听器，则无任何作用。
参数：

event: ( NWindowEvent ) 必选 要移除的事件类型
listener: ( EventCallback ) 必选 要移除监听函数对象

返回值：
void : 无
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null,embed=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    embed.addEventListener( "loaded", embedLoaded, false );
    ws.append(embed);
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 页面跳转监听器
function embedLoaded(e){
    alert( "Loaded: "+embed.getURL() );
}
// 移除Webview窗口事件监听器
function removeEvent() {
    embed.removeEventListener( "loaded", embedLoaded );
}
    </script>
    </head>
    <body>
        移除Webview窗口事件监听器
        <button onclick="removeEvent()">removeEventListener</button>
    </body>
</html>

removeFromParent

从父窗口中移除

void wobj.removeFromParent();

说明：

从所属的父Webview窗口移除，如果没有父窗口，则无任何作用。 从父窗口中移除后子Webview窗口不会关闭，需要调用其close方法才能真正关闭并销毁。
参数：

无
返回值：
void : 无
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null,embed=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    ws.append(embed);
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 从父窗口中移除
function removeFromeWebview() {
    embed.removeFromParent();
    embed.close();
}
    </script>
    </head>
    <body>
        从父窗口中移除
        <button onclick="removeFromeWebview()">removeFromParent</button>
    </body>
</html>

setBounce

设置Webview窗口的回弹效果

void wobj.setBounce( style );

说明：

开启窗口回弹效果后，当窗口中展现的内容滚动到头（顶部或底部）时，再拖拽时窗口整体内容将跟随移动，松开后自动回弹到停靠位置（可通过style设置）。 拖拽窗口内容时页面显示Webview窗口的背景色，默认为透明，此时显示Webview下面的内容，利用这个特点可以实现自定下拉刷新特效。
参数：

style: ( WebviewBounceStyle ) 必选 Webview窗口回弹样式参数
可设置窗口的回弹效果支持的方向，自动回弹后停靠的位置等参数。 

返回值：
void : 无
平台支持：

Android - 2.2+ (支持)
iOS - ALL (不支持)

示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    ws.setBounce({position:{top:"100px"},changeoffset:{top:"0px"}});
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
    </script>
    </head>
    <body style="text-align:center;">
        <br/><br/><br/>
        设置Webview窗口的回弹效果<br/><br/><br/>
        *暂仅支持顶部的回弹效果*
    </body>
</html>

setBlockNetworkImage

设置Webview窗口是否阻塞加载页面中使用的网络图片

void wobj.setBlockNetworkImage( block );

参数：

block: ( Boolean ) 必选 是否阻塞加载网络图片
true表示不加载页面中使用的网络图片，false表示加载也页面中使用的网络图片。 

返回值：
void : 无
平台支持：

Android - 2.2+ (支持)
iOS - ALL (不支持)

示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null;
// H5 plus事件处理
function plusReady(){
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
function blockOpen(){
    // 阻塞网络图片模式打开页面
    var w=plus.webview.create("http://m.csdn.net/","csdn",{blockNetworkImage:true});
    w.addEventListener("loaded",function(){
        w.show("slide-in-right",300);
        // 加载网络图片
        w.setBlockNetworkImage(false);
    },false);
}
    </script>
    </head>
    <body>
        显示窗口后再加载网络图片<br/>
        <button onclick="blockOpen()">打开页面</button>
    </body>
</html>

setContentVisible

设置HTML内容是否可见

void wobj.setContentVisible( visible );

说明：

设置HTML内容不可见后，将显示Webview窗口的背景色。
参数：

visible: ( Boolean ) 必选 设置页面是否可见，true表示可见，false表示不可见

返回值：
void : 无
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null,embed=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    ws.append(embed);
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 设置HTML内容是否可见
function setContentVisible(v) {
    embed.setContentVisible(v);
}
    </script>
    </head>
    <body>
        设置HTML内容是否可见
        <button onclick="setContentVisible(true)">可见</button>
        <button onclick="setContentVisible(false)">不可见</button>
    </body>
</html>

setPullToRefresh

设置Webview窗口的下拉刷新效果

void wobj.setPullToRefresh( style, refreshCB );

说明：

开启Webview窗口的下拉刷新功能，显示窗口内置的下拉刷新控件样式。
参数：

style: ( WebviewRefreshStyle ) 必选 Webview窗口下拉刷新样式参数
可设置窗口内置的下拉刷新控件在各种状态显示的文字内容。
refreshCB: ( SuccessCallback ) 必选 Webview窗口下拉刷新事件回调
用户操作窗口的下拉刷新触发窗口刷新事件时触发。

返回值：
void : 无
平台支持：

Android - 2.2+ (支持)
iOS - ALL (支持)

示例：

<!DOCTYPE HTML>
<html>
    <head>
        <meta charset="utf-8"/>
        <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, user-scalable=no"/>
        <meta name="HandheldFriendly" content="true"/>
        <meta name="MobileOptimized" content="320"/>
        <title>Webview Example</title>
        <script type="text/javascript" charset="utf-8">
var ws=null;
var list=null;
// 扩展API加载完毕，现在可以正常调用扩展API 
function plusReady(){
    ws=plus.webview.currentWebview();
    ws.setPullToRefresh({support:true,
        height:"50px",
        range:"200px",
        contentdown:{
            caption:"下拉可以刷新"
        },
        contentover:{
            caption:"释放立即刷新"
        },
        contentrefresh:{
            caption:"正在刷新..."
        }
    },onRefresh);
    plus.nativeUI.toast("下拉可以刷新");
}
// 判断扩展API是否准备，否则监听"plusready"事件
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// DOM构建完成获取列表元素
document.addEventListener("DOMContentLoaded",function(){
    list=document.getElementById("list");
})
// 刷新页面
function onRefresh(){
    setTimeout(function(){
        if(list){
            var item=document.createElement("li");
            item.innerHTML="<span>New Item "+(new Date())+"</span>";
            list.insertBefore(item,list.firstChild);
        }
        ws.endPullToRefresh();
    },2000);
}
        </script>
        <link rel="stylesheet" href="../css/common.css" type="text/css" charset="utf-8"/>
        <style type="text/css">
li {
    padding: 1em;
    border-bottom: 1px solid #eaeaea;
}
li:active {
    background: #f4f4f4;
}
        </style>
    </head>
    <body>
        <ul id="list" style="list-style:none;margin:0;padding:0;">
            <li><span>Initializ List Item 1</span></li>
            <li><span>Initializ List Item 2</span></li>
            <li><span>Initializ List Item 3</span></li>
            <li><span>Initializ List Item 4</span></li>
            <li><span>Initializ List Item 5</span></li>
            <li><span>Initializ List Item 6</span></li>
            <li><span>Initializ List Item 7</span></li>
            <li><span>Initializ List Item 8</span></li>
            <li><span>Initializ List Item 9</span></li>
            <li><span>Initializ List Item 10</span></li>
        </ul>
    </body>
</html>

setStyle

设置Webview窗口的样式

void wobj.setStyle( styles );

说明：

更新Webview窗口的样式，如窗口位置、大小、背景色等。
参数：

styles: ( WebviewStyles ) 必选 要设置的窗口样式

返回值：
void : 无
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null,embed=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    ws.append(embed);
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 设置Webview窗口的样式
function updateStyle() {
    embed.setStyle( {top:"92px"} );
}
    </script>
    </head>
    <body>
        设置Webview窗口的样式
        <button onclick="updateStyle()">setStyle</button>
    </body>
</html>

setJsFile

设置预加载的JS文件

void wobj.setJsFile( path );

说明：

预加载JS文件不需要在HTML页面中显式引用，在Webview窗口加载HTML页面时自动加载，在页面跳转时也会自动加载。 设置新的JS文件后将清空之前设置的值。
参数：

file: ( String ) 必选 预载入的JS文件地址，仅支持本地文件，格式为相对路径URL（plus.io.RelativeURL），如"_www/preload.js"

返回值：
void : 无
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null,embed=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    embed.setJsFile( "_www/js/preload.js" );
    ws.append(embed);
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
    </script>
    </head>
    <body>
        设置预加载的JS文件
    </body>
</html>

show

显示Webview窗口

void wobj.show( aniShow, duration, showedCB, extras );

说明：

当调用plus.webview.create方法创建Webview窗口后，需要调用其show方法才能显示，并可设置窗口显示动画及动画时间。 Webview窗口被隐藏后也可调用此方法来重新显示。
参数：

aniShow: ( AnimationTypeShow ) 可选 Webview窗口显示动画类型
如果没有指定窗口动画类型，则使用默认值“none”，即无动画。
duration: ( Number ) 可选 Webview窗口显示动画持续时间
单位为ms，默认使用动画类型想对应的默认时间。
showedCB: ( SuccessCallback ) 可选 Webview窗口显示完成的回调函数
当指定Webview窗口显示动画执行完毕时触发回调函数，窗口无动画效果（如"none"动画效果）时也会触发此回调。
extras: ( WebviewExtraOptions ) 可选 显示Webview窗口扩展参数
可用于指定Webview窗口动画是否使用图片加速。

返回值：
void : 无
示例：

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Webview Example</title>
<script type="text/javascript">
var ws=null,embed=null;
// H5 plus事件处理
function plusReady(){
ws=plus.webview.currentWebview();
}
if(window.plus){
plusReady();
}else{
document.addEventListener("plusready",plusReady,false);
}
// 创建并显示Webview窗口
function showWebview(){
embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
embed.show( "slide-in-right", 300 );
}
</script>
</head>
<body>
显示Webview窗口
<button onclick="showWebview()">show</button>
</body>
</html>

stop

停止加载HTML页面内容

void wobj.stop();

说明：

触发Webview窗口停止加载页面内容，如果已经加载部分内容则显示部分内容，如果加载完成则显示全部内容。
参数：

无
返回值：
void : 无
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null,embed=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    ws.append(embed);
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 停止加载HTML页面内容
function stopWebview(){
    embed.stop();
}
    </script>
    </head>
    <body>
        停止加载HTML页面内容
        <button onclick="stopWebview()">stop</button>
    </body>
</html>

onclose

Webview窗口关闭事件
说明：

EventCallback 类型

当Webview窗口关闭时触发此事件，类型为EventCallback。
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null,embed=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    embed.onclose=embedClose;
    ws.append(embed);
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 页面关闭事件回调函数
function embedClose(e){
    alert( "Closed!" );
}
    </script>
    </head>
    <body>
        Webview窗口关闭事件
        <button onclick="embed.close()">onclose</button>
    </body>
</html>

onerror

Webview窗口错误事件
说明：

WebviewEvent 类型

当Webview窗口加载错误时触发此事件，类型为EventCallback。
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null,embed=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    embed.onerror=embedError;
    ws.append(embed);
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 页面错误事件回调函数
function embedError(e){
    alert( "Error!" );
}
    </script>
    </head>
    <body>
        Webview窗口错误事件
        <button onclick="embed.loadData('<xml>Not html</xml>')">onerror</button>
    </body>
</html>

onloaded

Webview窗口页面加载完成事件
说明：

WebviewEvent 类型

当Webview窗口页面加载完成时触发此事件，类型为EventCallback。
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null,embed=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    embed.onloaded=embedLoaded;
    ws.append(embed);
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 页面加载完成事件回调函数
function embedLoaded(e){
    alert( "Loaded!" );
}
    </script>
    </head>
    <body>
        Webview窗口页面加载完成事件
        <button onclick="embed.loadURL('http://m.csdn.net')">onloaded</button>
    </body>
</html>

onloading

Webview窗口页面开始加载事件
说明：

WebviewEvent 类型

当Webview窗口开始加载新页面时触发此事件，类型为EventCallback。
示例：

<!DOCTYPE html>
<html>
    <head>
    <meta charset="utf-8">
    <title>Webview Example</title>
    <script type="text/javascript">
var ws=null,embed=null;
// H5 plus事件处理
function plusReady(){
    ws=plus.webview.currentWebview();
    embed=plus.webview.create("http://weibo.com/dhnetwork","",{top:"46px",bottom:"0px"});
    embed.onloading=embedLoading;
    ws.append(embed);
}
if(window.plus){
    plusReady();
}else{
    document.addEventListener("plusready",plusReady,false);
}
// 页面开始加载事件回调函数
function embedLoading(e){
    alert( "Loading!" );
}
    </script>
    </head>
    <body>
        Webview窗口页面开始加载事件
        <button onclick="embed.loadURL('http://m.csdn.net')">onloading</button>
    </body>
</html>