Service

Service属于Android的四大组件(只要是安卓四大组件就必须在AndroidMainFest中进行注册才可以使用),Service运行不赖于界面，即使退出应用，Service也将运行在后台中。服务在创建后，默认运行在主线程中，所以我们需要自己去开辟子线程，如果不开辟就有可能出现主线程被阻塞。

Android多线程

对于很多耗时操作(比如:发起网络请求，由于网络很慢，服务器不一定立刻响应)，我们一般把操作放在子线程中进行。

线程基本用法

• 定义一个线程需要继承Thread类，重写run()方法:

  class XXThread extends Thread {
    @Override
    public void run() {
        // 处理具体的逻辑
    }
}  

启动该线程:

    new XXThread().start();

• 使用Runable接口方法来定义一个线程

    class XXThread implements Runnable{

        @Override
        public void run() {

        }
}

启动该线程

    XXThread mThread = new XXThread();
    new Thread(mThread).start();

• 使用匿名类的方法

        new Thread(new Runnable() {
            @Override
            public void run() {
                // 处理具体的逻辑
            }
        }).start();

异步消息处理机制

我们是不能在子线程中更新UI中的内容，但是有时候我们却需要把子线程的内容更新到UI，Android提供一套异步消息处理机制来解决这个问题。

从图中可以发现，异步消息处理有4部分，分别是Message，Handle，MessageQuery，Looper四部分组成。在线程中我们调用 hanler.setMessage() 方法来发送消息给 MessageQuery，然后通过 Looper 来取出带处理消息，并且传回给 handler，然后调用在 UI 中的 handler.handleMessage() 方法来实现对 UI中的内容更新。

代码示例

TEXT_UPDATE自己定义的一个常量

• UI线程中的代码

    private Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what) {
                case TEXT_UPDATE:
                    tvShow.setText("你改变了TextView的内容");
                    break;
                default:
                    break;
            }
        }
    };

• 子线程中的代码

    @Override
    public void onClick(View v) {

        switch (v.getId()) {
            case R.id.btnUpdate:
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        Message message = new Message();
                        message.what = TEXT_UPDATE;
                        handler.sendMessage(message);
                    }
                }).start();
                break;
            default:
                break;
        }
    }

Service应用

前面讨论这么多关于多线程编程的问题都为在Service的使用上做准备的。先讨论最简单的基本用法

基本用法

Service和Activity一样都拥有 onCreate()，onDestroy()方法,来实现Service的创建和销毁。当然他们也有区别，在Service中我们必须实现 onBind() 方法，该方法用于与UI绑定(先不讨论)。在Service还有一个方法叫 onStartCommand()，这个方法和 onCreate() 区别是:onStartCommand()每次Service启动(包括第一次创建)都会启动这个方法，但是onCreate()只会在第一次创建的时候启动，之后不会再启动该方法

代码示例

• 创建一个Service

public class TestService extends Service {
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public void onCreate() {
        super.onCreate();
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }
}

• 启动一个Service

    Intent startIntent = new Intent(this, TestService.class);
    startService(startIntent);

• 停止一个Service
  停止Service需要注意，如果Service不仅被创建了，而且被绑定了，那么如果要停止这个Service，就需要同时执行 stopService() 和 unbindService()，才可以停止Service。

    Intent stopIntent = new Intent(this, TestService.class);
    stopService(stopIntent);

将Service绑定到UI中

如果要将Service绑定到UI中去，必须在 onBind() 方法中传回一个对象，使得UI可以操作Service中的方法，这个对象就好比一座桥梁连接着UI和Service。

代码示例

• 创建一个Biner对象，来实现Service中的公共方法

   private DownloadBinder mBinder = new DownloadBinder();

    class DownloadBinder extends Binder {

        public void startDownload() {
            Log.e(TAG, "开始下载");
        }

        public int getProgress() {
            Log.e(TAG, "获取进度表");
            return 0;
        }

        public void stopDownload() {
            Log.e(TAG, "停止下载");
        }
    }

• 桥梁的建立

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        //返回一个连接通道给service
        return mBinder;
    }

到此UI还没有和Service建立真正的桥梁，在UI中必须调用 bindService() 方法来绑定服务，在使用此方法之前，我们还需要 ServiceConnection的实现，来建立UI与Ser的连接。ServiceConnection 中有两个方法需要实现分别是 onServiceConnected() 和 onServiceDisconnected()，前者在调用bindService() 来建立连接的时候，会去调用此方法，但是在解除绑定的时候，却不会调用onServiceDisconnected(),只要发生系统意外的时候，才会调用此方法。我们在onServiceConnected()中来调用Service中的公共方法

• ServiceConnection的实现

    private ServiceConnection connection = new ServiceConnection() {

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {

            downloadBinder = (TestService.DownloadBinder) service;
            downloadBinder.startDownload();
            downloadBinder.getProgress();
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            //系统发生意外中断的时候才会调用此方法
            //客户端取消绑定的时候不会调用
        }
    };

到此我们还是不能调用Service中的方法，因为我们还没有使用onServiceConnected()来绑定。BIND_AUTO_CREATE 代表自动完成绑定。

• 桥梁的完成

    Intent bindIntent = new Intent(this, TestService.class);
    bindService(bindIntent, connection, BIND_AUTO_CREATE);

到此我们就可以任意调用Service中的公共方法了

• 桥梁的爆破
  解除绑定是非常简单的，只需要调用 unbindService() 方法,需要注意的是:如果已经解除绑定了，再次调用会报错

    unbindService(connection);

到这我们就已经学习了Service的创建、删除、绑定、取消绑定。但是这些都是在UI主线程中进行，就像我们前面提到如果遇到了耗时任务，将会被阻塞。所以我们要使用多线程技术。

IntendService的应用

IntendService的使用，可以使得开发者不必去停止服务，系统会在请求结束后自动停止服务。我们只需要在 onHandleIntent() 来完成UI所提出的任务即可，不过我们还需要为IntendService提供一个构造函数

代码示例

public class IntentServiceDemo extends IntentService {
    private static final String TAG_INTENT_SERVICE = "IntentService";

    public IntentServiceDemo() {
        super("IntentServiceDemo");
    }


    @Override
    protected void onHandleIntent(Intent intent) {
        Log.e(TAG_INTENT_SERVICE, "线程id是:" + Thread.currentThread().getId());
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.e(TAG_INTENT_SERVICE,"服务已经被销毁");
    }
}

启动IntendService

     Log.e("MainActivity", "线程id:" + Thread.currentThread().getId());
     Intent intentService = new Intent(this, IntentServiceDemo.class);
     startService(intentService);

这样Service就运行在子线程中。当然我们也可以不使用IntendService来实现，我们可以自己在 onStartCommand() 方法中，开启一个子线程。但是这样开启一个子线程将永远在执行，所以我们必须在任务完成后，调用 stopSelf() 或者 stopService()方法来关闭。

代码示例

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {

        new Thread(new Runnable() {
            @Override
            public void run() {   
               Log.e(TAG,"每次服务被创建");
                stopSelf();
            }
        }).start();

        return super.onStartCommand(intent, flags, startId);
    }

前台Service

应用场景，如果一个天气app，当后台数据更新后，会一直在前台显示更新后的数据情况。这就可以使用前台Service来实现。要在前台一直显示数据，这有点类似于Notification，当时我们不使用NotificationManger来显示出来，而是使用 startForeground()来实现。要注意 startForeground() 方法中的第一个参数id，不能使用0作为id。

代码示例

    @Override
    public void onCreate() {
        super.onCreate();
        //  Log.e(TAG, "服务被创建");
        //前台服务
        NotificationCompat.Builder builder = new NotificationCompat.Builder(this);

        Intent notificationIntent = new Intent(this, MainActivity.class);
        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notificationIntent, 0);

        builder.setContentTitle("通知");
        builder.setContentText("吃饭了么");
        builder.setContentIntent(pendingIntent);
        builder.setSmallIcon(R.drawable.ic_launcher);
        builder.setDefaults(Notification.DEFAULT_ALL);
        builder.setAutoCancel(true);

        startForeground(1, builder.build());
    }

后台定时执行任务

通过AlarmManager(在这不多说)来实现定时功能，同样首先我们通过 getSystemService()方法获得系统服务。然后通过set() 方法来定时唤醒 PendingIntent.getBroadcast()* 方法来发送一个广播，然后再广播内启动Service。整个流程如下图

代码示例

• Service

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {

        new Thread(new Runnable() {
            @Override
            public void run() {
                Log.e(TAG, "执行时间:" + new Date().toString());
            }
        }).start();

        AlarmManager manager = (AlarmManager) getSystemService(ALARM_SERVICE);
        int aSecond = 60 * 1000;//1分钟
        long triggerAtTime = SystemClock.elapsedRealtime() + aSecond;
        Intent i = new Intent(this, AlarmReceiver.class);
        PendingIntent pendingIntent = PendingIntent.getBroadcast(this, 0, i, 0);
        manager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, triggerAtTime, pendingIntent);
        //Log.e(TAG,"每次服务被创建");
        return super.onStartCommand(intent, flags, startId);
    }

• Broadcoast

public class AlarmReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        Log.e("AlarmReceiver", "接收到了");
        Intent i = new Intent(context, ServiceDemo.class);
        context.startService(i);
    }
}

最后还是感谢《第一行代码》的作者，郭神，文中很多都是来自于这本书。

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <color name="white">#FFFFFF</color> <!--白色 -->
    <color name="ivory">#FFFFF0</color> <!--象牙色 -->
    <color name="lightyellow">#FFFFE0</color> <!--亮黄色 -->
    <color name="yellow">#FFFF00</color> <!--黄色 -->
    <color name="snow">#FFFAFA</color> <!--雪白色 -->
    <color name="floralwhite">#FFFAF0</color> <!--花白色 -->
    <color name="lemonchiffon">#FFFACD</color> <!--柠檬绸色 -->
    <color name="cornsilk">#FFF8DC</color> <!--米绸色 -->
    <color name="seashell">#FFF5EE</color> <!--海贝色 -->
    <color name="lavenderblush">#FFF0F5</color> <!--淡紫红 -->
    <color name="papayawhip">#FFEFD5</color> <!--番木色 -->
    <color name="blanchedalmond">#FFEBCD</color> <!--白杏色 -->
    <color name="mistyrose">#FFE4E1</color> <!--浅玫瑰色 -->
    <color name="bisque">#FFE4C4</color> <!--桔黄色 -->
    <color name="moccasin">#FFE4B5</color> <!--鹿皮色 -->
    <color name="navajowhite">#FFDEAD</color> <!--纳瓦白 -->
    <color name="peachpuff">#FFDAB9</color> <!--桃色 -->
    <color name="gold">#FFD700</color> <!--金色 -->
    <color name="pink">#FFC0CB</color> <!--粉红色 -->
    <color name="lightpink">#FFB6C1</color> <!--亮粉红色 -->
    <color name="orange">#FFA500</color> <!--橙色 -->
    <color name="lightsalmon">#FFA07A</color> <!--亮肉色 -->
    <color name="darkorange">#FF8C00</color> <!--暗桔黄色 -->
    <color name="coral">#FF7F50</color> <!--珊瑚色 -->
    <color name="hotpink">#FF69B4</color> <!--热粉红色 -->
    <color name="tomato">#FF6347</color> <!--西红柿色 -->
    <color name="orangered">#FF4500</color> <!--红橙色 -->
    <color name="deeppink">#FF1493</color> <!--深粉红色 -->
    <color name="fuchsia">#FF00FF</color> <!--紫红色 -->
    <color name="magenta">#FF00FF</color> <!--红紫色 -->
    <color name="red">#FF0000</color> <!--红色 -->
    <color name="oldlace">#FDF5E6</color> <!--老花色 -->
    <color name="lightgoldenrodyellow">#FAFAD2</color> <!--亮金黄色 -->
    <color name="linen">#FAF0E6</color> <!--亚麻色 -->
    <color name="antiquewhite">#FAEBD7</color> <!--古董白 -->
    <color name="salmon">#FA8072</color> <!--鲜肉色 -->
    <color name="ghostwhite">#F8F8FF</color> <!--幽灵白 -->
    <color name="mintcream">#F5FFFA</color> <!--薄荷色 -->
    <color name="whitesmoke">#F5F5F5</color> <!--烟白色 -->
    <color name="beige">#F5F5DC</color> <!--米色 -->
    <color name="wheat">#F5DEB3</color> <!--浅黄色 -->
    <color name="sandybrown">#F4A460</color> <!--沙褐色 -->
    <color name="azure">#F0FFFF</color> <!--天蓝色 -->
    <color name="honeydew">#F0FFF0</color> <!--蜜色 -->
    <color name="aliceblue">#F0F8FF</color> <!--艾利斯兰 -->
    <color name="khaki">#F0E68C</color> <!--黄褐色 -->
    <color name="lightcoral">#F08080</color> <!--亮珊瑚色 -->
    <color name="palegoldenrod">#EEE8AA</color> <!--苍麒麟色 -->
    <color name="violet">#EE82EE</color> <!--紫罗兰色 -->
    <color name="darksalmon">#E9967A</color> <!--暗肉色 -->
    <color name="lavender">#E6E6FA</color> <!--淡紫色 -->
    <color name="lightcyan">#E0FFFF</color> <!--亮青色 -->
    <color name="burlywood">#DEB887</color> <!--实木色 -->
    <color name="plum">#DDA0DD</color> <!--洋李色 -->
    <color name="gainsboro">#DCDCDC</color> <!--淡灰色 -->
    <color name="crimson">#DC143C</color> <!--暗深红色 -->
    <color name="palevioletred">#DB7093</color> <!--苍紫罗兰色 -->
    <color name="goldenrod">#DAA520</color> <!--金麒麟色 -->
    <color name="orchid">#DA70D6</color> <!--淡紫色 -->
    <color name="thistle">#D8BFD8</color> <!--蓟色 -->
    <color name="lightgray">#D3D3D3</color> <!--亮灰色 -->
    <color name="lightgrey">#D3D3D3</color> <!--亮灰色 -->
    <color name="tan">#D2B48C</color> <!--茶色 -->
    <color name="chocolate">#D2691E</color> <!--巧可力色 -->
    <color name="peru">#CD853F</color> <!--秘鲁色 -->
    <color name="indianred">#CD5C5C</color> <!--印第安红 -->
    <color name="mediumvioletred">#C71585</color> <!--中紫罗兰色 -->
    <color name="silver">#C0C0C0</color> <!--银色 -->
    <color name="darkkhaki">#BDB76B</color> <!--暗黄褐色-->
    <color name="rosybrown">#BC8F8F</color> <!--褐玫瑰红 -->
    <color name="mediumorchid">#BA55D3</color> <!--中粉紫色 -->
    <color name="darkgoldenrod">#B8860B</color> <!--暗金黄色 -->
    <color name="firebrick">#B22222</color> <!--火砖色 -->
    <color name="powderblue">#B0E0E6</color> <!--粉蓝色 -->
    <color name="lightsteelblue">#B0C4DE</color> <!--亮钢兰色-->
    <color name="paleturquoise">#AFEEEE</color> <!--苍宝石绿 -->
    <color name="greenyellow">#ADFF2F</color> <!--黄绿色 -->
    <color name="lightblue">#ADD8E6</color> <!--亮蓝色 -->
    <color name="darkgray">#A9A9A9</color> <!--暗灰色 -->
    <color name="darkgrey">#A9A9A9</color> <!--暗灰色 -->
    <color name="brown">#A52A2A</color> <!--褐色 -->
    <color name="sienna">#A0522D</color> <!--赭色 -->
    <color name="darkorchid">#9932CC</color> <!--暗紫色 -->
    <color name="palegreen">#98FB98</color> <!--苍绿色 -->
    <color name="darkviolet">#9400D3</color> <!--暗紫罗兰色 -->
    <color name="mediumpurple">#9370DB</color> <!--中紫色 -->
    <color name="lightgreen">#90EE90</color> <!--亮绿色 -->
    <color name="darkseagreen">#8FBC8F</color> <!--暗海兰色 -->
    <color name="saddlebrown">#8B4513</color> <!--重褐色 -->
    <color name="darkmagenta">#8B008B</color> <!--暗洋红 -->
    <color name="darkred">#8B0000</color> <!--暗红色 -->
    <color name="blueviolet">#8A2BE2</color> <!--紫罗兰蓝色 -->
    <color name="lightskyblue">#87CEFA</color> <!--亮天蓝色 -->
    <color name="skyblue">#87CEEB</color> <!--天蓝色 -->
    <color name="gray">#808080</color> <!--灰色 -->
    <color name="grey">#808080</color> <!--灰色 -->
    <color name="olive">#808000</color> <!--橄榄色 -->
    <color name="purple">#800080</color> <!--紫色 -->
    <color name="maroon">#800000</color> <!--粟色 -->
    <color name="aquamarine">#7FFFD4</color> <!--碧绿色 -->
    <color name="chartreuse">#7FFF00</color> <!--黄绿色 -->
    <color name="lawngreen">#7CFC00</color> <!--草绿色 -->
    <color name="mediumslateblue">#7B68EE</color> <!--中暗蓝色 -->
    <color name="lightslategray">#778899</color> <!--亮蓝灰 -->
    <color name="lightslategrey">#778899</color> <!--亮蓝灰 -->
    <color name="slategray">#708090</color> <!--灰石色 -->
    <color name="slategrey">#708090</color> <!--灰石色 -->
    <color name="olivedrab">#6B8E23</color> <!--深绿褐色 -->
    <color name="slateblue">#6A5ACD</color> <!--石蓝色 -->
    <color name="dimgray">#696969</color> <!--暗灰色 -->
    <color name="dimgrey">#696969</color> <!--暗灰色 -->
    <color name="mediumaquamarine">#66CDAA</color> <!--中绿色 -->
    <color name="cornflowerblue">#6495ED</color> <!--菊兰色 -->
    <color name="cadetblue">#5F9EA0</color> <!--军兰色 -->
    <color name="darkolivegreen">#556B2F</color> <!--暗橄榄绿-->
    <color name="indigo">#4B0082</color> <!--靛青色 -->
    <color name="mediumturquoise">#48D1CC</color> <!--中绿宝石 -->
    <color name="darkslateblue">#483D8B</color> <!--暗灰蓝色 -->
    <color name="steelblue">#4682B4</color> <!--钢兰色 -->
    <color name="royalblue">#4169E1</color> <!--皇家蓝 -->
    <color name="turquoise">#40E0D0</color> <!--青绿色 -->
    <color name="mediumseagreen">#3CB371</color> <!--中海蓝 -->
    <color name="limegreen">#32CD32</color> <!--橙绿色 -->
    <color name="darkslategray">#2F4F4F</color> <!--暗瓦灰色 -->
    <color name="darkslategrey">#2F4F4F</color> <!--暗瓦灰色 -->
    <color name="seagreen">#2E8B57</color> <!--海绿色 -->
    <color name="forestgreen">#228B22</color> <!--森林绿 -->
    <color name="lightseagreen">#20B2AA</color> <!--亮海蓝色 -->
    <color name="dodgerblue">#1E90FF</color> <!--闪兰色 -->
    <color name="midnightblue">#191970</color> <!--中灰兰色 -->
    <color name="aqua">#00FFFF</color> <!--浅绿色 -->
    <color name="cyan">#00FFFF</color> <!--青色 -->
    <color name="springgreen">#00FF7F</color> <!--春绿色 -->
    <color name="lime">#00FF00</color> <!--酸橙色 -->
    <color name="mediumspringgreen">#00FA9A</color> <!--中春绿色 -->
    <color name="darkturquoise">#00CED1</color> <!--暗宝石绿 -->
    <color name="deepskyblue">#00BFFF</color> <!--深天蓝色 -->
    <color name="darkcyan">#008B8B</color> <!--暗青色 -->
    <color name="teal">#008080</color> <!--水鸭色 -->
    <color name="green">#008000</color> <!--绿色 -->
    <color name="darkgreen">#006400</color> <!--暗绿色 -->
    <color name="blue">#0000FF</color> <!--蓝色 -->
    <color name="mediumblue">#0000CD</color> <!--中兰色 -->
    <color name="darkblue">#00008B</color> <!--暗蓝色 -->
    <color name="navy">#000080</color> <!--海军色 -->
    <color name="black">#000000</color> <!--黑色 -->

</resources>

应用基础知识

<?xml version="1.0" encoding="utf-8"?>
<manifest ... >
    <application android:icon="@drawable/app_icon.png" ... >
        <activity android:name="com.example.project.ExampleActivity"
                  android:label="@string/example_label" ... >
        </activity>
        ...
    </application>
</manifest>

<manifest ... >
    ...
    <application ... >
        <activity android:name="com.example.project.ComposeEmailActivity">
            <intent-filter>
                <action android:name="android.intent.action.SEND" />
                <data android:type="*/*" />
                <category android:name="android.intent.category.DEFAULT" />
            </intent-filter>
        </activity>
    </application>
</manifest>

<manifest ... >
    <uses-feature android:name="android.hardware.camera.any"
                  android:required="true" />
    <uses-sdk android:minSdkVersion="7" android:targetSdkVersion="19" />
    ...
</manifest>

转载本文请注明出处：http://blog.csdn.net/qq_32059827/article/details/52203347   点击打开链接

在自定义进度条之前，先来学习一下shape的用法。

一、在res目录下边新建一个drawble目录（如果您会自定义状态选择器的话，这将很简单）

二、新建一个android.xml文件，找到shape，点击finish

我们可以看到shape属性并不多，截图如下：

现在逐步介绍常用的属性用法：

1、<corners />表示  “角”，表示圆角

   （1）、radius　：　表示半径android:radius="5dip"代表，指定圆角半径为5dip

2、<gradient />  ：表示颜色渐变。放射性改变

测试上边两个属性特征：

在drawable/shapetest.xml代码如下：

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

    <corners android:radius="5dip" >
    </corners>

    <gradient
        android:endColor="#00ff00"
        android:startColor="#ff0000" />

</shape>

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity" >

    <TextView
        android:textSize="22sp"
        android:background="@drawable/shapetest"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/hello_world" />

</RelativeLayout>

好了。接着看shape的后边的几个属性：

3、<padding />表示内间距，与布局文件中的padding效果一样，就不做介绍。

4、<size />同上，可以直接在布局文件设置

5、<solid />固定颜色，设置这个原色后，放射颜色就不起作用

6、<stoke />改组件加边框线，看一下设置这个属性后，变为什么样子：

<stroke android:width="1dip"
        android:color="#0000ff"
        android:dashWidth="5dip"
        android:dashGap="5dip"/>

到这里shape的基本用法就介绍完了。学习完shape基本用法，在Android简易实战系列第十七话中，完成一个自定义彩色进度条的案例

Intent 和 Intent 过滤器

来源：Android Develop - API Guides - App Components - Intents and Intent Filters

Intent 是一个消息传递对象，您可以使用它从其他应用组件请求操作。尽管 Intent 可以通过多种方式促进组件之间的通信，但其基本用例主要包括以下三个：

• 启动 Activity：

  Activity 表示应用中的一个屏幕。通过将 Intent 传递给 startActivity()，您可以启动新的 Activity 实例。Intent 描述了要启动的 Activity，并携带了任何必要的数据。

  如果您希望在 Activity 完成后收到结果，请调用 startActivityForResult()。在 Activity 的onActivityResult() 回调中，您的 Activity 将结果作为单独的 Intent 对象接收。如需了解详细信息，请参阅Activity指南。

• 启动服务：

  Service 是一个不使用用户界面而在后台执行操作的组件。通过将 Intent 传递给 startService()，您可以启动服务执行一次性操作（例如，下载文件）。Intent 描述了要启动的服务，并携带了任何必要的数据。

  如果服务旨在使用客户端-服务器接口，则通过将 Intent 传递给 bindService()，您可以从其他组件绑定到此服务。如需了解详细信息，请参阅服务指南。

• 传递广播：

  广播是任何应用均可接收的消息。系统将针对系统事件（例如：系统启动或设备开始充电时）传递各种广播。通过将 Intent 传递给 sendBroadcast()、sendOrderedBroadcast() 或 sendStickyBroadcast()，您可以将广播传递给其他应用。

Intent 类型

Intent 分为两种类型：

• 显式 Intent ：按名称（完全限定类名）指定要启动的组件。通常，您会在自己的应用中使用显式 Intent 来启动组件，这是因为您知道要启动的 Activity 或服务的类名。例如，启动新 Activity 以响应用户操作，或者启动服务以在后台下载文件。
• 隐式 Intent ：不会指定特定的组件，而是声明要执行的常规操作，从而允许其他应用中的组件来处理它。例如，如需在地图上向用户显示位置，则可以使用隐式 Intent，请求另一具有此功能的应用在地图上显示指定的位置。

创建显式 Intent 启动 Activity 或服务时，系统将立即启动 Intent 对象中指定的应用组件。

图 1. 隐式 Intent 如何通过系统传递以启动其他 Activity 的图解：[1] Activity A 创建包含操作描述的 Intent，并将其传递给 startActivity()。[2] Android 系统搜索所有应用中与 Intent 匹配的 Intent 过滤器。找到匹配项之后，[3] 该系统通过调用匹配 Activity（Activity B）的 onCreate() 方法并将其传递给Intent，以此启动匹配 Activity。

创建隐式 Intent 时，Android 系统通过将 Intent 的内容与在设备上其他应用的清单文件中声明的 Intent 过滤器进行比较，从而找到要启动的相应组件。Intent如果 Intent 与 Intent 过滤器匹配，则系统将启动该组件，并将其传递给对象。如果多个 Intent 过滤器兼容，则系统会显示一个对话框，支持用户选取要使用的应用。

Intent 过滤器是应用清单文件中的一个表达式，它指定该组件要接收的 Intent 类型。例如，通过为 Activity 声明 Intent 过滤器，您可以使其他应用能够直接使用某一特定类型的 Intent 启动 Activity。同样，如果您没有为 Activity 声明任何 Intent 过滤器，则 Activity 只能通过显式 Intent 启动。

警告：为了确保应用的安全性，启动 Service 时，请始终使用显式 Intent，且不要为服务声明 Intent 过滤器。使用隐式 Intent 启动服务存在安全隐患，因为您无法确定哪些服务将响应 Intent，且用户无法看到哪些服务已启动。从 Android 5.0（API 级别 21）开始，如果使用隐式 Intent 调用 bindService()，系统会抛出异常。

构建 Intent

Intent 对象携带了 Android 系统用来确定要启动哪个组件的信息（例如，准确的组件名称或应当接收该 Intent 的组件类别），以及收件人组件为了正确执行操作而使用的信息（例如，要采取的操作以及要处理的数据）。

Intent 中包含的主要信息如下：

组件名称

要启动的组件名称。

这是可选项，但也是构建显式 Intent 的一项重要信息，这意味着 Intent 应当仅传递给由组件名称定义的应用组件。如果没有组件名称，则 Intent 是隐式的，且系统将根据其他 Intent 信息（例如，以下所述的操作、数据和类别）决定哪个组件应当接收 Intent。因此，如需在应用中启动特定的组件，则应指定该组件的名称。

注意：启动 Service 时，您应 始终指定组件名称。否则，您无法确定哪项服务会响应 Intent，且用户无法看到哪项服务已启动。

Intent 的这一字段是 ComponentName 对象，您可以使用目标组件的完全限定类名指定此对象，其中包括应用的软件包名称。例如，com.example.ExampleActivity。您可以使用 setComponent()、setClass()、setClassName() 或 Intent 构造函数设置组件名称。

操作

指定要执行的通用操作（例如，“查看”或“选取”）的字符串。

对于广播 Intent，这是指已发生且正在报告的操作。操作在很大程度上决定了其余 Intent 的构成，特别是数据和 extra 中包含的内容。

您可以指定自己的操作，供 Intent 在您的应用内使用（或者供其他应用在您的应用中调用组件）。但是，您通常应该使用由 Intent 类或其他框架类定义的操作常量。以下是一些用于启动 Activity 的常见操作：

ACTION_VIEW

如果您拥有一些某项 Activity 可向用户显示的信息（例如，要使用图库应用查看的照片；或者要使用地图应用查找的地址），请使用 Intent 将此操作与 startActivity() 结合使用。

ACTION_SEND

这也称为“共享” Intent。如果您拥有一些用户可通过其他应用（例如，电子邮件应用或社交共享应用）共享的数据，则应使用 Intent 中将此操作与 startActivity() 结合使用。

有关更多定义通用操作的常量，请参阅Intent类引用。 其他操作在 Android 框架中的其他位置定义。例如，对于在系统的设置应用中打开特定屏幕的操作，将在 Settings 中定义。

您可以使用 setAction() 或 Intent 构造函数为 Intent 指定操作。

如果定义自己的操作，请确保将应用的软件包名称作为前缀。 例如：

static final String ACTION_TIMETRAVEL = "com.example.action.TIMETRAVEL";

数据

引用待操作数据和/或该数据 MIME 类型的 URI（Uri 对象）。提供的数据类型通常由 Intent 的操作决定。例如，如果操作是 ACTION_EDIT，则数据应包含待编辑文档的 URI。

创建 Intent 时，除了指定 URI 以外，指定数据类型（其 MIME 类型）往往也很重要。例如，能够显示图像的Activity可能无法播放音频文件，即便 URI 格式十分类似时也是如此。因此，指定数据的 MIME 类型有助于 Android 系统找到接收 Intent 的最佳组件。但有时，MIME 类型可以从 URI 中推断得出，特别当数据是 content: URI 时尤其如此。这表明数据位于设备中，且由 ContentProvider 控制，这使得数据 MIME 类型对系统可见。

要仅设置数据 URI，请调用 setData()。要仅设置 MIME 类型，请调用 setType()。如有必要，您可以使用 setDataAndType() 同时显式设置二者。

警告：若要同时设置 URI 和 MIME 类型，请勿调用 setData() 和 setType()，因为它们会互相抵消彼此的值。请始终使用 setDataAndType()同时设置 URI 和 MIME 类型。

类别

一个包含应处理 Intent 组件类型的附加信息的字符串。您可以将任意数量的类别描述放入一个 Intent 中，但大多数 Intent 均不需要类别。以下是一些常见类别：

CATEGORY_BROWSABLE

目标 Activity 允许本身通过 Web 浏览器启动，以显示链接引用的数据，如图像或电子邮件。

CATEGORY_LAUNCHER

该 Activity 是任务的初始 Activity，在系统的应用启动器中列出。

有关类别的完整列表，请参阅 Intent 类描述。

您可以使用 addCategory() 指定类别。

以上列出的这些属性（组件名称、操作、数据和类别）表示 Intent 的既定特征。通过读取这些属性，Android 系统能够解析应当启动哪个应用组件。

但是，Intent 也有可能会一些携带不影响其如何解析为应用组件的信息。Intent 还可以提供：

Extra

携带完成请求操作所需的附加信息的键值对。正如某些操作使用特定类型的数据 URI 一样，有些操作也使用特定的附加数据。

您可以使用各种 putExtra() 方法添加附加数据，每种方法均接受两个参数：键名和值。您还可以创建一个包含所有附加数据的 Bundle 对象，然后使用 putExtras() 将 Bundle 插入 Intent 中。

例如，使用 ACTION_SEND 创建用于发送电子邮件的 Intent 时，可以使用 EXTRA_EMAIL 键指定“目标”收件人，并使用 EXTRA_SUBJECT 键指定“主题”。

Intent 类将为标准化的数据类型指定多个 EXTRA_* 常量。如需声明自己的附加数据 键（对于应用接收的 Intent ），请确保将应用的软件包名称作为前缀。例如：

static final String EXTRA_GIGAWATTS = "com.example.EXTRA_GIGAWATTS";

标志

在 Intent 类中定义的、充当 Intent 元数据的标志。标志可以指示 Android 系统如何启动 Activity（例如，Activity 应属于哪个 任务 ），以及启动之后如何处理（例如，它是否属于最近的 Activity 列表）。

如需了解详细信息，请参阅 setFlags() 方法。

显式 Intent 示例

显式 Intent 是指用于启动某个特定应用组件（例如，应用中的某个特定 Activity 或服务）的 Intent。要创建显式 Intent，请为 Intent 对象定义组件名称。Intent 的所有其他属性均为可选属性。

例如，如果在应用中构建了一个名为 DownloadService、旨在从 Web 中下载文件的服务，则可使用以下代码启动该服务：

// Executed in an Activity, so 'this' is the Context
// The fileUrl is a string URL, such as "http://www.example.com/image.png"
Intent downloadIntent = new Intent(this, DownloadService.class);
downloadIntent.setData(Uri.parse(fileUrl));
startService(downloadIntent);

Intent(Context, Class) 构造函数分别为应用和组件提供 Context 和 Class 对象。因此，此 Intent 将显式启动该应用中的 DownloadService 类。

如需了解有关构建和启动服务的详细信息，请参阅服务指南。

隐式 Intent 示例

隐式 Intent 指定能够在可以执行相应操作的设备上调用任何应用的操作。如果您的应用无法执行该操作而其他应用可以，且您希望用户选取要使用的应用，则使用隐式 Intent 非常有用。

例如，如果您希望用户与他人共享您的内容，请使用 ACTION_SEND 操作创建 Intent，并添加指定共享内容的 Extra。使用该 Intent 调用 startActivity()时，用户可以选取共享内容所使用的应用。

警告：用户可能没有任何应用处理您发送到 startActivity() 的隐式 Intent。如果出现这种情况，则调用将会失败，且应用会崩溃。要验证 Activity 是否会接收 Intent，请对 Intent 对象调用 resolveActivity()。如果结果为非空，则至少有一个应用能够处理该 Intent，且可以安全调用startActivity()。如果结果为空，则不应使用该 Intent。如有可能，您应禁用发出该 Intent 的功能。

// Create the text message with a string
Intent sendIntent = new Intent();
sendIntent.setAction(Intent.ACTION_SEND);
sendIntent.putExtra(Intent.EXTRA_TEXT, textMessage);
sendIntent.setType("text/plain");

// Verify that the intent will resolve to an activity
if (sendIntent.resolveActivity(getPackageManager()) != null) {
    startActivity(sendIntent);
}

注意：在这种情况下，系统并没有使用 URI，但已声明 Intent 的数据类型，用于指定 Extra 携带的内容。

调用 startActivity() 时，系统将检查已安装的所有应用，确定哪些应用能够处理这种 Intent（即：含 ACTION_SEND 操作并携带“文本/纯”数据的 Intent ）。如果只有一个应用能够处理，则该应用将立即打开并提供给 Intent。如果多个 Activity 接受 Intent，则系统将显示一个对话框，使用户能够选取要使用的应用。

图 2. 选择器对话框。

强制使用应用选择器

如果有多个应用响应隐式 Intent，则用户可以选择要使用的应用，并将其设置为该操作的默认选项。 如果用户可能希望今后一直使用相同的应用执行某项操作（例如，打开网页时，用户往往倾向于仅使用一种 Web 浏览器），则这一点十分有用。

但是，如果多个应用可以响应 Intent，且用户可能希望每次使用不同的应用，则应采用显式方式显示选择器对话框。选择器对话框要求用户选择每次操作要使用的应用（用户无法为该操作选择默认应用）。 例如，当应用使用ACTION_SEND 操作执行“共享”时，用户根据目前的状况可能需要使用另一不同的应用，因此应当始终使用选择器对话框，如图 2 中所示。

要显示选择器，请使用 createChooser() 创建 Intent，并将其传递给 startActivity()。例如：

Intent sendIntent = new Intent(Intent.ACTION_SEND);
...

// Always use string resources for UI text.
// This says something like "Share this photo with"
String title = getResources().getString(R.string.chooser_title);
// Create intent to show the chooser dialog
Intent chooser = Intent.createChooser(sendIntent, title);

// Verify the original intent will resolve to at least one activity
if (sendIntent.resolveActivity(getPackageManager()) != null) {
    startActivity(chooser);
}

这将显示一个对话框，其中包含响应传递给 createChooser() 方法的 Intent 的应用列表，并使用提供的文本作为对话框标题。

接收隐式 Intent

要公布应用可以接收哪些隐式 Intent，请在清单文件中使用 <intent-filter> 元素为每个应用组件声明一个或多个 Intent 过滤器。每个 Intent 过滤器均根据 Intent 的操作、数据和类别指定自身接受的 Intent 类型。仅当隐式 Intent 可以通过 Intent 过滤器之一传递时，系统才会将该 Intent 传递给应用组件。

注意：显式 Intent 始终会传递给其目标，无论组件声明的 Intent 过滤器如何均是如此。

应用组件应当为自身可执行的每个独特作业声明单独的过滤器。例如，图像库应用中的一个 Activity 可能会有两个过滤器，分别用于查看图像和编辑图像。 当 Activity 启动时，它将检查 Intent 并根据 Intent 中的信息决定具体的行为（例如，是否显示编辑器控件）。

每个 Intent 过滤器均由应用清单文件中的 <intent-filter> 元素定义，并嵌套在相应的应用组件（例如，<activity> 元素）中。在<intent-filter> 内部，您可以使用以下三个元素中的一个或多个指定要接受的 Intent 类型：

<action>

在 name 属性中，声明接受的 Intent 操作。该值必须是操作的文本字符串值，而不是类常量。

<data>

使用一个或多个指定 数据 URI（scheme、host、port、path 等）各个方面和 MIME 类型的属性，声明接受的数据类型。

<category>

在 name 属性中，声明接受的 Intent 类别。该值必须是操作的文本字符串值，而不是类常量。

注意：为了接收隐式 Intent，必须将 CATEGORY_DEFAULT 类别包括在 Intent 过滤器中。方法 startActivity() 和 startActivityForResult()将按照已申明 CATEGORY_DEFAULT 类别的方式处理所有 Intent。 如果未在 Intent 过滤器中声明此类别，则隐式 Intent 不会解析为您的 Activity。

例如，以下是一个使用 Intent 过滤器进行的 Activity 声明，当数据类型为文本时，系统将接收 ACTION_SEND Intent ：

<activity android:name="ShareActivity">
    <intent-filter>
        <action android:name="android.intent.action.SEND"/>
        <category android:name="android.intent.category.DEFAULT"/>
        <data android:mimeType="text/plain"/>
    </intent-filter>
</activity>

您可以创建一个包括多个 <action>、<data> 或 <category> 实例的过滤器。创建时，仅需确定组件能够处理这些过滤器元素的任何及所有组合即可。

如需仅以操作、数据和类别类型的特定组合来处理多种 Intent，则需创建多个 Intent 过滤器。

系统通过将 Intent 与所有这三个元素进行比较，根据过滤器测试隐式 Intent。隐式 Intent 若要传递给组件，必须通过所有这三项测试。如果 Intent 甚至无法匹配其中任何一项测试，则 Android 系统不会将其传递给组件。但是，由于一个组件可能有多个 Intent 过滤器，因此未能通过某一组件过滤器的 Intent 可能会通过另一过滤器。如需了解有关系统如何解析 Intent 的详细信息，请参阅下文的 Intent 解析部分。

警告：为了避免无意中运行不同应用的 Service，请始终使用显式 Intent 启动您自己的服务，且不必为该服务声明 Intent 过滤器。

注意： 对于所有 Activity，您必须在清单文件中声明 Intent 过滤器。但是，广播接收器的过滤器可以通过调用 registerReceiver() 动态注册。稍后，您可以使用 unregisterReceiver() 注销该接收器。这样一来，应用便可仅在应用运行时的某一指定时间段内侦听特定的广播。

过滤器示例

为了更好地了解一些 Intent 过滤器的行为，我们一起来看看从社交共享应用的清单文件中截取的以下片段。

<activity android:name="MainActivity">
    <!-- This activity is the main entry, should appear in app launcher -->
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

<activity android:name="ShareActivity">
    <!-- This activity handles "SEND" actions with text data -->
    <intent-filter>
        <action android:name="android.intent.action.SEND"/>
        <category android:name="android.intent.category.DEFAULT"/>
        <data android:mimeType="text/plain"/>
    </intent-filter>
    <!-- This activity also handles "SEND" and "SEND_MULTIPLE" with media data -->
    <intent-filter>
        <action android:name="android.intent.action.SEND"/>
        <action android:name="android.intent.action.SEND_MULTIPLE"/>
        <category android:name="android.intent.category.DEFAULT"/>
        <data android:mimeType="application/vnd.google.panorama360+jpg"/>
        <data android:mimeType="image/*"/>
        <data android:mimeType="video/*"/>
    </intent-filter>
</activity>

第一个 Activity MainActivity 是应用的主要入口点。当用户最初使用启动器图标启动应用时，该 Activity 将打开：

• ACTION_MAIN 操作指示这是主要入口点，且不要求输入任何 Intent 数据。
• CATEGORY_LAUNCHER 类别指示此 Activity 的图标应放入系统的应用启动器。如果 <activity> 元素未使用 icon 指定图标，则系统将使用<application> 元素中的图标。

这两个元素必须配对使用，Activity 才会显示在应用启动器中。

第二个 Activity ShareActivity 旨在便于共享文本和媒体内容。尽管用户可以通过从 MainActivity 导航进入此 Activity，但也可以从发出隐式 Intent（与两个 Intent 过滤器之一匹配）的另一应用中直接进入 ShareActivity。

注意：MIME 类型 application/vnd.google.panorama360+jpg 是一个指定全景照片的特殊 数据类型，您可以使用 Google 全景 API 对其进行处理。

使用待定 Intent

PendingIntent 对象是 Intent 对象的包装器。PendingIntent 的主要目的是授权外部应用使用包含的 Intent，就像是它从您应用本身的进程中执行的一样。

待定 Intent 的主要用例包括：

• 声明用户使用您的通知执行操作时所要执行的 Intent（Android 系统的 NotificationManager 执行 Intent）。
• 声明用户使用您的 应用小工具执行操作时要执行的 Intent（主屏幕应用执行 Intent）。
• 声明未来某一特定时间要执行的 Intent（Android 系统的 AlarmManager 执行 Intent）。

由于每个 Intent 对象均设计为由特定类型的应用组件进行处理（Activity、Service 或 BroadcastReceiver），因此还必须基于相同的考虑因素创建PendingIntent。使用待定 Intent 时，应用不会使用调用（如 startActivity()）执行该 Intent。相反，通过调用相应的创建器方法创建 PendingIntent时，您必须声明所需的组件类型：

• PendingIntent.getActivity()，适用于启动 Activity 的 Intent。
• PendingIntent.getService()，适用于启动 Service 的 Intent。
• PendingIntent.getBroadcast()，适用于启动 BroadcastReceiver 的 Intent。

除非您的应用正在从其他应用中接收待定 Intent，否则上述用于创建 PendingIntent 的方法可能是您所需的唯一 PendingIntent 方法。

每种方法均会提取当前的应用 Context、您要包装的 Intent 以及一个或多个指定应如何使用该 Intent 的标志（例如，是否可以多次使用该 Intent）。

如需了解有关使用待定 Intent 的详细信息，请参阅通知 和应用小工具 API 指南等手册中每个相应用例的相关文档。

Intent 解析

当系统收到隐式 Intent 以启动 Activity 时，它根据以下三个方面将该 Intent 与 Intent 过滤器进行比较，搜索该 Intent 的最佳 Activity：

• Intent 操作
• Intent 数据（URI 和数据类型）
• Intent 类别

下文根据如何在应用的清单文件中声明 Intent 过滤器，描述 Intent 如何与相应的组件匹配。

操作测试

要指定接受的 Intent 操作， Intent 过滤器既可以不声明任何 <action> 元素，也可以声明多个此类元素。例如：

<intent-filter>
    <action android:name="android.intent.action.EDIT" />
    <action android:name="android.intent.action.VIEW" />
    ...
</intent-filter>

要通过此过滤器，您在 Intent 中指定的操作必须与过滤器中列出的某一操作匹配。

如果该过滤器未列出任何操作，则 Intent 没有任何匹配项，因此所有 Intent 均无法通过测试。但是，如果 Intent 未指定操作，则会通过测试（只要过滤器至少包含一个操作）。

类别测试

要指定接受的 Intent 类别， Intent 过滤器既可以不声明任何 <category> 元素，也可以声明多个此类元素。例如：

<intent-filter>
    <category android:name="android.intent.category.DEFAULT" />
    <category android:name="android.intent.category.BROWSABLE" />
    ...
</intent-filter>

若要 Intent 通过类别测试，则 Intent 中的每个类别均必须与过滤器中的类别匹配。反之则未必然，Intent 过滤器声明的类别可以超出 Intent 中指定的数量，且 Intent 仍会通过测试。因此，不含类别的 Intent 应当始终会通过此测试，无论过滤器中声明何种类别均是如此。

注意： Android 会自动将 CATEGORY_DEFAULT 类别应用于传递给 startActivity() 和 startActivityForResult() 的所有隐式 Intent。因此，如需 Activity 接收隐式 Intent，则必须将 "android.intent.category.DEFAULT" 的类别包括在其 Intent 过滤器中（如上文的 <intent-filter> 示例所示）。

数据测试

要指定接受的 Intent 数据， Intent 过滤器既可以不声明任何 <data> 元素，也可以声明多个此类元素。例如：

<intent-filter>
    <data android:mimeType="video/mpeg" android:scheme="http" ... />
    <data android:mimeType="audio/mpeg" android:scheme="http" ... />
    ...
</intent-filter>

每个 <data> 元素均可指定 URI 结构和数据类型（MIME 介质类型）。URI 的每个部分均包含单独的 scheme、host、port 和 path 属性：

<scheme>://<host>:<port>/<path>

例如：

content://com.example.project:200/folder/subfolder/etc

在此 URI 中，架构是 content，主机是 com.example.project，端口是 200，路径是 folder/subfolder/etc。

在 <data> 元素中，上述每个属性均为可选，但存在线性依赖关系：

• 如果未指定架构，则会忽略主机。
• 如果未指定主机，则会忽略端口。
• 如果未指定架构和主机，则会忽略路径。

将 Intent 中的 URI 与过滤器中的 URI 规范进行比较时，它仅与过滤器中包含的部分 URI 进行比较。例如：

• 如果过滤器仅指定架构，则具有该架构的所有 URI 均与该过滤器匹配。
• 如果过滤器指定架构和权限、但未指定路径，则具有相同架构和权限的所有 URI 都会通过过滤器，无论其路径如何均是如此。
• 如果过滤器指定架构、权限和路径，则仅具有相同架构、权限和路径 的 URI 才会通过过滤器。

注意：路径规范可以包含星号通配符 (*)，因此仅需部分匹配路径名即可。

数据测试会将 Intent 中的 URI 和 MIME 类型与过滤器中指定的 URI 和 MIME 类型进行比较。规则如下：

1. 仅当过滤器未指定任何 URI 或 MIME 类型时，不含 URI 和 MIME 类型的 Intent 才会通过测试。
2. 对于包含 URI、但不含 MIME 类型（既未显式声明，也无法通过 URI 推断得出）的 Intent，仅当其 URI 与过滤器的 URI 格式匹配、且过滤器同样未指定 MIME 类型时，才会通过测试。
3. 仅当过滤器列出相同的 MIME 类型且未指定 URI 格式时，包含 MIME 类型、但不含 URI 的 Intent 才会通过测试。
4. 仅当 MIME 类型与过滤器中列出的类型匹配时，包含 URI 和 MIME 类型（通过显式声明，或可以通过 URI 推断得出）的 Intent 才会通过测试的 MIME 类型部分。如果 Intent 的 URI 与过滤器中的 URI 匹配，或者如果 Intent 具有 content: 或 file: URI 且过滤器未指定 URI，则 Intent 会通过测试的 URI 部分。换而言之，如果过滤器仅列出 MIME 类型，则假定组件支持 content: 和 file: 数据。

最后一条规则，即规则 (d)，反映了期望组件能够从文件中或内容提供商处获得本地数据。因此，其过滤器可以仅列出数据类型，而不必显式命名content: 和 file: 架构。这是一个典型的案例。例如，下文中的 <data> 元素向 Android 指出，组件可从内容提供商处获得并显示图像数据：

<intent-filter>
    <data android:mimeType="image/*" />
    ...
</intent-filter>

由于大部分可用数据均由内容提供商分发，因此指定数据类型（而非 URI）的过滤器也许最为常见。

另一常见的配置是具有架构和数据类型的过滤器。例如，下文中的 <data> 元素向 Android 指出，组件可从网络中检索视频数据以执行操作：

<intent-filter>
    <data android:scheme="http" android:type="video/*" />
    ...
</intent-filter>

Intent 匹配

通过 Intent 过滤器匹配 Intent，这不仅有助于发现要激活的目标组件，还有助于发现设备上组件集的相关信息。例如，主页应用通过使用指定ACTION_MAIN 操作和 CATEGORY_LAUNCHER 类别的 Intent 过滤器查找所有 Activity，以此填充应用启动器。

您的应用可以采用类似的方式使用 Intent 匹配。PackageManager 提供了一整套 query...() 方法来返回所有能够接受特定 Intent 的组件。此外，它还提供了一系列类似的 resolve...() 方法来确定响应 Intent 的最佳组件。例如，queryIntentActivities() 将返回能够执行那些作为参数传递的 Intent 的所有 Activity 列表，而 queryIntentServices() 则可返回类似的服务列表。这两种方法均不会激活组件，而只是列出能够响应的组件。对于广播接收器，有一种类似的方法： queryBroadcastReceivers()。

如何选择数据存储

来源：Android Develop - API Guides - Data Storage - Storage Options

Android给提供了几种应用数据持久化的选择，如何选择数据存储的解决方案要根据我们的特殊需要，比如根据数据是应该对应用私有还是数据可以让其他应用（或用户）获取，以及数据需要多大的空间来存储。

数据存储的解决方案有如下几种：

Shared Preferences

以键值对的形式存储私有的、简单的数据。

Internal Storage

在设备内部存储中存储私有数据。

External Storage

在共享的外部存储中存储公共数据。

SQLite Databases

在私有的数据库中存储结构化的数据。

Network Connection

用我们自己的网络服务器在网络中存储数据。

Android提供了一种将数据暴露给其他应用的方式 — 使用content provider。 Content provider 是可选的组件，它可以暴露应用数据的 读/写 使用权限， 并且可以在数据的使用上添加我们需要的任何限制条件。 您可以在Content Providers开发者指南中了解有关它的更多详情。

Shared Preference 应用

SharedPreferences 类提供了一套框架，我们可以用其存储以及恢复的私有的、持久化的、键值对类型的数据。我们可以使用 SharedPreferences 来存储任何类型的私有数据： boolean、float、int、long、string。数据会在用户活动时会持久存在 (即便应用被kill掉)。

以下是为应用获得 SharedPreferences 的两种方法：

• getSharedPreferences() - 如果需要用到多个preferences使用这个方法，第一个参数为用来标识不同preferences的名字。（这里的preferences属于应用程序）
• getPreferences() - 如果你的Activity只需要使用一个preference则调用这个方法来获取，因为这个preferences是你的Activity的唯一一个，不需要提供名字来获取。

写入数据：

1. 调用 SharedPreferences的 edit() 方法来获取 SharedPreferences.Editor。
2. 使用 putBoolean() 或者 putString()等等类似的方法来添加数据。
3. 使用 commit()方法来提交新添加的数据。

读取数据：使用SharedPreferences 的 getBoolean() 以及getString()等等类似的方法来获取数据。

以下为在计算器应用中使用preferences存取静音按键模式设置的例子：

public class Calc extends Activity {
    public static final String PREFS_NAME = "MyPrefsFile";

    @Override
    protected void onCreate(Bundle state){
       super.onCreate(state);
       . . .

       // Restore preferences
       SharedPreferences settings = getSharedPreferences(PREFS_NAME, 0);
       boolean silent = settings.getBoolean("silentMode", false);
       setSilent(silent);
    }

    @Override
    protected void onStop(){
       super.onStop();

      // We need an Editor object to make preference changes.
      // All objects are from android.context.Context
      SharedPreferences settings = getSharedPreferences(PREFS_NAME, 0);
      SharedPreferences.Editor editor = settings.edit();
      editor.putBoolean("silentMode", mSilentMode);

      // Commit the edits!
      editor.commit();
    }
}

Internal Storage 使用

我们可以将文件直接存到 internal storage 中。 缺省情况下，存到internal storage中的文件对我们的应用是私有的，其他应用（以及用户）都没有办法获取它们。当用户卸载我们的应用时，这些文件也会被移除。 

在 internal storage 中创建文件并写入数据：

1. 调用 openFileOutput() 方法并传入文件名以及操作模式两个参数以获取到 FileOutputStream。
2. 调用 write()方法来将数据写入文件。
3. 使用 close()方法来关闭stream。

例:

String FILENAME = "hello_file";
String string = "hello world!";

FileOutputStream fos = openFileOutput(FILENAME, Context.MODE_PRIVATE);
fos.write(string.getBytes());
fos.close();

MODE_PRIVATE 会创建一个文件 (或者替换一个同名文件) 并使其对应用私有。 其他操作模式有： MODE_APPEND,MODE_WORLD_READABLE, and MODE_WORLD_WRITEABLE.

注意:  MODE_WORLD_READABLE 和MODE_WORLD_WRITEABLE 在 API level 17之后已经过时。 Android N 版本开始，使用它们的话会抛出 SecurityException 异常. 这意味着应用的目标版本如果为 Android N 或者更高的话，则不可以通过文件名来共享私有文件，并且尝试共享像这样的"file://" URI 也会导致 FileUriExposedException 异常被抛出。如果你的应用需要和其他应用共享私有文件，需要使用 FileProvider 并传入 FLAG_GRANT_READ_URI_PERMISSION。具体请看 Android Develop - Training - Building Apps With Contents Sharing - Sharing Files。

从 internal storage中读文件：

1. 调用openFileInput()方法并传入文件名以返回FileInputStream。
2. 使用read()方法来读取bytes。
3. 使用close()方法来关闭stream。

注意: 如果你希望在应用中存储一个编译期的静态文件（即应用编译打包时不会对文件作任何处理），那么请将这个文件存到 res/raw/ 目录下。 你可以使用openRawResource()方法来打开它，同时需要传入类似 R.raw.<filename> 的资源 ID。这个方法会返回 InputStream ，你可以用它来读取文件 (但是不可以对原始的文件进行写操作)。

存储缓存文件

如果你想缓存一些数据而不想将其持久化存储，你应该调用getCacheDir() 来打开一个 File ，它是位于 internal storage 中的应用存储自身临时缓存文件的目录。

当设备的 internal storage 存储空间所剩不多时，Android 会删掉这些缓存来恢复存储空间。然而，你不应该依靠系统来为你清理这些文件。 你应该自行维护这些缓存文件，让其保持合理的空间消耗，比如1MB。当用户卸载了你的应用时，这些缓存文件也会被移除。

其他比较有用的方法

getFilesDir()

得到你的内部文件存储目录的绝对路径。

getDir()

在internal storage 空间中创建一个(或打开已经存在的) 目录。

deleteFile()

删除一个存储在internal storage 空间中的文件。

fileList()

返回现在存储在应用中的文件列表。

External Storage 使用

每个兼容Android系统的设备都支持一个共享的 external storage ，我们可以用它来存储文件。 它可以是可移动的存储媒介 (例如一个SD卡) ，或者位于 手机内部存储中(不可移动)。存储在 external storage 中的文件对所有应用都是可读的，并且当用户使用USB以文件传输模式将设备连接到电脑时。用户也可以去更改 external storage 中的文件。

提醒: 当用户将 external storage 挂载到电脑上或者移除了这些存储媒介时，external storage 会变得不可用，并且存储在 external storage 中的文件没有强制的安全措施来维护，所有应用都可以读写这些存储在 external storage 中的文件并且用户也可以删除它们。

获取 external storage

如果需要对 external storage 进行文件的读写操作，应用需要获取 READ_EXTERNAL_STORAGE 或者 WRITE_EXTERNAL_STORAGE 系统权限。例：

<manifest ...>
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    ...
</manifest>

如果你既要对文件进行读操作，又要进行写操作， 那你只要获取 WRITE_EXTERNAL_STORAGE 这一个权限，因为它也包含了对文件的读操作的权限。

注意: 自 Android 4.4开始， 如果你只是读写你的应用的私有文件，将不再需要获取这些权限，更多内容请看下面的 saving files that are app-private (存储应用私有的文件)这个章节。

检查存储媒介是否可用

在你对 external storage 进行任何操作之前，你应该先调用 getExternalStorageState() 这个方法来检查当前存储媒介是否可用。External storage 的存储可能被挂载到了电脑上、缺失、只读或者在其它状态下。下面是两个用于检查存储可用性的方法的例子：

/* 检查 external storage 是否可读写 */
public boolean isExternalStorageWritable() {
    String state = Environment.getExternalStorageState();
    if (Environment.MEDIA_MOUNTED.equals(state)) {
        return true;
    }
    return false;
}

/* 检查 external storage 是否为只读 */
public boolean isExternalStorageReadable() {
    String state = Environment.getExternalStorageState();
    if (Environment.MEDIA_MOUNTED.equals(state) ||
        Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)) {
        return true;
    }
    return false;
}

这个 getExternalStorageState() 方法也会返回其它你希望检查的状态，例如存储是否正在被共享（即挂载到了电脑上）、是否完全缺失、是否已经被移除，当你的应用需要获取而无法获取 external storage 时你可以去检查状态以用更多的信息来通知用户。

存储应用共享文件

通常用户通过应用获取的文件应该在设备上的公共的位置进行存储，其他的应用可以获取这些存储在公共的位置中的文件并且用户也可以轻易从设备上复制它们，当这样做的时候，你应该使用一个公共的文件目录，例如 Music/、Pictures/、Ringtones/。

调用 getExternalStoragePublicDirectory()来获取公共的文件目录 File ，方法中需要传入你想获取的文件目录类型例如 DIRECTORY_MUSIC, DIRECTORY_PICTURES,DIRECTORY_RINGTONES 或者其他的。通过将你的文件存储到与文件类型相一致的文件目录中，系统的 media 扫描可以合理的对你的文件进行分类 (例如，铃声文件在系统设置中会以铃声类型出现，而不是音乐类型)。

下面是一个在公共的图片目录中创建一个新的相册的方法的例子：

public File getAlbumStorageDir(String albumName) {
    // 获取用户放置公共图片的文件目录
    File file = new File(Environment.getExternalStoragePublicDirectory(
            Environment.DIRECTORY_PICTURES), albumName);
    if (!file.mkdirs()) {
        Log.e(LOG_TAG, "Directory not created");
    }
    return file;
}

存储应用私有的文件

如果你需要处理一些不希望被其他应用使用的文件 (例如仅仅在你的应用中使用的图形纹理或声音效果)，你应该调用 getExternalFilesDir()这个方法以使用在 external storage 中的私有文件目录，这个方法也需要一个 type 参数来指明子文件目录的类型 (例如 DIRECTORY_MOVIES)。如果你不需要一个特定的 media 目录，那么可以传入 null 来获取应用的私有文件目录的根目录。

自 Android 4.4 开始，在应用私有文件目录中读写文件不需要再获取 READ_EXTERNAL_STORAGE 或者 WRITE_EXTERNAL_STORAGE 权限。所以你可以通过加入maxSdkVersion 属性来为需要获取这两个权限的低版本来申请权限。

<manifest ...>
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"
                     android:maxSdkVersion="18" />
    ...
</manifest>

注意: 当用户删除了你的应用，这个私有文件目录里的所有的文件内容都会被删除，并且系统的 media 扫描不会来读取这个目录中的文件，所以这些文件不可以在 MediaStore content provider中获取到。同样地, 你 不应该使用这个私有文件目录 存储属于用户的 media 文件，例如应用拍摄或修改的照片以及用户购买的音乐等，这些应该被存储在公共的文件目录中，详细请看上面的 saved in the public directories (存储应用共享文件)章节。

有时候，设备会从手机内部存储中分配一个分区给 external storage 使用，或者也会给其提供一个SD卡卡槽。当设备在 Android 4.3 或更低的版本中运行时， 这个 getExternalFilesDir() 方法仅仅能够获取在手机内部存储中的 external storage ，应用没有办法通过这个方法来对SD卡进行读写操作。 然而自Android 4.4 开始，调用 getExternalFilesDirs()方法可以获取手机内部存储以及SD卡的 external storage 两个位置，其会返回一个 File数组来分别表示不同的存储位置。数组中的第一个值为首要的 external storage ，并且你不应该去使用这个位置，除非它满了或者不可用了。如果你希望在Android 4.3 或更低版本中获取也能够获取不同的存储位置，请使用 support library's 中的静态方法 ContextCompat.getExternalFilesDirs()。这个也可以返回一个 File 数组。但是在 Android 4.3 或者更低版本中，数组中通常只包含一个值。

提醒:尽管 getExternalFilesDir() 和getExternalFilesDirs() 返回的文件目录不可以被 MediaStore content provider获取，但其他应用如果获取了 READ_EXTERNAL_STORAGE 权限的话则可以取到所有 external storage 中的文件，包含这些 external storage 中私有文件目录中的文件。如果你需要完全限制其他应用对你的文件的获取，那你应该将文件存储在 internal storage 中而不是  external storage 中。

存储缓存文件

如果要打开在  external storage 中存储缓存文件的文件目录，请调用 getExternalCacheDir()方法 ，如果用户卸载了这个应用，这些缓存文件也会被删除。

类似上面提及的 ContextCompat.getExternalFilesDirs()方法，你也可以调用ContextCompat.getExternalCacheDirs()方法来获取多个 external storage （如果存在第二个 external storage ）中的缓存文件目录。

注意: 你需要谨慎的管理缓存文件并且通过应用的生命周期来移除那些不再需要用到的缓存文件，这对于维护文件空间以及应用性能而言非常重要。

Databases 使用

Android提供了对 SQLite 数据库的完整的支持。你创建的任何数据库都可以在应用中的任何类中通过数据库名称来获取到，但是其他应用不能获取。

创建一个新的 SQLite 数据库的推荐方法：创建 SQLiteOpenHelper 的子类并覆盖其 onCreate() 方法，在 onCreate() 方法中你可以执行 SQLite 命令以在数据库中创建表格，例：

public class DictionaryOpenHelper extends SQLiteOpenHelper {

    private static final int DATABASE_VERSION = 2;
    private static final String DICTIONARY_TABLE_NAME = "dictionary";
    private static final String DICTIONARY_TABLE_CREATE =
                "CREATE TABLE " + DICTIONARY_TABLE_NAME + " (" +
                KEY_WORD + " TEXT, " +
                KEY_DEFINITION + " TEXT);";

    DictionaryOpenHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL(DICTIONARY_TABLE_CREATE);
    }
}

之后你可以获取你自定义了构造器的 SQLiteOpenHelper 的实例，如果需要读写数据库，则需要分别调用getWritableDatabase() 和getReadableDatabase()方法，它们都会返回一个 SQLiteDatabase ，其代表数据库并提供了对 SQLite 数据库操作的方法。

你可以使用 SQLiteDatabase query() 方法来执行 SQLite 的查询，这个方法可以接受多个查询的参数，例如需要查询的表格、查询的行及其条件、查询的列、如何分组等等。更复杂的查询，比如需要列名称的别名等，你应该使用 SQLiteQueryBuilder，它提供了几个方便的方法来构建查询参数。

SQLite 查询会返回一个 Cursor，它指向了查询返回的所有行。 你可以使用这个 Cursor 来对数据库查询的结果进行操作，并且可以从中读取查询记录的行和列。

这是两个Android 使用 SQLite 数据库的demo， Note Pad ，Searchable Dictionary 。

数据库调试

Android SDK 包含一套 sqlite3 数据库工具，其可以让我们浏览数据库表格内容、执行SQL命令以及完成其他与 SQLite 数据库相关的功能。具体如何使用请查看 Examining sqlite3 databases from a remote shell 。（PS：就是adb里面那些对数据库操作的指令）

Network Connection 使用

你可以使用网络 (当其可用时)在网络服务器上存储和恢复数据，网络的操作需要用到下面两个包中的类：

• java.net.*
• android.net.*

由于ReactNative使用了NodeJS环境，以前没有系统学习过NodeJS，故花点时间学习下。了解ReactNative里关于NodeJS部分的知识。

我们先看看一个RN项目的目录，如下：

我们看到的node_modules 和package.json都是和NodeJS相关联的。 学习完这边文章你就能明白：

1、我们在调试时，使用的包服务器，启动命令：npm start ，是什么意思？

2、我们在down一个项目下来以后，为什么要执行下：npm install ?

3、我们如果管理我们的node资源包？包括下载、更新、发布。

模块

编写稍大一点的程序时一般都会将代码模块化。在NodeJS中，一般将代码合理拆分到不同的JS文件中，每一个文件就是一个模块，而文件路径就是模块名。

在编写每个模块时，都有require、exports、module三个预先定义好的变量可供使用。

require

require函数用于在当前模块中加载和使用别的模块，传入一个模块名，返回一个模块导出对象。模块名可使用相对路径（以./开头），或者是绝对路径（以/或C:之类的盘符开头）。另外，模块名中的.js扩展名可以省略。以下是一个例子。

var foo1 = require('./foo');
var foo2 = require('./foo.js');
var foo3 = require('/home/user/foo');
var foo4 = require('/home/user/foo.js');

// foo1至foo4中保存的是同一个模块的导出对象。

另外，可以使用以下方式加载和使用一个JSON文件，模块名中.json扩展名不可省略。

var data = require('./data.json');

exports

exports对象是当前模块的导出对象，用于导出模块公有方法和属性。别的模块通过require函数使用当前模块时得到的就是当前模块的exports对象。以下例子中导出了一个公有方法。

exports.hello = function () {
    console.log('Hello World!');
};

module

通过module对象可以访问到当前模块的一些相关信息，但最多的用途是替换当前模块的导出对象。例如模块导出对象默认是一个普通对象，如果想改成一个函数的话，可以使用以下方式。

module.exports = function () {
    console.log('Hello World!');
};

以上代码中，模块默认导出对象被替换为一个函数。

模块初始化

一个模块中的JS代码仅在模块第一次被使用时执行一次，并在执行过程中初始化模块的导出对象。之后，缓存起来的导出对象被重复利用。

主模块

通过命令行参数传递给NodeJS以启动程序的模块被称为主模块。主模块负责调度组成整个程序的其它模块完成工作。例如通过以下命令启动程序时，main.js就是主模块。

$ node main.js

完整示例

例如有以下目录。

- /home/user/hello/
    - util/
        counter.js
    main.js

其中counter.js内容如下：

var i = 0;

function count() {
    return ++i;
}

exports.count = count;

该模块内部定义了一个私有变量i，并在exports对象导出了一个公有方法count。

主模块main.js内容如下：

var counter1 = require('./util/counter');
var    counter2 = require('./util/counter');

console.log(counter1.count());
console.log(counter2.count());
console.log(counter2.count());

运行该程序的结果如下：

$ node main.js
1
2
3

可以看到，counter.js并没有因为被require了两次而初始化两次。

package.json

如果想自定义入口模块的文件名和存放位置，就需要在包目录下包含一个package.json文件，并在其中指定入口模块的路径。上例中的cat模块可以重构如下。

- /home/user/lib/
    - cat/
        + doc/
        - lib/
            head.js
            body.js
            main.js
        + tests/
        package.json

其中package.json内容如下。

{
    "name": "cat",
    "main": "./lib/main.js"
}

如此一来，就同样可以使用require('/home/user/lib/cat')的方式加载模块。NodeJS会根据包目录下的package.json找到入口模块所在位置。

NPM

NPM是随同NodeJS一起安装的包管理工具，能解决NodeJS代码部署上的很多问题，常见的使用场景有以下几种：

• 允许用户从NPM服务器下载别人编写的三方包到本地使用。

• 允许用户从NPM服务器下载并安装别人编写的命令行程序到本地使用。

• 允许用户将自己编写的包或命令行程序上传到NPM服务器供别人使用。

可以看到，NPM建立了一个NodeJS生态圈，NodeJS开发者和用户可以在里边互通有无。以下分别介绍这三种场景下怎样使用NPM。

下载三方包

需要使用三方包时，首先得知道有哪些包可用。虽然npmjs.org提供了个搜索框可以根据包名来搜索，但如果连想使用的三方包的名字都不确定的话，就请百度一下吧。知道了包名后，比如上边例子中的argv，就可以在工程目录下打开终端，使用以下命令来下载三方包。

$ npm install argv
...
argv@0.0.2 node_modules\argv

下载好之后，argv包就放在了工程目录下的node_modules目录中，因此在代码中只需要通过require('argv')的方式就好，无需指定三方包路径。

以上命令默认下载最新版三方包，如果想要下载指定版本的话，可以在包名后边加上@<version>，例如通过以下命令可下载0.0.1版的argv。

$ npm install argv@0.0.1
...
argv@0.0.1 node_modules\argv

如果使用到的三方包比较多，在终端下一个包一条命令地安装未免太人肉了。因此NPM对package.json的字段做了扩展，允许在其中申明三方包依赖。因此，上边例子中的package.json可以改写如下：

{
    "name": "node-echo",
    "main": "./lib/echo.js",
    "dependencies": {
        "argv": "0.0.2"
    }
}

这样处理后，在工程目录下就可以使用npm install命令批量安装三方包了。更重要的是，当以后node-echo也上传到了NPM服务器，别人下载这个包时，NPM会根据包中申明的三方包依赖自动下载进一步依赖的三方包。例如，使用npm install node-echo命令时，NPM会自动创建以下目录结构。

- project/
    - node_modules/
        - node-echo/
            - node_modules/
                + argv/
            ...
    ...

如此一来，用户只需关心自己直接使用的三方包，不需要自己去解决所有包的依赖关系。

安装命令行程序

从NPM服务上下载安装一个命令行程序的方法与三方包类似。例如上例中的node-echo提供了命令行使用方式，只要node-echo自己配置好了相关的package.json字段，对于用户而言，只需要使用以下命令安装程序。

$ npm install node-echo -g

参数中的-g表示全局安装，因此node-echo会默认安装到以下位置，并且NPM会自动创建好*nix系统下需要的软链文件或Windows系统下需要的.cmd文件。

- /usr/local/               # *nix系统下
    - lib/node_modules/
        + node-echo/
        ...
    - bin/
        node-echo
        ...
    ...

- %APPDATA%\npm\            # Windows系统下
    - node_modules\
        + node-echo\
        ...
    node-echo.cmd
    ...

发布代码

第一次使用NPM发布代码前需要注册一个账号。终端下运行npm adduser，之后按照提示做即可。账号搞定后，接着我们需要编辑package.json文件，加入NPM必需的字段。接着上边node-echo的例子，package.json里必要的字段如下。

{
    "name": "node-echo",           # 包名，在NPM服务器上须要保持唯一
    "version": "1.0.0",            # 当前版本号
    "dependencies": {              # 三方包依赖，需要指定包名和版本号
        "argv": "0.0.2"
      },
    "main": "./lib/echo.js",       # 入口模块位置
    "bin" : {
        "node-echo": "./bin/node-echo"      # 命令行程序名和主模块位置
    }
}

之后，我们就可以在package.json所在目录下运行npm publish发布代码了。

版本号

使用NPM下载和发布代码时都会接触到版本号。NPM使用语义版本号来管理代码，这里简单介绍一下。

语义版本号分为X.Y.Z三位，分别代表主版本号、次版本号和补丁版本号。当代码变更时，版本号按以下原则更新。

+ 如果只是修复bug，需要更新Z位。

+ 如果是新增了功能，但是向下兼容，需要更新Y位。

+ 如果有大变动，向下不兼容，需要更新X位。

版本号有了这个保证后，在申明三方包依赖时，除了可依赖于一个固定版本号外，还可依赖于某个范围的版本号。例如"argv": "0.0.x"表示依赖于0.0.x系列的最新版argv。NPM支持的所有版本号范围指定方式可以查看官方文档。

灵机一点

除了本章介绍的部分外，NPM还提供了很多功能，package.json里也有很多其它有用的字段。除了可以在npmjs.org/doc/查看官方文档外，这里再介绍一些NPM常用命令。

• NPM提供了很多命令，例如install和publish，使用npm help可查看所有命令。

• 使用npm help <command>可查看某条命令的详细帮助，例如npm help install。

• 在package.json所在目录下使用npm install . -g可先在本地安装当前命令行程序，可用于发布前的本地测试。

• 使用npm update <package>可以把当前目录下node_modules子目录里边的对应模块更新至最新版本。

• 使用npm update <package> -g可以把全局安装的对应命令行程序更新至最新版。

• 使用npm cache clear可以清空NPM本地缓存，用于对付使用相同版本号发布新版本代码的人。

• 使用npm unpublish <package>@<version>可以撤销发布自己发布过的某个版本代码。

掌握上面NodeJS的知识点，对RN开发来说就足够用了，希望对你有用。

如果还想进一步学习NodeJS，可以移步：

阿里巴巴国际站前端技术部的blog：七天学会NodeJS

参考：http://www.lvtao.net/content/book/node.js.htm#8

转载请注明出处：http://blog.csdn.net/qq_32059827/article/details/52203533   点击打开链接

在Android初级教程里面，介绍了shape用法的理论知识，再来完成这个小案例将会变得非常简单哦。（欢迎学习阅读）：http://blog.csdn.net/qq_32059827/article/details/52203347 点击打开链接

这一篇就针对这个知识点，完成一个自定义的彩色进度条。系统自带的环形进度条是黑白相间的，如果你不是色盲，肯定觉得那个进度条其丑无比！就有必要设计一下它的状态，让我们给她点”颜色”看看。

首先看一下要设计的进度条长什么样子，动态截图如下：

接下来就一步步的完成这个效果。

还是老样子，在drawable目录下建一个shape类型的文件。里面代码如下：

在style里面加入如下代码：

<style name="ProgressBar">
        <item name="android:indeterminateOnly">true</item>
        <item name="android:indeterminateDrawable">@drawable/progressstyleshape</item>
        <item name="android:indeterminateBehavior">repeat</item>
        <item name="android:indeterminateDuration">3500</item>
        <item name="android:minWidth">60dip</item>
        <item name="android:maxWidth">60dip</item>
        <item name="android:minHeight">60dip</item>
        <item name="android:maxHeight">60dip</item>
        <item name="android:mirrorForRtl">false</item>
    </style>

<?xml version="1.0" encoding="utf-8"?>
<rotate xmlns:android="http://schemas.android.com/apk/res/android"
    android:fromDegrees="0"
    android:pivotX="50%"
    android:pivotY="50%"
    android:toDegrees="360" >

    <!--
    封装一个动画
    0~360°旋转、锚点位于中心
    -->
    <shape
        xmlns:android="http://schemas.android.com/apk/res/android"
        android:innerRadiusRatio="3"
        android:shape="ring"
        android:thicknessRatio="10"
        android:useLevel="false" >
        <gradient
            android:endColor="#0000ff"
            android:startColor="#ff0000"
            android:type="sweep" />
        <!--
    android:shape="ring"系统默认矩形，这里修改为环形 
    android:innerRadiusRatio=""表示内半径比：半径/比值，这个值越大，环形的外环越细
	 android:thicknessRatio="10"表示厚度比
	android:useLevel="false"表示让进度条环形不切分，完全显示
	 gradint表示颜色的渐变
	android:type="sweep" 表示扫射的效果

        -->

    </shape>

</rotate>

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity" >

    <ProgressBar
        android:layout_centerInParent="true"
        style="@style/ProgressBar"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>

</RelativeLayout>

1 数组基本

1.1 创建数组

NSArray 是不可变数组,一旦创建完成就不能够对数组进行,添加,删除等操作

下面这种方式相当于什么都没做

NSArray * array = [[NSArray alloc] init];

NSLog(@"%@",array);

1.2 通过构造方法的方式创建一个NSArray

在创建一个NSArray的时候,集合的最后一个元素一定是nil

NSArray * array1 = [NSArray arrayWithObjects:@"one",@"two",@"three", nil];
NSLog(@"%@",array1);

1.3 数组中可以存储不同类型的对象

NSNumber * number = [NSNumber numberWithInt:10];
NSArray * array2 = [[NSArray alloc] initWithObjects:@"one",@"two",number, nil];
NSLog(@"array2  %@",array2);

1.4 数组实际上存储的是对象的地址,同样也可以存储数组的地址

NSArray * a1 = [[NSArray alloc] initWithObjects:@"one",@"two",@"three", nil];
NSArray * a2 = [[NSArray alloc] initWithObjects:@"1",@"2",@"3", nil];
NSArray * a3 = [[NSArray alloc] initWithObjects:a1,a2, nil];

NSLog(@"a3 %@",a3);

1.5 存储自定义的对象

最好都 description 方法

@interface Person : NSObject

@property (nonatomic,strong)NSString * name;
@property (nonatomic,assign)int age;

- (id)initWithName:(NSString *)name andAge:(int)age;

@end

@implementation Person

- (id)initWithName:(NSString *)name andAge:(int)age
{
    if (self = [super init])
    {
        _name = name;
        _age = age;
    }
    return self;
}

- (NSString *)description
{
    return [NSString stringWithFormat:@"age = %d name = %@",_age,_name];
}

@end

Person * p1 = [[Person alloc] initWithName:@"xiaozhe" andAge:20];
Person * p2 = [[Person alloc] initWithName:@"hell" andAge:18];
Person * p3 = [[Person alloc] initWithName:@"marray" andAge:38];

NSArray * array3 = [[NSArray alloc] initWithObjects:p1,p2,p3, nil];
NSLog(@"array3  %@",array3);

1.6 数组中存储基本数据类型

如果你要在数组中存储基本数据类型,请包装好了之后在去存 NSNumber

注意不要把nil值存储到 NSArray 中,会导致数据丢失

NSString * str = nil;
NSArray * array4 = [[NSArray alloc] initWithObjects:@"2",str,[NSNumber numberWithInt:23], nil];
NSLog(@"array4 %@",array4);

1.7 创建数组的快捷方式

NSArray * karray = @[@"a",@"b",@"c"];
NSLog(@"karray %@",karray);

1.8 快速获得一个数组中的元素

NSString * kstr = karray[0];
NSLog(@"kstr %@",kstr);

1.9 从数组中取出数据

NSArray * array = [[NSArray alloc] initWithObjects:@"one",@"two",@"three", nil];

数组的index时从0开始的

NSString * str = [array objectAtIndex:0];
NSLog(@"str %@",str);

1.10 获得数组的元素个数

NSUInteger arrayCount = [array count];
NSLog(@"arrayCount %d",arrayCount);

1.11 判断数组中是否存在某个对象

Person * p1 = [[Person alloc] initWithName:@"yofer" andAge:20];
Person * p2 = [[Person alloc] initWithName:@"luke" andAge:30];

NSArray * array = @[p1,p2];

BOOL isContain = [array containsObject:p1];
if (isContain)
{
    NSLog(@"存在");
}else
{
    NSLog(@"不存在");
}

2 遍历数组

2.1 使用for循环遍历数组

NSArray * array = @[@"one",@"two",@"three"];
for (int i = 0; i < array.count; i++)
{
    NSString * str = array[i];
    NSLog(@"array[%d] = %@",i,str);
}

2.2 使用增强for循环的方式遍历数组

for (NSString * str in array)
{
    NSLog(@"str = %@",str);
}

2.3 注意事项

如果你的数组中村粗了多种不同类型的数据,那么最好不要调用某个对象特有的方法,会导致程序崩溃

在实际的开发中,一个数组往往只负责存储一种数据类型

Person * p1 = [[Person alloc] init];
NSArray * array2 = @[@"one",[NSNumber numberWithInt:10],p1];

for (NSString * str in array2)
{
//    NSLog(@"array2 str %@",str);
//    NSLog(@"str %ld",str.length);
}

2.4 枚举器

NSArray * array3 = @[@"one",@"two",@"three"];

NSEnumerator * enumerateor =  [array3 objectEnumerator];

NSString * value;

while (value = [enumerateor nextObject]) {
    NSLog(@"enum str %@",value);
}

3 数组排序

3.1 使用 sortedArrayUsingSelector

是最简单的排序方式

数组是按照你存入元素的顺序存储的

NSArray * array = @[@"b",@"d",@"a",@"z"];
NSLog(@"排序前 array %@",array);

array = [array sortedArrayUsingSelector:@selector(compare:)];
// NSArray * array1 = [array sortedArrayUsingSelector:@selector(compare:)];
NSLog(@"排序后 array %@",array);

3.2 使用block方式排序

NSArray * array2 = @[@"z",@"4",@"b",@"3",@"x"];

NSLog(@"array2 排序前 %@",array2);
array2 = [array2 sortedArrayUsingComparator:^NSComparisonResult(id obj1, id obj2) {

    /*
    NSComparisonResult retuslt = [obj1 compare:obj2];

    return retuslt;
     */
    //obj1 compare obj2 就是正序排序
    //  return [obj1 compare:obj2];
    //obj2 compare obj1 就是倒序排序
    return [obj2 compare:obj1];

}];
NSLog(@"array2 排序后 %@",array2);

先给一个 Person 类

@interface Person : NSObject

@property (nonatomic,assign) int age;
@property (nonatomic,strong) NSString * name;
@property (nonatomic,strong) NSString * year;

- (id)initWithName:(NSString *)name  andAge:(int)age andYear:(NSString *)year;
//+ (id)personWithName:(NSString *)name  andAge:(int)age andYear:(NSString *)year;

@end

@implementation Person

- (id)initWithName:(NSString *)name  andAge:(int)age andYear:(NSString *)year
{
    if (self = [super init])
    {
        _name = name;
        _age = age;
        _year = year;

    }
    return self;
}

- (NSString *)description
{
    return [NSString stringWithFormat:@"name %@ age %d year %@",_name,_age,_year];
}

@end

3.3 定制化数组对象排序

Person * p1 = [[Person alloc] initWithName:@"xiaozhe" andAge:20 andYear:@"1990"];
Person * p2 = [[Person alloc] initWithName:@"alex" andAge:18 andYear:@"2990"];
Person * p3 = [[Person alloc] initWithName:@"merry" andAge:25 andYear:@"1890"];

NSArray * array3 = @[p1,p2,p3];
NSLog(@"array3 排序前 %@",array3);

如果你向给你自己定义的对象排序,必须根据某一个属性来排序,

sortDescriptorWithKey 参数要的就是你对象中,要依据哪个属性来排序,你就把哪个属性的名字当成key传入

ascending YES表示正序 NO表示倒序

NSSortDescriptor * d1 = [NSSortDescriptor sortDescriptorWithKey:@"age" ascending:NO];
NSSortDescriptor * d2 = [NSSortDescriptor sortDescriptorWithKey:@"year" ascending:NO];

如果你要使用多个属性进行排序,默认在前面的NSSortDescriptor优先级比较高

NSArray * descripts = @[d2,d1];

array3 = [array3 sortedArrayUsingDescriptors:descripts];

NSLog(@"array 3 排序后  %@",array3);

结果：

2016-08-14 14:13:57.238 05-数组排序[2105:516991] array3 排序前 (
    "name xiaozhe age 20 year 1990",
    "name alex age 18 year 2990",
    "name merry age 25 year 1890"
)
2016-08-14 14:13:57.238 05-数组排序[2105:516991] array 3 排序后  (
    "name alex age 18 year 2990",
    "name xiaozhe age 20 year 1990",
    "name merry age 25 year 1890"
)

再次测试：

NSArray * array4 = @[p1,p2,p3];
NSLog(@"array4 排序前 %@",array4);
array4 = [array4 sortedArrayUsingComparator:^NSComparisonResult(id obj1, id obj2) {

    Person * p1 = obj1;
    Person * p2 = obj2;

    //year
    return [p1.year compare:p2.year];
}];
NSLog(@"array4 排序后 %@",array4);

结果：

2016-08-14 14:13:57.238 05-数组排序[2105:516991] array4 排序前 (
    "name xiaozhe age 20 year 1990",
    "name alex age 18 year 2990",
    "name merry age 25 year 1890"
)
2016-08-14 14:13:57.238 05-数组排序[2105:516991] array4 排序后 (
    "name merry age 25 year 1890",
    "name xiaozhe age 20 year 1990",
    "name alex age 18 year 2990"
)

4 可变数组: NSMutableArray

NSMutableArray 继承至 NSArray

4.1 创建可变数组

NSMutableArray * array = [[NSMutableArray alloc] initWithCapacity:0];

使用addObject 动态给数组中增加元素

[array addObject:@"one"];
[array addObject:@"two"];
[array addObject:@"three"];
[array addObject:@"one"];

NSString * str1 = @"one";
NSString * str2 = @"two";
NSString * str3 = @"three";

数组中可以存储,同一个对象多次

[array addObject:str1];
[array addObject:str2];
[array addObject:str3];
[array addObject:str1];

4.2 指定对象插入的位置

[array insertObject:str1 atIndex:2];

4.3 删除 会通过对象,删除数组中所有的同一个地址的对象

[array removeObject:str1];

4.4 通过索引的方式删除对象,超出了数组的count值,那么就会导致异常 index beyond bounds

[array removeObjectAtIndex:0];

[array addObject:str2];
[array addObject:str3];
[array addObject:str1];

4.5 删除数组中所有的元素

[array removeAllObjects];

NSLog(@"array %@",array);

[array addObject:str2];
[array addObject:str3];
[array addObject:str1];

5 可变数组 NSMutableArray 遍历

5.1 for换遍历

for (int i = 0; i < array.count; i++)
{
    NSString * str = [array objectAtIndex:i];

    //在遍历数组的时候,千万不要给数组中,增加,或者删除元素
    // [array removeObject:str1];

    NSLog(@"str %@",str);

}

5.2 增强for循环

for (NSString * str in array)
{
//    [array removeObject:str1];
    //如果你在增强for循环中,删除元素,会直接导致异常出现
    NSLog(@"str %@",str);
}

5.3 枚举器

NSEnumerator * enumerator = [array objectEnumerator];
NSString * value;
while (value = [enumerator nextObject]) {
    //如果你在枚举器中,删除元素,会直接导致异常出现
//    [array removeObject:str1];
    NSLog(@"str %@",value);
}

5.4 要通过遍历的方式确定删除哪个元素怎么办

NSMutableArray * array2 = [[NSMutableArray alloc] init];
[array2 addObject:@"1"];
[array2 addObject:@"2"];
[array2 addObject:@"3"];
[array2 addObject:@"4"];
[array2 addObject:@"5"];

NSMutableArray * tmp = [[NSMutableArray alloc] init];

for (NSString * str in array2)
{
    if ([str isEqualToString:@"3"])
    {
        [tmp addObject:str];
    }
}

NSLog(@"array2 %@",array2);
NSLog(@"tmp %@",tmp);

结果：

2016-08-14 14:35:20.437 06-可变数组[2252:538261] array2 (
    1,
    2,
    3,
    4,
    5
)
2016-08-14 14:35:20.437 06-可变数组[2252:538261] tmp (
    3
)

遍历临时数组

for (int i = 0; i < tmp.count; i++)
{
    NSString * str = [tmp objectAtIndex:i];

    //从原数组中删除,临时数组中存储的对象
    [array2 removeObject:str];
}

NSLog(@"array2 %@",array2);

新博客文章地址：NSArray/NSMutableArray创建,获取,遍历,排序

上一篇智能厨房重构-用ActiveAndroid来实现收藏的功能介绍了本地数据库的实现，有了第一个博友评论说还不错，受益良多，很感动，因为这让我感觉到了技术分享的力量，我们都不是一个人孤军奋战，我们是一个互相交流的群体，因为分享，我们会变得更好。今天给大家介绍一下使用Bmob后端云搭建自己的网上服务器，以后再也不要求着搞服务器的了，自己一个人搞定一个客户端。因为此处篇幅比较多，所以我决定分两篇博客进行讲解，欢迎看下篇 智能厨房重构-使用Bmob后端云实现朋友圈的功能。

1. 环境配置

1.1 服务器配置

首先你需要注册一个Bmob的账号，进入官网即可，注册一个自己的App，如何在后台建立属于自己的表，基本都是傻瓜式建表了，不需要使用SQL语言，来看一下我建的表：

表搭建好了，服务器这边就完事了，就是如此简单。

1.2 客户端环境配置

搞完服务器，接下来就需要将bmob集成到我们的客户端中来了，其实我也是官网文档的搬运工，我就将最主要的步骤介绍一下：

去官网上面下载这两个JAR包，然后再build gradle中添加两个依赖，官网文档中还有直接导入的方式，给个链接http://docs.bmob.cn/data/Android/a_faststart/doc/index.html#初始化BmobSDK，都是比较简单的。

1.3 基本的数据类型和函数

数据类型
目前为止，Bmob支持的数据类型：String、Integer、Float、Short、Byte、Double、Character、Boolean、Object、Array。
同时也支持BmobObject、BmobDate、BmobGeoPoint、BmobFile特有的数据类型。

添加数据
添加数据使用BmobObject对象的save方法，就可以将当前对象的内容保存到Bmob服务端。
例如，你现在要保存一条游戏分数的记录，代码如下：

GameScore gameScore = new GameScore();
//注意：不能调用gameScore.setObjectId("")方法
gameScore.setPlayerName("比目");
gameScore.setScore(89);
gameScore.setIsPay(false);
gameScore.save(new SaveListener<String>() {

    @Override
    public void done(String objectId, BmobException e) {
        if(e==null){
            toast("创建数据成功：" + objectId);
        }else{
            Log.i("bmob","失败："+e.getMessage()+","+e.getErrorCode());
        }
    }
})

删除数据
从服务器删除对象。例如：将GameScore表中objectId为dd8e6aff28的数据删除。

GameScore gameScore = new GameScore();
gameScore.setObjectId("dd8e6aff28");
gameScore.delete(new UpdateListener() {

    @Override
    public void done(BmobException e) {
        if(e==null){
            Log.i("bmob","成功");
        }else{
            Log.i("bmob","失败："+e.getMessage()+","+e.getErrorCode());
        }
    }
});

查询数据
当我们知道某条数据的objectId时，就可以根据objectId直接获取单条数据对象。例如：查询objectId为a203eba875的人员信息。

BmobQuery<GameScore> query = new BmobQuery<GameScore>();
query.getObject("a203eba875", new QueryListener<GameScore>() {

    @Override
    public void done(GameScore object, BmobException e) {
        if(e==null){
            //获得playerName的信息
            object.getPlayerName();
            //获得数据的objectId信息
            object.getObjectId();
            //获得createdAt数据创建时间（注意是：createdAt，不是createAt）
            object.getCreatedAt();
        }else{
            Log.i("bmob","失败："+e.getMessage()+","+e.getErrorCode());
        }
    }

});

修改数据
更新一个对象也是非常简单。例如：将GameScore表中objectId为0c6db13c的游戏分数修改为77.

GameScore gameScore = new GameScore();
gameScore.setScore(77);
gameScore.update("0c6db13c", new UpdateListener() {

    @Override
    public void done(BmobException e) {
        if(e==null){
            Log.i("bmob","更新成功");
        }else{
            Log.i("bmob","更新失败："+e.getMessage()+","+e.getErrorCode());
        }
    }
});

函数都比较简单好用，如果想要了解更多，请直接看官网文档。

2.实战

现在服务器和客户端的环境都配置好，现在我们可以开始实战了。我们要实现的注册和登录的功能，首先来看一下流程

2.1 建立实体对象

使用Bmob，必须遵守的一个规则就是，你的实体对象名必须和表名相同，表中的每一个列都对应一个属性，必须继承BmobObject这个类，这一点很不好，假如和ActiveAndroid连用的话，就冲突了，因为Java中不能多重继承，比如上面的用户表对应实体类就是：

/**
 * 作者：GXL on 2016/8/3 0003
 * 博客: http://blog.csdn.net/u014316462
 * 作用：用户表
 */
public class User extends BmobObject implements Serializable{

    //姓名
    String Name;
    //头像
    BmobFile Photo;
    //密码
    String Password;

    public String getNumber() {
        return Number;
    }

    public void setNumber(String number) {
        Number = number;
    }

    //手机号码
    String Number;

    public String getName() {
        return Name;
    }

    public void setName(String name) {
        Name = name;
    }

    public BmobFile getPhoto() {
        return Photo;
    }

    public void setPhoto(BmobFile photo) {
        Photo = photo;
    }

    public String getPassword() {
        return Password;
    }

    public void setPassword(String password) {
        Password = password;
    }

    public User() {
    }
}

2.2 建立UserModel和服务器进行数据交互

/**
 * 作者：GXL on 2016/8/3 0003
 * 博客: http://blog.csdn.net/u014316462
 * 作用：用户信息Model
 */
public class UserModel implements UserModelImpl {

    private final String LOGINUSER = "loginuser";

    /**
     * 用户登录验证
     *
     * @param phone
     * @param passoword
     * @param listener
     */
    @Override
    public void getUser(String phone, String passoword, final FoodModelImpl.BaseListener listener) {
        BmobQuery<User> query = new BmobQuery<User>();
        query.addWhereEqualTo("Number", phone);
        query.addWhereEqualTo("Password", passoword);
        query.setLimit(1);
        query.findObjects(BaseApplication.getmContext(), new FindListener<User>() {
            @Override
            public void onSuccess(List<User> object) {
                if (object != null && object.size() != 0) {
                    SPUtils.put(BaseApplication.getmContext(), LOGINUSER, object.get(0));
                    listener.getSuccess(object.get(0));
                } else {
                    listener.getFailure();
                }
            }

            @Override
            public void onError(int code, String msg) {

            }
        });
    }

    /**
     * 根据objectId获取User
     *
     * @param objectId
     * @param listener
     */
    @Override
    public void getUser(String objectId, final FoodModelImpl.BaseListener listener) {
        BmobQuery<User> query = new BmobQuery<User>();
        query.addWhereEqualTo("objectId", objectId);
        query.setLimit(1);
        query.findObjects(BaseApplication.getmContext(), new FindListener<User>() {
            @Override
            public void onSuccess(List<User> object) {
                if (object != null && object.size() != 0) {
                    SPUtils.put(BaseApplication.getmContext(), LOGINUSER, object.get(0));
                    listener.getSuccess(object.get(0));
                } else {
                    listener.getFailure();
                }
            }

            @Override
            public void onError(int code, String msg) {

            }
        });
    }

    /**
     * 更换用户的头像
     *
     * @param path
     * @param listener
     */
    public void updateUserPhoto(String path, final String objectId, final FoodModelImpl.BaseListener listener) {
        final BmobFile bmobFile = new BmobFile(new File(path));
        bmobFile.upload(BaseApplication.getmContext(), new UploadFileListener() {
            @Override
            public void onSuccess() {
                final User user = new User();
                user.setPhoto(bmobFile);
                user.update(BaseApplication.getmContext(), objectId, new UpdateListener() {
                    @Override
                    public void onSuccess() {
                        listener.getSuccess(user);

                    }

                    @Override
                    public void onFailure(int i, String s) {
                        listener.getFailure();
                    }
                });
            }

            @Override
            public void onFailure(int i, String s) {
                listener.getFailure();
            }
        });
    }

    /**
     * 判断当前用户是否登录
     *
     * @return
     */
    public boolean isLogin() {
        List<UserLocal> list = new Select().from(UserLocal.class).execute();
        if (list.size() != 0) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 将当前登录的对象保持到数据库中
     *
     * @param userLocal
     */
    public void putUserLocal(UserLocal userLocal) {
        new Delete().from(UserLocal.class).execute();
        userLocal.save();
    }

    /**
     * 获取当前登录的对象
     *
     * @return
     */
    public UserLocal getUserLocal() {
        return new Select().from(UserLocal.class).executeSingle();
    }


    /**
     * 注册功能
     *
     * @param user
     */
    public void onRegister(User user, final FoodModelImpl.BaseListener listener) {
        user.save(BaseApplication.getmContext(), new SaveListener() {
            @Override
            public void onSuccess() {
                ToastUtils.showLong(BaseApplication.getmContext(), "注册成功");
                listener.getSuccess(null);
            }

            @Override
            public void onFailure(int i, String s) {
                ToastUtils.showLong(BaseApplication.getmContext(), "注册失败");
                listener.getFailure();
            }
        });
    }

    /**
     * 判断当前手机号码是否注册
     *
     * @param phone
     * @param listener
     * @return
     */
    public void isPhoneRegister(String phone, final FoodModelImpl.BaseListener listener) {
        BmobQuery<User> query = new BmobQuery<User>();
        query.addWhereEqualTo("Number", phone);
        query.setLimit(1);
        query.findObjects(BaseApplication.getmContext(), new FindListener<User>() {
            @Override
            public void onSuccess(List<User> object) {
                if (object != null && object.size() != 0) {
                    listener.getSuccess(object.get(0));
                } else {
                    listener.getFailure();
                }
            }

            @Override
            public void onError(int code, String msg) {

            }
        });
    }
}

所有和服务器的数据请求和提交都在上面了，都很简单，都是利用了上面的函数。

2.3 使用效果

详细的项目代码地址：https://github.com/gxl1240779189/ReIntelligentKitchen，如果决定效果还可以，请点个赞支持一下，多谢了。

项目下载地址github：

1.打开蓝牙：

      mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();

      /**如果本地蓝牙没有开启，则开启*/
      if (!mBluetoothAdapter.isEnabled()) {
        // 我们通过startActivityForResult()方法发起的Intent将会在onActivityResult()回调方法中获取用户的选择，比如用户单击了Yes开启，
        // 那么将会收到RESULT_OK的结果，
        // 如果RESULT_CANCELED则代表用户不愿意开启蓝牙
        Intent mIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
        startActivityForResult(mIntent, ENABLE_BLUE);
       } else {
           Toast.makeText(this, "蓝牙已开启", Toast.LENGTH_SHORT).show();
       }

监听打开的结果：

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (requestCode == ENABLE_BLUE) {
            if (resultCode == RESULT_OK) {
                Toast.makeText(this, "蓝牙开启成功", Toast.LENGTH_SHORT).show();
                getBondedDevices();
            } else if (resultCode == RESULT_CANCELED) {
                Toast.makeText(this, "蓝牙开始失败", Toast.LENGTH_SHORT).show();
            }
        } else {

        }
    }

2.关闭蓝牙:

     /**关闭蓝牙*/
     if (mBluetoothAdapter.isEnabled()) {
           mBluetoothAdapter.disable();
     }

3.设计蓝牙为可见:

     Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
     intent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 180);//180可见时间
     startActivity(intent);

4.收索蓝牙:

注册广播监听搜索的结果：

     /**注册搜索蓝牙receiver*/
     mFilter = new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
     mFilter.addAction(BluetoothDevice.ACTION_FOUND);
     mFilter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
     registerReceiver(mReceiver, mFilter);

开始的搜索：

     // 如果正在搜索，就先取消搜索
     if (mBluetoothAdapter.isDiscovering()) {
         mBluetoothAdapter.cancelDiscovery();
     }
     // 开始搜索蓝牙设备,搜索到的蓝牙设备通过广播返回
     mBluetoothAdapter.startDiscovery();

监听搜索的结果：

    private BroadcastReceiver mReceiver = new BroadcastReceiver() {

        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            /** 搜索到的蓝牙设备*/
            if (action.equals(BluetoothDevice.ACTION_FOUND)) {
                BluetoothDevice device = intent
                        .getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
                // 搜索到的不是已经配对的蓝牙设备
                if (device.getBondState() != BluetoothDevice.BOND_BONDED) {
                    BlueDevice blueDevice = new BlueDevice();
                    blueDevice.setName(device.getName());
                    blueDevice.setAddress(device.getAddress());
                    blueDevice.setDevice(device);
                    setDevices.add(blueDevice);
                    blueAdapter.setSetDevices(setDevices);
                    blueAdapter.notifyDataSetChanged();
                    Log.d(MAINACTIVITY, "搜索结果......"+device.getName());
                }

                /**当绑定的状态改变时*/
            } else if (action.equals(BluetoothDevice.ACTION_BOND_STATE_CHANGED)) {




                /**搜索完成*/
            } else if (action.equals(BluetoothAdapter.ACTION_DISCOVERY_FINISHED)) {
                setProgressBarIndeterminateVisibility(false);
                Log.d(MAINACTIVITY, "搜索完成......");
                hideProgressDailog();
            }
        }
    };

5.配对蓝牙:

配对工具类

    public class BlueUtils {

        public BlueUtils(BlueDevice blueDevice) {
            this.blueDevice = blueDevice;
        }

        /**
         * 配对
         */
        public void doPair() {
                if(null == mOthHandler){
                    HandlerThread handlerThread = new HandlerThread("other_thread");
                    handlerThread.start();
                    mOthHandler = new Handler(handlerThread.getLooper());
                }
                mOthHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        initSocket();   //取得socket
                        try {
                            socket.connect();   //请求配对
        //                      mAdapterManager.updateDeviceAdapter();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                });
        }


        /**
         * 取消蓝牙配对
         * @param device
         */
        public static void unpairDevice(BluetoothDevice device) {
            try {
                Method m = device.getClass()
                        .getMethod("removeBond", (Class[]) null);
                m.invoke(device, (Object[]) null);
            } catch (Exception e) {
                Log.d("BlueUtils", e.getMessage());
            }
        }


        /**
         * 取得BluetoothSocket
         */
       private void initSocket() {
            BluetoothSocket temp = null;
            try {
                Method m = blueDevice.getDevice().getClass().getMethod("createRfcommSocket", new Class[] {int.class});
                temp = (BluetoothSocket) m.invoke(blueDevice.getDevice(), 1);
                //怪异错误： 直接赋值给socket,对socket操作可能出现异常，  要通过中间变量temp赋值给socket
            } catch (SecurityException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
            socket = temp;
        }

    }

注册监听配对结果的广播（使用同上面的注册代码）

     /**注册搜索蓝牙receiver*/
     mFilter = new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
     mFilter.addAction(BluetoothDevice.ACTION_FOUND);
     mFilter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
     registerReceiver(mReceiver, mFilter);

开始配对

    /**
     * 开始配对蓝牙设备
     *
     * @param blueDevice
     */
    private void startPariBlue(BlueDevice blueDevice) {
        BlueUtils blueUtils = new BlueUtils(blueDevice);
        blueUtils.doPair();
    }

监听配对结果：（使用同上面的广播接收者）

    private BroadcastReceiver mReceiver = new BroadcastReceiver() {

        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            /** 搜索到的蓝牙设备*/
            if (action.equals(BluetoothDevice.ACTION_FOUND)) {

                .....
                /**当绑定的状态改变时*/
            } else if (action.equals(BluetoothDevice.ACTION_BOND_STATE_CHANGED)) {
                BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
                switch (device.getBondState()) {
                    case BluetoothDevice.BOND_BONDING:
                        Log.d(MAINACTIVITY, "正在配对......");

                        break;
                    case BluetoothDevice.BOND_BONDED:
                        Log.d(MAINACTIVITY, "完成配对");
                        hideProgressDailog();
                        /**开始连接*/
                        contectBuleDevices();
                        break;
                    case BluetoothDevice.BOND_NONE:
                        Log.d(MAINACTIVITY, "取消配对");
                        Toast.makeText(MainActivity.this,"成功取消配对",Toast.LENGTH_SHORT).show();
                        getBondedDevices();
                        break;
                    default:
                        break;
                }

                /**搜索完成*/
            } else if (action.equals(BluetoothAdapter.ACTION_DISCOVERY_FINISHED)) {
                ....
            }
        }
    };

6.使用A2DP协议连接蓝牙设备:

连接设备

    /**
     * 开始连接蓝牙设备
     */
    private void contectBuleDevices() {
        /**使用A2DP协议连接设备*/
        mBluetoothAdapter.getProfileProxy(this, mProfileServiceListener, BluetoothProfile.A2DP);
    }

监听连接的回调

    /**
     * 连接蓝牙设备（通过监听蓝牙协议的服务，在连接服务的时候使用BluetoothA2dp协议）
     */
    private BluetoothProfile.ServiceListener mProfileServiceListener = new BluetoothProfile.ServiceListener() {

        @Override
        public void onServiceDisconnected(int profile) {

        }

        @Override
        public void onServiceConnected(int profile, BluetoothProfile proxy) {
            try {
                if (profile == BluetoothProfile.HEADSET) {
                    ....

                } else if (profile == BluetoothProfile.A2DP) {
                    /**使用A2DP的协议连接蓝牙设备（使用了反射技术调用连接的方法）*/
                    a2dp = (BluetoothA2dp) proxy;
                    if (a2dp.getConnectionState(currentBluetoothDevice) != BluetoothProfile.STATE_CONNECTED) {
                        a2dp.getClass()
                                .getMethod("connect", BluetoothDevice.class)
                                .invoke(a2dp, currentBluetoothDevice);
                        Toast.makeText(MainActivity.this,"请播放音乐",Toast.LENGTH_SHORT).show();
                        getBondedDevices();
                    }
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    };

7.添加权限

    <uses-permission android:name="android.permission.BLUETOOTH" />
    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />

8.打开乐库播放音乐

9.Android 6.0的系统需要动态添加权限才能搜索出蓝牙设备

Android 6.0的系统需要动态添加权限

    /**判断手机系统的版本*/
    if (Build.VERSION.SDK_INT >= 6.0) {//Build.VERSION.SDK_INT >= Build.VERSION_CODES.M
            if(ActivityCompat.checkSelfPermission(this,Manifest.permission.ACCESS_COARSE_LOCATION)!=PackageManager.PERMISSION_GRANTED){
                /**动态添加权限：ACCESS_FINE_LOCATION*/
                ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
                        MY_PERMISSION_REQUEST_CONSTANT);
            }
        }

请求权限的回调

    /**请求权限的回调：这里判断权限是否添加成功*/
     /**请求权限的回调：这里判断权限是否添加成功*/
    public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
        switch (requestCode) {
            case MY_PERMISSION_REQUEST_CONSTANT: {
                if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    Log.i("main","添加权限成功");
                }
                return;
            }
        }
    }

Android GridView如何适配不同屏幕

GridView和ListView一样，都是项目中常用的控件之一，针对Android市场层出不穷的手机机型，在实际开发中，我们就需要去做适配，这篇文章就给大家讲解一下GridView的适配。

效果图：

GridView.xml

<GridView
        android:id="@+id/gridview"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="@color/transparent"
        android:descendantFocusability="blocksDescendants"
        android:gravity="center"
        android:horizontalSpacing="3dp"
        android:numColumns="3"
        android:scrollbars="none"
        android:verticalSpacing="3dp"

        />

android:numColumns=”3” 一行三个
android:horizontalSpacing=”3dp” 子控件item之间的行间距及列间距
android:verticalSpacing=”3dp”

Gridview与ListView用法原理是一样的都需要用到Adapter，一般都是继承BaseAdapter。

接下来介绍在Adapter如何用GridView去做适配，直接上代码：

  //宽度高度适配  
            WindowManager wm = MomentNewsActivity.this.getWindowManager();
            int width = wm.getDefaultDisplay().getWidth();
            AbsListView.LayoutParams layoutParams = new AbsListView.LayoutParams(width/3, width/3);
            convertView.setLayoutParams(layoutParams);

上面这段代码写在return convertView之前即可。

Gridview的简单适配就是这样的，接下来介绍一下Gridview稍微复杂一些的适配，主要的就是适配是要显示的主要内容要等比例的放大缩小来适应屏幕的分辨率。

先上效果图：

这次每个展示的item不再是简单的正方形的展现形式了，而是长方形的展示。分析一下，item显示中的整体是长方形，照片展示还是采取正方形展示，我们只需要将长方形等比例的放大缩小，然后将照片展示的正方形采取正方形展示的适配，适配问题就解决了。

xml:

   <GridView
                    android:id="@+id/gridview_samecity"
                    android:layout_width="match_parent"
                    android:layout_height="match_parent"
                    android:background="@color/transparent"
                    android:descendantFocusability="blocksDescendants"
                    android:gravity="center"
                    android:horizontalSpacing="3dp"
                    android:numColumns="2"
                    android:scrollbars="none"
                    android:verticalSpacing="3dp"

                    />

item的xml:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:id="@+id/layout_the_same_city"
    android:layout_width="170dp"
    android:layout_height="233dp"
    android:background="@color/M323535"
    android:orientation="vertical">

    <!--//故事照片 -->
    <!--标题-->
    <RelativeLayout
        android:id="@+id/layout_story_pic"
        android:layout_width="match_parent"
        android:layout_height="@dimen/dp170">

        <ImageView
            android:id="@+id/img_bitmap"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:contentDescription="@null" />

        <RelativeLayout
            android:id="@+id/layout_story"
            android:layout_width="match_parent"
            android:layout_height="match_parent">

            <ImageView
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:background="@color/M0D493E"
                android:contentDescription="@null"
                android:scaleType="centerCrop" />

            <ImageView
                android:id="@+id/img_story_bitmap"
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:layout_marginBottom="@dimen/dp5"
                android:layout_marginEnd="@dimen/dp5"
                android:layout_marginLeft="@dimen/dp5"
                android:layout_marginRight="@dimen/dp5"
                android:layout_marginStart="@dimen/dp5"
                android:layout_marginTop="@dimen/dp5"
                android:background="@mipmap/now_default_img"
                android:contentDescription="@null"
                android:scaleType="centerCrop" />

        </RelativeLayout>


        <ImageView
            android:layout_width="match_parent"
            android:layout_height="@dimen/dp85"
            android:layout_alignParentBottom="true"
            android:background="@mipmap/story_cover"
            android:contentDescription="@null" />

        <TextView
            android:id="@+id/txt_story_title"
            android:layout_width="match_parent"
            android:layout_height="@dimen/dp26"
            android:layout_alignParentBottom="true"
            android:gravity="center|start"
            android:paddingEnd="@dimen/dp36"
            android:paddingLeft="@dimen/dp10"
            android:paddingRight="@dimen/dp36"
            android:paddingStart="@dimen/dp10"
            android:singleLine="true"
            android:textColor="@color/ME6E6E6"
            android:textSize="@dimen/sp12" />


        <!--//视频-->
        <ImageView
            android:id="@+id/img_video"
            android:layout_width="@dimen/dp35"
            android:layout_height="@dimen/dp35"
            android:layout_centerInParent="true"
            android:background="@mipmap/video_play"
            android:contentDescription="@null" />

    </RelativeLayout>
    <!--头像-->
    <!--用户名-->
    <!--时间 -->
    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="@dimen/dp36">

        <!--头像-->

        <ImageView
            android:id="@+id/img_sex_color"
            android:layout_width="@dimen/dp25"
            android:layout_height="@dimen/dp25"
            android:layout_centerVertical="true"
            android:layout_marginLeft="@dimen/dp5"
            android:layout_marginStart="@dimen/dp5"
            android:background="@drawable/shape_image_background"
            android:contentDescription="@null" />

        <com.motoband.widget.RoundImageView
            android:id="@+id/img_story_head_portrait"
            android:layout_width="@dimen/dp23"
            android:layout_height="@dimen/dp23"
            android:layout_centerVertical="true"
            android:layout_marginLeft="@dimen/dp6"
            android:layout_marginStart="@dimen/dp6"
            android:background="@mipmap/me_headportrait_2"
            android:scaleType="centerCrop"
            app:maskType="CIRCLE" />

        <TextView
            android:id="@+id/txt_story_name"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_marginLeft="@dimen/dp5"
            android:layout_marginStart="@dimen/dp5"
            android:layout_marginTop="@dimen/dp5"
            android:layout_toEndOf="@+id/img_sex_color"
            android:layout_toRightOf="@+id/img_sex_color"
            android:singleLine="true"
            android:textColor="@color/MD9D9D9"
            android:textSize="@dimen/sp12" />


        <TextView
            android:id="@+id/txt_story_time"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_below="@+id/txt_story_name"
            android:layout_marginLeft="@dimen/dp5"
            android:layout_marginStart="@dimen/dp5"
            android:layout_toEndOf="@+id/img_sex_color"
            android:layout_toRightOf="@+id/img_sex_color"
            android:singleLine="true"
            android:textColor="@color/M969696"
            android:textSize="@dimen/sp8" />

    </RelativeLayout>


    <TextView
        android:layout_width="match_parent"
        android:layout_height="0.5dp"
        android:layout_gravity="center_vertical"
        android:background="@color/M3C3C3C" />

    <!--点赞-->
    <!--评论-->
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="@dimen/dp27"
        android:orientation="horizontal">

        <RelativeLayout
            android:id="@+id/layout_story_like"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:layout_weight="1">

            <TextView
                android:id="@+id/txt_story_like"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_centerVertical="true"
                android:layout_marginLeft="@dimen/dp50"
                android:layout_marginStart="@dimen/dp50"
                android:gravity="center"
                android:text="@string/zero"
                android:textColor="@color/MC8C8C8"
                android:textSize="@dimen/sp11"
                 />

            <ImageView
                android:id="@+id/img_story_like"
                android:layout_width="@dimen/dp18"
                android:layout_height="@dimen/dp18"
                android:layout_centerVertical="true"
                android:layout_marginLeft="@dimen/dp26"
                android:layout_marginStart="@dimen/dp26"
                android:contentDescription="@null" />
            <!--android:background="@drawable/select_dynamic_like"-->
        </RelativeLayout>


        <TextView
            android:layout_width="0.5dp"
            android:layout_height="@dimen/dp20"
            android:layout_gravity="center_vertical"
            android:background="@color/M3C3C3C" />

        <RelativeLayout
            android:id="@+id/layout_story_comment"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:layout_weight="1">

            <ImageView
                android:id="@+id/img_story_comment"
                android:layout_width="@dimen/dp18"
                android:layout_height="@dimen/dp18"
                android:layout_centerVertical="true"
                android:layout_marginLeft="@dimen/dp26"
                android:layout_marginStart="@dimen/dp26"
                android:background="@mipmap/select_dynamic_comment"
                android:contentDescription="@null" />


            <TextView
                android:id="@+id/txt_story_comment"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_centerVertical="true"
                android:layout_marginLeft="@dimen/dp50"
                android:layout_marginStart="@dimen/dp50"
                android:gravity="center"
                android:text="@string/zero"
                android:textColor="@color/MC8C8C8"
                android:textSize="@dimen/sp11"
                 />

        </RelativeLayout>

    </LinearLayout>


</LinearLayout>

注：实际开发中根据自身的项目需求去调整

适配还是在Adapter中去写：

 //宽度高度适配   
 //外层的整体item
            WindowManager wm = NewsActivity.this.getWindowManager();
            int width = wm.getDefaultDisplay().getWidth();
            AbsListView.LayoutParams layoutParams = new AbsListView.LayoutParams((width - PixelOrdpManager.dip2px(getBaseContext(), 6)) / 2,
                    (width - PixelOrdpManager.dip2px(getBaseContext(), 6)) / 2 + PixelOrdpManager.dip2px(getBaseContext(), 63));
            convertView.setLayoutParams(layoutParams);

//展示中的正方形照片
            LinearLayout.LayoutParams layoutParamsStory = new LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
            layoutParamsStory.width = (width - PixelOrdpManager.dip2px(getBaseContext(), 6)) / 2;
            layoutParamsStory.height = (width - PixelOrdpManager.dip2px(getBaseContext(), 6)) / 2;
            storyHodelView.layout_story_pic.setLayoutParams(layoutParamsStory);

这里用到了dp与px的转换： xml中一般是dp,代码中是px.
(这里参考 Utils（上）一些常用的工具类)

同理还是写在 return convertView; 之前

GridView的适配就说到这里了，希望有什么问题大家可以共同讨论，相互学习，相互进步。

现在很多app的支付、输入密码功能，都已经开始使用自定义数字键盘，不仅更加方便、其效果着实精致。
下面带着大家学习下，如何高仿微信的数字键盘，可以拿来直接用在自身的项目中。
先看下效果图：

1. 自定义布局

<?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="wrap_content">

    <!-- 输入键盘 -->
    <GridView
        android:id="@+id/gv_keybord"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_alignParentBottom="true"
        android:background="#bdbdbd"
        android:horizontalSpacing="1px"
        android:numColumns="3"
        android:verticalSpacing="1px" />

    <View
        android:id="@+id/line"
        android:layout_width="match_parent"
        android:layout_height="1px"
        android:layout_above="@id/gv_keybord"
        android:background="#bdbdbd" />

    <RelativeLayout
        android:id="@+id/layoutBack"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_above="@id/line"
        android:background="#f5f5f5"
        android:padding="10dp">

        <ImageView
            android:id="@+id/imgBack"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerInParent="true"
            android:src="@mipmap/keyboard_back_img" />

    </RelativeLayout>

    <View
        android:layout_width="match_parent"
        android:layout_height="1px"
        android:layout_above="@id/layoutBack"
        android:layout_marginTop="1dp"
        android:background="#bdbdbd" />

</RelativeLayout>

键盘的布局，实质就是一个4X3网格布局的GridView。

2.实现数字键盘内容

import android.content.Context;
import android.util.AttributeSet;
import android.view.View;
import android.widget.GridView;
import android.widget.RelativeLayout;

import com.lnyp.pswkeyboard.R;
import com.lnyp.pswkeyboard.adapter.KeyBoardAdapter;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

/**
 * 虚拟键盘
 */
public class VirtualKeyboardView extends RelativeLayout implements View.OnClickListener {

    Context context;

    private GridView gridView;    

    private RelativeLayout layoutBack;

    private ArrayList<Map<String, String>> valueList;   


    public VirtualKeyboardView(Context context) {
        this(context, null);
    }

    public VirtualKeyboardView(Context context, AttributeSet attrs) {
        super(context, attrs);
        this.context = context;
        View view = View.inflate(context, R.layout.layout_virtual_keyboard, null);

        valueList = new ArrayList<>();

        layoutBack = (RelativeLayout) view.findViewById(R.id.layoutBack);
        layoutBack.setOnClickListener(this);

        gridView = (GridView) view.findViewById(R.id.gv_keybord);

        setView();

        addView(view); 
    }

    public RelativeLayout getLayoutBack() {
        return layoutBack;
    }

    public ArrayList<Map<String, String>> getValueList() {
        return valueList;
    }

    public GridView getGridView() {
        return gridView;
    }

    private void setView() {

        /* 初始化按钮上应该显示的数字 */
        for (int i = 1; i < 13; i++) {
            Map<String, String> map = new HashMap<String, String>();
            if (i < 10) {
                map.put("name", String.valueOf(i));
            } else if (i == 10) {
                map.put("name", ".");
            } else if (i == 11) {
                map.put("name", String.valueOf(0));
            } else if (i == 12) {
                map.put("name", "");
            }
            valueList.add(map);
        }

        KeyBoardAdapter keyBoardAdapter = new KeyBoardAdapter(context, valueList);
        gridView.setAdapter(keyBoardAdapter);
    }

    @Override
    public void onClick(View v) {

    }
}

看下适配器如何处理：KeyBoardAdapter .java

import android.content.Context;
import android.graphics.Color;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.RelativeLayout;
import android.widget.TextView;

import com.lnyp.pswkeyboard.R;

import java.util.ArrayList;
import java.util.Map;

/**
 * 九宫格键盘适配器
 */
public class KeyBoardAdapter extends BaseAdapter {


    private Context mContext;
    private ArrayList<Map<String, String>> valueList;

    public KeyBoardAdapter(Context mContext, ArrayList<Map<String, String>> valueList) {
        this.mContext = mContext;
        this.valueList = valueList;
    }

    @Override
    public int getCount() {
        return valueList.size();
    }

    @Override
    public Object getItem(int position) {
        return valueList.get(position);
    }

    @Override
    public long getItemId(int position) {
        return position;
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        ViewHolder viewHolder;
        if (convertView == null) {
            convertView = View.inflate(mContext, R.layout.grid_item_virtual_keyboard, null);
            viewHolder = new ViewHolder();
            viewHolder.btnKey = (TextView) convertView.findViewById(R.id.btn_keys);
            viewHolder.imgDelete = (RelativeLayout) convertView.findViewById(R.id.imgDelete);

            convertView.setTag(viewHolder);
        } else {
            viewHolder = (ViewHolder) convertView.getTag();
        }

        if (position == 9) {
            viewHolder.imgDelete.setVisibility(View.INVISIBLE);
            viewHolder.btnKey.setVisibility(View.VISIBLE);
            viewHolder.btnKey.setText(valueList.get(position).get("name"));
            viewHolder.btnKey.setBackgroundColor(Color.parseColor("#e0e0e0"));
        } else if (position == 11) {
            viewHolder.btnKey.setBackgroundResource(R.mipmap.keyboard_delete_img);
            viewHolder.imgDelete.setVisibility(View.VISIBLE);
            viewHolder.btnKey.setVisibility(View.INVISIBLE);

        } else {
            viewHolder.imgDelete.setVisibility(View.INVISIBLE);
            viewHolder.btnKey.setVisibility(View.VISIBLE);

            viewHolder.btnKey.setText(valueList.get(position).get("name"));
        }

        return convertView;
    }

    /**
     * 存放控件
     */
    public final class ViewHolder {
        public TextView btnKey;
        public RelativeLayout imgDelete;
    }
}

在看Adapter之前，我们先看下grid_item_virtual_keyboard是如何实现的：

<?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"
    android:background="#e0e0e0">

    <TextView
        android:id="@+id/btn_keys"
        android:layout_width="match_parent"
        android:layout_height="60dp"
        android:layout_centerInParent="true"
        android:background="@drawable/selector_gird_item"
        android:gravity="center"
        android:includeFontPadding="false"
        android:textColor="#333333"
        android:textSize="26sp" />

    <RelativeLayout
        android:id="@+id/imgDelete"
        android:layout_width="wrap_content"
        android:layout_height="60dp"
        android:layout_centerInParent="true">

        <ImageView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerInParent="true"
            android:src="@mipmap/keyboard_delete_img" />

    </RelativeLayout>


</RelativeLayout>

可以看到，我们在item布局文件中，指定了两个view，一个是普通显示数字的TextView， 一个是显示最后删除键的RelativeLayout。
然后，在KeyBoardAdapter 的getView方法中，我们根据position位置，对布局进行不同的处理。当position为9，也就是倒数第三个按键，它的按钮颜色要单独设置。 当position为12也就是最后一个按钮时，需要控制删除按钮显示，数字按钮隐藏。 其余情况则是删除按钮隐藏，数字按钮显示。

3.使用并实现键盘事件逻辑

布局中，可以直接使用自己定义的数字键盘：

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#efefef"
    tools:context="com.lnyp.pswkeyboard.NormalKeyBoardActivity">


    <EditText
        android:id="@+id/textAmount"
        android:layout_width="match_parent"
        android:layout_height="50dp"
        android:background="#FFFFFF"
        android:inputType="numberDecimal"
        android:padding="14dp"
        android:textColor="#333333"
        android:textSize="16sp" />

    <com.lnyp.pswkeyboard.widget.VirtualKeyboardView
        android:id="@+id/virtualKeyboardView"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="bottom" />

</RelativeLayout>

我们在Activity中，操作数字键盘：

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.text.Editable;
import android.view.View;
import android.view.animation.Animation;
import android.view.animation.AnimationUtils;
import android.widget.AdapterView;
import android.widget.EditText;
import android.widget.GridView;

import com.lnyp.pswkeyboard.widget.VirtualKeyboardView;

import java.util.ArrayList;
import java.util.Map;

public class NormalKeyBoardActivity extends AppCompatActivity {

    private VirtualKeyboardView virtualKeyboardView;

    private GridView gridView;

    private ArrayList<Map<String, String>> valueList;

    private EditText textAmount;

    private Animation enterAnim;

    private Animation exitAnim;

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

        valueList = virtualKeyboardView.getValueList();

        initAnim();

        initView();
    }

    private void initAnim() {

        enterAnim = AnimationUtils.loadAnimation(this, R.anim.push_bottom_in);
        exitAnim = AnimationUtils.loadAnimation(this, R.anim.push_bottom_out);
    }

    private void initView() {

        virtualKeyboardView = (VirtualKeyboardView) findViewById(R.id.virtualKeyboardView);
        textAmount = (EditText) findViewById(R.id.textAmount);
        virtualKeyboardView.getLayoutBack().setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                virtualKeyboardView.startAnimation(exitAnim);
                virtualKeyboardView.setVisibility(View.GONE);
            }
        });

        gridView = virtualKeyboardView.getGridView();
        gridView.setOnItemClickListener(onItemClickListener);

        textAmount.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                virtualKeyboardView.setFocusable(true);
                virtualKeyboardView.setFocusableInTouchMode(true);

                virtualKeyboardView.startAnimation(enterAnim);
                virtualKeyboardView.setVisibility(View.VISIBLE);
            }
        });

    }

    private AdapterView.OnItemClickListener onItemClickListener = new AdapterView.OnItemClickListener() {
        @Override
        public void onItemClick(AdapterView<?> adapterView, View view, int position, long l) {

            if (position < 11 && position != 9) {    //点击0~9按钮

                String amount = textAmount.getText().toString().trim();
                amount = amount + valueList.get(position).get("name");

                textAmount.setText(amount);

                Editable ea = textAmount.getText();
                textAmount.setSelection(ea.length());
            } else {

                if (position == 9) {      //点击退格键
                    String amount = textAmount.getText().toString().trim();
                    if (!amount.contains(".")) {
                        amount = amount + valueList.get(position).get("name");
                        textAmount.setText(amount);

                        Editable ea = textAmount.getText();
                        textAmount.setSelection(ea.length());
                    }
                }

                if (position == 11) {      //点击退格键
                    String amount = textAmount.getText().toString().trim();
                    if (amount.length() > 0) {
                        amount = amount.substring(0, amount.length() - 1);
                        textAmount.setText(amount);

                        Editable ea = textAmount.getText();
                        textAmount.setSelection(ea.length());
                    }
                }
            }
        }
    };
}

好了，通过以上步骤，我们便可以实现微信支付键盘啦，是不是很easy呢？！

如有疑问或建议，欢迎进QQ群来讨论交流：487786925（ Android研发村 ）

源码地址：https://github.com/zuiwuyuan/WeChatPswKeyboard

承接上一篇：http://blog.csdn.net/lyh916/article/details/51146693

上一篇基本实现了更新下载，很多时候，我们还需要将更新文件数，下载速度等信息显示在界面上，所以这篇就说下怎么做。

效果图：

Ps：上面的下载速度为Infinity(无穷大)，具体原因不明，估计是我使用的是编辑器链接本地服务器，而且更新的文件很小，所以就快得飞起吧！

分析：

这里我把它分为两部分：

a.信息的获取：其实上面显示的信息，都可以通过GameManager.cs获取到。

b.信息的显示：在GameManager.cs中，我们可以发现，当获取到消息后，就会通过facade.SendMessageCommand把消息进行发送，然后被AppView.cs进行捕获处理。

因此目标就很明确了：修改GameManager和AppView。

1.首先，看下facade.SendMessageCommand，它可以发送各种的消息，消息的定义在NotiConst.cs。这里我们把消息的种类扩充一下。

using UnityEngine;
using System.Collections;

public class NotiConst
{
    /// <summary>
    /// Controller层消息通知
    /// </summary>
    public const string START_UP = "StartUp";                       //启动框架
    public const string DISPATCH_MESSAGE = "DispatchMessage";       //派发信息

    /// <summary>
    /// View层消息通知
    /// </summary>
    
    //解包要展示的相关参数
	public const string EXTRACT_FILE_NAME = "EXTRACT_FILE_NAME";           //解包文件名
	public const string EXTRACT_FINISH_ONE = "EXTRACT_FINISH_ONE";         //解包完一个文件   
	public const string EXTRACT_ALL_COUNT = "EXTRACT_ALL_COUNT";           //解包总文件数
	
	//更新要展示的相关参数
    public const string UPDATE_SPEED = "UPDATE_SPEED";                     //下载速度
	public const string UPDATE_FILE_NAME = "UPDATE_FILE_NAME";             //下载文件名
	public const string UPDATE_FINISH_ONE = "UPDATE_FINISH_ONE";           //下载完一个文件
	public const string UPDATE_ALL_COUNT = "UPDATE_ALL_COUNT";             //下载总文件数

    //线程相关
    public const string THREAD_EXTRACT = "THREAD_EXTRACT";                   //线程解包
    public const string THREAD_DOWNLOAD = "THREAD_DOWNLOAD";                 //线程下载
}

2.然后就是准备好解包和更新的参数，并把这些参数发送出去。

修改GameManager.cs

using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;
using LuaInterface;
using System.Reflection;
using System.IO;

namespace LuaFramework {
    public class GameManager : Manager {
        protected static bool initialize = false;
        private List<string> downloadFiles = new List<string>();

        /// <summary>
        /// 初始化游戏管理器
        /// </summary>
        void Awake() {
            Init();
        }

        /// <summary>
        /// 初始化
        /// </summary>
        void Init() {
            if (AppConst.ExampleMode) {
                InitGui();
            }
            DontDestroyOnLoad(gameObject);  //防止销毁自己

            CheckExtractResource(); //释放资源
            Screen.sleepTimeout = SleepTimeout.NeverSleep;
            Application.targetFrameRate = AppConst.GameFrameRate;
        }

        /// <summary>
        /// 初始化GUI
        /// </summary>
        public void InitGui() {
            string name = "UI Root";
            GameObject gui = GameObject.Find(name);
            if (gui != null) return;

            GameObject prefab = Util.LoadPrefab(name);
            gui = Instantiate(prefab) as GameObject;
            gui.name = name;
        }

        /// <summary>
        /// 释放资源
        /// </summary>
        public void CheckExtractResource() {
            hadExtractResource = Directory.Exists(Util.DataPath) &&
              Directory.Exists(Util.DataPath + "lua/") && File.Exists(Util.DataPath + "files.txt");
            if (hadExtractResource || AppConst.DebugMode)
            {
                ResManager.initialize(OnResourceInited);
                //StartCoroutine(OnUpdateResource());//在第二次解包后就更新
                return;   //文件已经解压过了，自己可添加检查文件列表逻辑
            }
            StartCoroutine(OnExtractResource());    //启动释放协成 
        }

        bool hadExtractResource;
        bool firstExtractResource = true;

        IEnumerator OnExtractResource() {
            string dataPath = Util.DataPath;  //数据目录
            string resPath = Util.AppContentPath(); //游戏包资源目录

            string infile = resPath + "files.txt";
            string outfile = dataPath + "files.txt";
            string message = "";

            if (firstExtractResource)
            {
                //创建Util.DataPath目录
                if (Directory.Exists(dataPath)) Directory.Delete(dataPath, true);
                Directory.CreateDirectory(dataPath);

                if (File.Exists(outfile)) File.Delete(outfile);

                //解包files.txt
                message = "正在解包文件:>files.txt";
                Debug.Log("正在解包文件:>files.txt");
                //facade.SendMessageCommand(NotiConst.EXTRACT_FILE_NAME, message);

                if (Application.platform == RuntimePlatform.Android)
                {
                    WWW www = new WWW(infile);
                    yield return www;

                    if (www.isDone)
                    {
                        File.WriteAllBytes(outfile, www.bytes);
                    }
                    yield return 0;
                }
                else File.Copy(infile, outfile, true);
                //yield return new WaitForEndOfFrame();
            }

            List<string> willExtractFileName = new List<string>();

            //释放文件到数据目录，过滤要解包的文件
            string[] files = File.ReadAllLines(outfile);
            foreach (var file in files) 
            {
                string[] fs = file.Split('|');
                infile = resPath + fs[0];  
                outfile = dataPath + fs[0];

                //start是主界面的包，需要自行修改
                bool a = fs[0].StartsWith("lua/") || fs[0].StartsWith("StreamingAssets") ||fs[0].StartsWith("start");
                if (firstExtractResource && !a) continue;
                if (!firstExtractResource && a) continue;

                //message = "正在解包文件:>" + fs[0];
                //Debug.Log("正在解包文件:>" + infile);
                //facade.SendMessageCommand(NotiConst.EXTRACT_FILE_NAME, fs[0]);

                string dir = Path.GetDirectoryName(outfile);
                if (!Directory.Exists(dir)) Directory.CreateDirectory(dir);

                willExtractFileName.Add(fs[0]);
            }

            //第二次解包才显示信息
            if (!firstExtractResource && (willExtractFileName.Count > 0)) 
                facade.SendMessageCommand(NotiConst.EXTRACT_ALL_COUNT, willExtractFileName.Count);

            for (int i = 0; i < willExtractFileName.Count; i++)
			{
                Debug.Log("正在解包：" + willExtractFileName[i]);
                string from = resPath + willExtractFileName[i];
                string to = dataPath + willExtractFileName[i];

                if (Application.platform == RuntimePlatform.Android)
                {
                    if (!firstExtractResource) facade.SendMessageCommand(NotiConst.EXTRACT_FILE_NAME, willExtractFileName[i]);

                    WWW www = new WWW(from);
                    yield return www;

                    if (www.isDone)
                    {
                        File.WriteAllBytes(to, www.bytes);
                        if (!firstExtractResource) facade.SendMessageCommand(NotiConst.EXTRACT_FINISH_ONE, 0);
                    }
                    yield return 0;
                }
                else
                {
                    if (File.Exists(to))
                    {
                        File.Delete(to);
                    }
                    if (!firstExtractResource) facade.SendMessageCommand(NotiConst.EXTRACT_FILE_NAME, willExtractFileName[i]);
                    File.Copy(from, to, true);
                    if (!firstExtractResource) facade.SendMessageCommand(NotiConst.EXTRACT_FINISH_ONE, 0);
                }
                yield return new WaitForEndOfFrame();
			}
;               
            
            if (firstExtractResource)
            {
                ResManager.initialize(OnResourceInited);
            }
            else
            {
                message = "解包完成!!!";
                //facade.SendMessageCommand(NotiConst.UPDATE_MESSAGE, message);

                //释放完成，开始启动更新资源
                StartCoroutine(OnUpdateResource());
            }

            yield return new WaitForSeconds(0.1f);
            message = string.Empty;
        }

        /// <summary>
        /// 启动更新下载，这里只是个思路演示，此处可启动线程下载更新
        /// </summary>
        IEnumerator OnUpdateResource() {
            downloadFiles.Clear();

            if (!AppConst.UpdateMode) {
                //ResManager.initialize(OnResourceInited);
                yield break;
            }
            string dataPath = Util.DataPath;  //数据目录
            string url = AppConst.WebUrl;
            string random = DateTime.Now.ToString("yyyymmddhhmmss");
            string listUrl = url + "files.txt?v=" + random;
            Debug.LogWarning("LoadUpdate---->>>" + listUrl);

            WWW www = new WWW(listUrl); yield return www;
            if (www.error != null) {
                OnUpdateFailed(string.Empty);
                yield break;
            }
            if (!Directory.Exists(dataPath)) {
                Directory.CreateDirectory(dataPath);
            }
            File.WriteAllBytes(dataPath + "files.txt", www.bytes);

            string filesText = www.text;
            string[] files = filesText.Split('\n');

            List<string> willDownLoadUrl = new List<string>();//from
            List<string> willDownLoadFileName = new List<string>();
            List<string> willDownLoadDestination = new List<string>();//to

            string message = string.Empty;
            for (int i = 0; i < files.Length; i++) 
            {
                if (string.IsNullOrEmpty(files[i])) continue;
                string[] keyValue = files[i].Split('|');
                string f = keyValue[0];
                string localfile = (dataPath + f).Trim();
                string path = Path.GetDirectoryName(localfile);
                if (!Directory.Exists(path)) {
                    Directory.CreateDirectory(path);
                }
                string fileUrl = url + keyValue[0] + "?v=" + random;
                bool canUpdate = !File.Exists(localfile);
                if (!canUpdate) {
                    string remoteMd5 = keyValue[1].Trim();
                    string localMd5 = Util.md5file(localfile);
                    canUpdate = !remoteMd5.Equals(localMd5);
                    if (canUpdate) File.Delete(localfile);
                }
                if (canUpdate) {   //本地缺少文件
                    //Debug.Log(fileUrl);
                    //message = "downloading>>" + fileUrl;
                    //facade.SendMessageCommand(NotiConst.UPDATE_MESSAGE, message);
                    /*
                    www = new WWW(fileUrl); yield return www;
                    if (www.error != null) {
                        OnUpdateFailed(path);   //
                        yield break;
                    }
                    File.WriteAllBytes(localfile, www.bytes);
                     * */
                    willDownLoadUrl.Add(fileUrl);//下载地址
                    willDownLoadFileName.Add(keyValue[0]);
                    willDownLoadDestination.Add(localfile);//目标文件路径
                }
            }

            if (willDownLoadUrl.Count > 0) facade.SendMessageCommand(NotiConst.UPDATE_ALL_COUNT, willDownLoadUrl.Count);
            for (int i = 0; i < willDownLoadUrl.Count; i++)
            {
                Debug.Log("要下载的文件：" + willDownLoadUrl[i]);
                //这里都是资源文件，用线程下载
                facade.SendMessageCommand(NotiConst.UPDATE_FILE_NAME, willDownLoadFileName[i]);
                BeginDownload(willDownLoadUrl[i], willDownLoadDestination[i]);
                //while (!(IsDownOK(willDownLoadDestination[i]))) { yield return new WaitForEndOfFrame(); }
            }
            yield return new WaitForEndOfFrame();
            message = "更新完成!!";
            //facade.SendMessageCommand(NotiConst.UPDATE_MESSAGE, message);

            //ResManager.initialize(OnResourceInited);
        }

        /// <summary>
        /// 是否下载完成
        /// </summary>
        bool IsDownOK(string file) {
            return downloadFiles.Contains(file);
        }

        /// <summary>
        /// 线程下载
        /// </summary>
        void BeginDownload(string url, string file) {     //线程下载
            object[] param = new object[2] {url, file};

            ThreadEvent ev = new ThreadEvent();
            ev.Key = NotiConst.THREAD_DOWNLOAD;
            ev.evParams.AddRange(param);
            ThreadManager.AddEvent(ev, OnThreadCompleted);   //线程下载
        }

        /// <summary>
        /// 线程完成
        /// </summary>
        /// <param name="data"></param>
        void OnThreadCompleted(NotiData data) {
            switch (data.evName) {
                case NotiConst.THREAD_EXTRACT:  //解压一个完成
                    //
                break;
                case NotiConst.THREAD_DOWNLOAD: //下载一个完成
                    downloadFiles.Add(data.evParam.ToString());
                break;
            }
        }

        void OnUpdateFailed(string file) {
            string message = "更新失败!>" + file;
            Debug.Log(message);
            //facade.SendMessageCommand(NotiConst.UPDATE_MESSAGE, message);
        }

        /// <summary>
        /// 资源初始化结束
        /// </summary>
        public void OnResourceInited() {
            LuaManager.InitStart();
            LuaManager.DoFile("Logic/Game");            //加载游戏
            LuaManager.DoFile("Logic/Network");         //加载网络
            NetManager.OnInit();                        //初始化网络

            Util.CallMethod("Game", "OnInitOK");          //初始化完成
            initialize = true;                          //初始化完 

            //类对象池测试
            var classObjPool = ObjPoolManager.CreatePool<TestObjectClass>(OnPoolGetElement, OnPoolPushElement);
            //方法1
            //objPool.Release(new TestObjectClass("abcd", 100, 200f));
            //var testObj1 = objPool.Get();

            //方法2
            ObjPoolManager.Release<TestObjectClass>(new TestObjectClass("abcd", 100, 200f));
            var testObj1 = ObjPoolManager.Get<TestObjectClass>();

            Debugger.Log("TestObjectClass--->>>" + testObj1.ToString());

            //游戏对象池测试
            var prefab = Resources.Load("TestGameObjectPrefab", typeof(GameObject)) as GameObject;
            var gameObjPool = ObjPoolManager.CreatePool("TestGameObject", 5, 10, prefab);

            var gameObj = Instantiate(prefab) as GameObject;
            gameObj.name = "TestGameObject_01";
            gameObj.transform.localScale = Vector3.one;
            gameObj.transform.localPosition = Vector3.zero;

            ObjPoolManager.Release("TestGameObject", gameObj);
            var backObj = ObjPoolManager.Get("TestGameObject");
            backObj.transform.SetParent(null);

            Debug.Log("TestGameObject--->>>" + backObj);

            if (hadExtractResource)
            {
                StartCoroutine(OnUpdateResource());
            }
            else
            {
                firstExtractResource = false;//进行二次解包
                hadExtractResource = true;
                StartCoroutine(OnExtractResource());
            }
        }

        /// <summary>
        /// 当从池子里面获取时
        /// </summary>
        /// <param name="obj"></param>
        void OnPoolGetElement(TestObjectClass obj) {
            Debug.Log("OnPoolGetElement--->>>" + obj);
        }

        /// <summary>
        /// 当放回池子里面时
        /// </summary>
        /// <param name="obj"></param>
        void OnPoolPushElement(TestObjectClass obj) {
            Debug.Log("OnPoolPushElement--->>>" + obj);
        }

        /// <summary>
        /// 析构函数
        /// </summary>
        void OnDestroy() {
            if (NetManager != null) {
                NetManager.Unload();
            }
            if (LuaManager != null) {
                LuaManager.Close();
            }
            Debug.Log("~GameManager was destroyed");
        }
    }
}

3.接着就是把信息显示出来了。

修改AppView.cs

using UnityEngine;
using LuaFramework;
using System.Collections.Generic;

public class AppView : View {
    private string message;

    ///<summary>
    /// 监听的消息
    ///</summary>
    List<string> MessageList {
        get {
            return new List<string>()
            { 
                NotiConst.EXTRACT_FILE_NAME,
                NotiConst.EXTRACT_FINISH_ONE,
                NotiConst.EXTRACT_ALL_COUNT,

                NotiConst.UPDATE_SPEED,
                NotiConst.UPDATE_FILE_NAME,
                NotiConst.UPDATE_FINISH_ONE,
                NotiConst.UPDATE_ALL_COUNT,
            };
        }
    }

    void Awake() {
        RemoveMessage(this, MessageList);
        RegisterMessage(this, MessageList);
    }

    /// <summary>
    /// 处理View消息
    /// </summary>
    /// <param name="message"></param>
    public override void OnMessage(IMessage message) {
        string name = message.Name;
        object body = message.Body;

        this.message = message.Name;
        switch (name) {
            case NotiConst.EXTRACT_FILE_NAME:
                extractFileName = body.ToString();
            break;

            case NotiConst.EXTRACT_FINISH_ONE:
                extractNowCount++;
            break;

            case NotiConst.EXTRACT_ALL_COUNT:
                extractAllCount = (int)body;
            break;

            case NotiConst.UPDATE_SPEED:
                updateSpeed = body.ToString();
            break;

            case NotiConst.UPDATE_FILE_NAME:
                updateFileName = body.ToString();
            break;

            case NotiConst.UPDATE_FINISH_ONE:
                updateNowCount++;
            break;

            case NotiConst.UPDATE_ALL_COUNT:
                updateAllCount = (int)body;
            break;
        }
    }

    string extractFileName;
    int extractNowCount = 0;
    int extractAllCount = 0;

    string updateFileName;
    int updateNowCount = 0;
    int updateAllCount = 0;
    string updateSpeed;

    void OnGUI()
    {
        if (string.IsNullOrEmpty(message)) return;
        if (message.StartsWith("EXTRACT_"))
        {
            GUILayout.Label("正在解包的文件：" + extractFileName);
            GUILayout.Label("当前解包数：" + extractNowCount);
            GUILayout.Label("总的解包数：" + extractAllCount);
        }
        else if (message.StartsWith("UPDATE_"))
        {
            GUILayout.Label("正在下载的文件：" + updateFileName);
            GUILayout.Label("当前下载数：" + updateNowCount);
            GUILayout.Label("总的下载数：" + updateAllCount);
            GUILayout.Label("下载速度：" + updateSpeed);
        }
        
    }

}

4.最后，因为消息类型变了，所以还要修改ThreadManager.cs

using System.Collections;
using System.Threading;
using System.Collections.Generic;
using System.IO;
using System.Diagnostics;
using System.Net;
using System;
using Debug = UnityEngine.Debug;

public class ThreadEvent {
    public string Key;
    public List<object> evParams = new List<object>();
}

public class NotiData {
    public string evName;
    public object evParam;

    public NotiData(string name, object param) {
        this.evName = name;
        this.evParam = param;
    }
}

namespace LuaFramework {
    /// <summary>
    /// 当前线程管理器，同时只能做一个任务
    /// </summary>
    public class ThreadManager : Manager {
        private Thread thread;
        private Action<NotiData> func;
        private Stopwatch sw = new Stopwatch();
        private string currDownFile = string.Empty;

        static readonly object m_lockObj = new object();
        static Queue<ThreadEvent> events = new Queue<ThreadEvent>();

        delegate void ThreadSyncEvent(NotiData data);
        private ThreadSyncEvent m_SyncEvent;

        void Awake() {
            m_SyncEvent = OnSyncEvent;
            thread = new Thread(OnUpdate);
        }

        // Use this for initialization
        void Start() {
            thread.Start();
        }

        /// <summary>
        /// 添加到事件队列
        /// </summary>
        public void AddEvent(ThreadEvent ev, Action<NotiData> func) {
            lock (m_lockObj) {
                this.func = func;
                events.Enqueue(ev);
            }
        }

        /// <summary>
        /// 通知事件
        /// </summary>
        /// <param name="state"></param>
        private void OnSyncEvent(NotiData data) {
            if (this.func != null) func(data);  //回调逻辑层
            facade.SendMessageCommand(data.evName, data.evParam); //通知View层
        }

        // Update is called once per frame
        void OnUpdate() {
            while (true) {
                lock (m_lockObj) {
                    if (events.Count > 0) {
                        ThreadEvent e = events.Dequeue();
                        try {
                            switch (e.Key) {
                                case NotiConst.THREAD_EXTRACT: {     //解压文件
                                    OnExtractFile(e.evParams);
                                }
                                break;
                                case NotiConst.THREAD_DOWNLOAD: {    //下载文件
                                    OnDownloadFile(e.evParams);
                                }
                                break;
                            }
                        } catch (System.Exception ex) {
                            UnityEngine.Debug.LogError(ex.Message);
                        }
                    }
                }
                Thread.Sleep(1);
            }
        }

        /// <summary>
        /// 下载文件
        /// </summary>
        void OnDownloadFile(List<object> evParams) {
            string url = evParams[0].ToString();    
            currDownFile = evParams[1].ToString();

            using (WebClient client = new WebClient()) {
                sw.Start();
                client.DownloadProgressChanged += new DownloadProgressChangedEventHandler(ProgressChanged);
                client.DownloadFileAsync(new System.Uri(url), currDownFile);
            }
        }

        private void ProgressChanged(object sender, DownloadProgressChangedEventArgs e) {
            //UnityEngine.Debug.Log(e.ProgressPercentage);
            /*
            UnityEngine.Debug.Log(string.Format("{0} MB's / {1} MB's",
                (e.BytesReceived / 1024d / 1024d).ToString("0.00"),
                (e.TotalBytesToReceive / 1024d / 1024d).ToString("0.00")));
            */
            //float value = (float)e.ProgressPercentage / 100f;

            string value = string.Format("{0} kb/s", (e.BytesReceived / 1024d / sw.Elapsed.TotalSeconds).ToString("0.00"));
            NotiData data = new NotiData(NotiConst.UPDATE_SPEED, value);
            if (m_SyncEvent != null) m_SyncEvent(data);

            if (e.ProgressPercentage == 100 && e.BytesReceived == e.TotalBytesToReceive)
            {
                sw.Reset();

                data = new NotiData(NotiConst.UPDATE_FINISH_ONE, 0);
                if (m_SyncEvent != null) m_SyncEvent(data);
            }
        }

        /// <summary>
        /// 调用方法
        /// </summary>
        void OnExtractFile(List<object> evParams) {
            Debugger.LogWarning("Thread evParams: >>" + evParams.Count);

            ///------------------通知更新面板解压完成--------------------
            //NotiData data = new NotiData(NotiConst.UPDATE_DOWNLOAD, null);
            //if (m_SyncEvent != null) m_SyncEvent(data);
        }

        /// <summary>
        /// 应用程序退出
        /// </summary>
        void OnDestroy() {
            thread.Abort();
        }
    }
}

   <style name="noActionbarTheme" parent="Theme.AppCompat.Light.DarkActionBar">
        <!-- 设置不显示ActionBar -->
        <item name="windowActionBar">false</item>
        <!--设置不显示title-->
        <item name="windowNoTitle">true</item>

    </style>

 android:theme="@style/Theme.AppCompat.NoActionBar"
 android:theme="@style/Theme.AppCompat.Light.NoActionBar"      

     隐藏效果    

package com.example.androiduiappbar;

import android.support.v7.app.ActionBar;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //实例化ActionBar，注意为了向下兼容我们使用了support.v7.app.ActionBar
        ActionBar actionBar = getSupportActionBar();
        //隐藏ActionBar
        actionBar.hide();
    }
}

   <style name="myTheme" parent="Theme.AppCompat.Light.DarkActionBar">
        <!-- 设置不显示ActionBar -->
       <!--<item name="windowActionBar">false</item>-->
       <!--设置不显示title-->
        <!--  <item name="windowNoTitle">true</item>-->
        <!--ActionBar颜色-->
        <item name="colorPrimary">@color/colorAccent</item>
        <!--状态栏颜色-->
        <item name="colorPrimaryDark">@color/accent_material_light</item>
        <!--设置window中控件的,比如：checkbox、switch等checked或selected时的颜色-->
        <item name="colorAccent">@color/colorAccent1</item>
        <!--设置window布局背景色-->
        <item name="android:windowBackground">@color/dim_foreground_material_dark</item>
    </style>

<application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/myTheme"
        >

    3)效果截图：

<resources>

    <!-- Base application theme. -->
    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
        <!-- Customize your theme here. -->
        <item name="colorPrimary">@color/colorPrimary</item>
        <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
        <item name="colorAccent">@color/colorAccent</item>
    </style>

    <!--自定义无Actionbar的主题-->
    <style name="noActionbarTheme" parent="Theme.AppCompat.Light.DarkActionBar">
        <!-- 设置不显示ActionBar -->
        <item name="windowActionBar">false</item>
        <!--设置不显示title-->
        <item name="windowNoTitle">true</item>
    </style>

</resources>

 <activity android:name=".SecondActivity" android:theme="@style/noActionbarTheme">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
</activity>    

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.example.androiduiappbar.SecondActivity">
     <!--
     android:background="":可设置toolbar的背景
     -->   
    <android.support.v7.widget.Toolbar
        android:id="@+id/toolBar"
        android:layout_height="?attr/actionBarSize"
        android:layout_width="match_parent"
        android:background="@color/colorAccent1"
        />
<ImageView
    android:layout_below="@+id/toolBar"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@drawable/pinkgirl"/>
</RelativeLayout>

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    xmlns:android="http://schemas.android.com/apk/res/android"
    tools:context=".SecondActivity">
    <!--
    属性用法:
     android:title=""：设置自定义action的标题文字，放入action flow中时只显示文字
     android:orderInCategory=""：表示action在app bar上显示的顺序，值越小越靠前
     android:icon=""：设置显示的图标
     app:showAsAction="ifRoom":设置显示的位置，ifRoom（有空间显示，没空间显示到overflow）
        never（一直显示到overflow），alaways（一直显示在app bar上），
        withText（设置图标和文字一起显示）
    -->
    <!--查询按钮-->
   <item android:id="@+id/action_serach"
        android:title="@string/action_search"
        android:orderInCategory="1"
       android:icon="@drawable/search_24"
        app:showAsAction="ifRoom"
        />
    <!--分享-->
    <item android:id="@+id/action_share"
        android:title="@string/action_share"
        android:orderInCategory="2"
        app:showAsAction="ifRoom"
        android:icon="@drawable/share_24"
        />
    <!--设置-->
    <item android:id="@+id/action_setting"
        android:title="@string/action_setting"
        android:orderInCategory="3"
        app:showAsAction="never"
        android:icon="@drawable/back"
        />
    <!--更多-->
    <item android:id="@+id/action_more"
        android:title="@string/action_more"
        android:orderInCategory="4"
        app:showAsAction="never"
        android:icon="@drawable/share_24b"
        />
</menu>

package com.example.androiduiappbar;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.util.Log;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.widget.Toast;

public class SecondActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);
        Toolbar toolbar = (Toolbar) findViewById(R.id.toolBar);
        //设置应用图标
        toolbar.setLogo(R.mipmap.ic_launcher);
        //设置标题，也可在xml中实现toolbar:title="标题"
        toolbar.setTitle("标题");
        //设置子标题
        toolbar.setSubtitle("子标题");
        //设置导航图标
        toolbar.setNavigationIcon(R.drawable.back);
        //设置toolbar
        //注意这句代码必须放在自定义按钮监听和设置导航条Icon之前
        setSupportActionBar(toolbar);
        //自定义去的按钮点击监听
        toolbar.setOnMenuItemClickListener(new Toolbar.OnMenuItemClickListener() {
            @Override
            public boolean onMenuItemClick(MenuItem item) {
                switch (item.getItemId()){
                    case R.id.action_serach:
                        Log.d("ItemId",item.getItemId()+"");
                        Toast.makeText(SecondActivity.this,"你点击了搜索！",Toast.LENGTH_SHORT).show();
                        break;
                    case R.id.action_share:
                        Log.d("ItemId",item.getItemId()+"");
                        Toast.makeText(SecondActivity.this,"你点击了分享！",Toast.LENGTH_SHORT).show();
                        break;
                    case R.id.action_setting:
                        Log.d("ItemId",item.getItemId()+"");
                        Toast.makeText(SecondActivity.this,"你点击了设置！",Toast.LENGTH_SHORT).show();
                        break;
                    case R.id.action_more:
                        Log.d("ItemId",item.getItemId()+"");
                        Toast.makeText(SecondActivity.this,"你点击了更多！",Toast.LENGTH_SHORT).show();
                        break;
                    default:
                        Log.d("ItemId",item.getItemId()+"");
                        break;
                }

                return false;
            }
        });

        //设置导航按钮监听
        toolbar.setNavigationOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Toast.makeText(SecondActivity.this,"你点击了导航按钮！",Toast.LENGTH_SHORT).show();
            }
        });
    }
    /*
    * 继承实现onCreateOptionsMenu方法实例化inflater去加载布局
    * 另一种方法是通过toolbar.inflateMenu(R.menu.toolbar_menu);
    * */

    @Override
    public boolean onCreateOptionsMenu(Menu menu){
        MenuInflater inflater =getMenuInflater();
        inflater.inflate(R.menu.toolbar_menu,menu);
        return super.onCreateOptionsMenu(menu);
    }
}

ps:需要用support v7里面的toolbar，否则只有API 21(Android 5.0)以上才能使用
    
    5)效果截图(原谅我花痴的用了一张萌妹纸的照片，贼笑.jpg)
    
    
    4.3 一些问题？（标题/子标题/overflow文字的颜色和字体+overflow icon设置和flow menu背景等）    
    1)标题/子标题的颜色字体设置
    java代码设置:

  
        //子标题颜色和字体设置，因为Theme_Toolbar_Title中已经设置字体颜色所以setTitleTextAppearance可以不用    
        //toolbar.setTitleTextColor(R.color.colorAccent);
        toolbar.setTitleTextAppearance(SecondActivity.this,R.style.Theme_Toolbar_Title);
        //子标题颜色和字体设置，因为Theme_Toolbar_Subtitle中已经设置字体颜色所以setSubtitleTextColor可以不用
        //toolbar.setSubtitleTextColor(getResources().getColor(android.R.color.holo_blue_light));
        toolbar.setSubtitleTextAppearance(SecondActivity.this,R.style.Theme_Toolbar_Subtitle);

       <!--标题文字颜色和字体大小-->
        <style name="Theme_Toolbar_Title" parent="@style/TextAppearance.Widget.AppCompat.Toolbar.Title">
            <item name="android:textSize">20dp</item>
            <item name="android:textColor">@color/colorAccent</item>
        </style>
        <!--子标题文字颜色和字体大小-->
        <style name="Theme_Toolbar_Subtitle" parent="@style/TextAppearance.Widget.AppCompat.Toolbar.Subtitle">
            <item name="android:textSize">18dp</item>
            <item name="android:textColor">@color/colorAccent</item>
        </style>

    <style name="PopupOverflow" parent="@style/ThemeOverlay.AppCompat.Dark">
        <item name="android:textColorPrimary">@color/textcolorPrimary</item>
        <item name="android:textSize">16sp</item>
        <item name="android:background">@color/textColor</item>
    </style>

        <android.support.v7.widget.Toolbar
            android:id="@+id/toolBar"
            android:layout_height="?attr/actionBarSize"
            android:layout_width="match_parent"
            android:background="@color/colorAccent1"
            app:popupTheme="@style/PopupOverflow"
            />

        <style name="customOverflowButtonStyle" parent="android:style/Widget.Holo.Light.ActionButton.Overflow">
            <item name="android:src">@drawable/expand_more_24</item>
        </style>

        <!--自定义无Actionbar的主题-->
        <style name="noActionbarTheme" parent="Theme.AppCompat.Light.DarkActionBar">
            <!-- 设置不显示ActionBar -->
            <item name="windowActionBar">false</item>
            <!--设置不显示title-->
            <item name="windowNoTitle">true</item>
            <!--引用自定义图标style-->
            <item name="actionOverflowButtonStyle">@style/customOverflowButtonStyle</item>
        </style>

    
    4)效果截图(可与更改之前的对比)
    
    
    参考：http://www.jcodecraeer.com/a/anzhuokaifa/androidkaifa/2014/1118/2006.html   

本文只是给大家提供一个思路，如果能提升工作效率那最好了。

• shift + command + a
  查找动作

如上，我们可以快捷的打开java autoimport开关

• shift + shift
  全局查找

可以方便的查找资源文件、类等

• control + space
  代码提示

这个估计是IDE的最强feature了吧

• shift + control + space
  根据类型提示

根据需要的类型提示，这个还是挺实用的

• command + d
  复制一整行

• alt + right/left
  单词为单位移动光标

同时按住shift的话就可以在行内灵活选择了

• alt + up/down
  多行选择 扩大/缩小

• shift + alt + up/down
  移动当前行或选中的代码

• tab
  使用tab代替enter可以替换之前的代码

• 使用模板

as提供了很多模板，更多去设置中live templates中查看吧。

• 自定义模板

使用时只要使用缩写就能很方便的生成代码了。

• 给断点设置表达式
  左键设置断点，右键唤出菜单

debug运行后，会在console中打印表达式的值

• 结构化查找
  按照模板查找代码

• 结构化检查
  按照指定模板检查代码，可以指定警告级别

• 结构化替换

关于Java和Android大牛频道

Java和Android大牛频道是一个数万人关注的探讨Java和Android开发的公众号，分享和原创最有价值的干货文章，让你成为这方面的大牛！

我们探讨android和Java开发最前沿的技术：android性能优化 ，插件化，动态化，跨平台，动态化，加固和反破解等，也讨论设计模式／软件架构等。由一群来自BAT的工程师组成的团队。

关注即送红包，回复：“百度” 、“阿里”、“腾讯” 有惊喜！！！关注后可用入微信群。群里都是来自百度阿里腾讯的大牛。

欢迎关注我们，一起讨论技术，扫描和长按下方的二维码可快速关注我们。或搜索微信公众号:JANiubility。

公众号：JANiubility

如想加群讨论学习，请关注微信公众号点击右下角的“加群学习”菜单入群。

Android 仿微信的键盘切换

Android 仿微信的键盘切换（录音，表情，文字，其他），IM通讯，类似朋友圈只要涉及到文字等相关的app都会要涉及到键盘的处理，今天就给大家分享一下Android 仿微信的键盘切换。

效果图如下：

Android 仿微信的键盘切换，实现了录音、表情、其他和软键盘显示之间的切换，其中解决了很多博客介绍的键盘切换时，软键盘显示切换到表情（其他）时，出现屏幕晃动的情况，以及点击和滑动键盘显示区域外时，软键盘隐藏的功能等，废话不多说直接上代码，以供大家参考：

xml:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/linearlayout_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/M323535"
    android:fitsSystemWindows="true"
    android:orientation="vertical"
    tools:context=".ui.activity.ChatActivity">

    <RelativeLayout
        android:id="@+id/layout_title"
        android:layout_width="match_parent"
        android:layout_height="@dimen/dp44"
        android:background="@color/title_bar"
        android:orientation="horizontal">

        <ImageView
            android:id="@+id/img_finish"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerVertical="true"
            android:layout_marginLeft="@dimen/dp3"
            android:layout_marginStart="@dimen/dp3"
            android:background="@drawable/select_image_finsh"
            android:contentDescription="@null" />

        <TextView
            android:id="@+id/txt_finish"
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            android:layout_gravity="center"
            android:layout_toEndOf="@+id/img_finish"
            android:layout_toRightOf="@+id/img_finish"
            android:gravity="center"
            android:text="@string/img_finish"
            android:textColor="@drawable/text_selector"
            android:textSize="18sp" />

        <TextView
            android:id="@+id/txt_im_object_name"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:layout_gravity="center"
            android:clickable="false"
            android:gravity="center"
            android:textColor="@color/MFFCE00"
            android:textSize="@dimen/sp20" />


    </RelativeLayout>

    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_above="@+id/keyboardListenRelativeLayout"
        android:layout_below="@+id/layout_title">

        <ListView
            android:id="@+id/listView"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:divider="@null" />

        <!--<com.motoband.ui.Voice.RecordButton-->
            <!--android:id="@+id/btn_record"-->
            <!--android:layout_width="match_parent"-->
            <!--android:layout_height="wrap_content"-->
            <!--android:layout_alignParentBottom="true"-->
            <!--android:layout_centerHorizontal="true"-->
            <!--/>-->

        <!--//语音-->
        <RelativeLayout
            android:id="@+id/layout_voice"
            android:layout_width="@dimen/dp200"
            android:layout_height="@dimen/dp200"
            android:layout_centerInParent="true"
            android:visibility="gone">

            <ImageView
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:background="@drawable/chat_window_backgroud"
                android:contentDescription="@null" />

            <ImageView
                android:id="@+id/img_im_microphone_state"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_centerHorizontal="true"
                android:layout_marginTop="@dimen/dp16"
                android:background="@mipmap/im_microphone"
                android:contentDescription="@null" />

            <ImageView
                android:id="@+id/img_im_microphone_sound_size"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_below="@+id/img_im_microphone_state"
                android:layout_centerHorizontal="true"
                android:layout_marginTop="@dimen/dp11"
                android:background="@mipmap/chat_volume_06"
                android:contentDescription="@null" />


            <TextView
                android:id="@+id/txt_im_microphone_show_text"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_below="@+id/img_im_microphone_sound_size"
                android:layout_centerHorizontal="true"
                android:layout_marginTop="@dimen/dp26"
                android:contentDescription="@null"
                android:text="@string/slide_to_cancel_sending"
                android:textColor="@color/M3C3C3C"
                android:textSize="@dimen/sp16" />


        </RelativeLayout>

        <!--<TextView-->
            <!--android:id="@+id/txt_start"-->
            <!--android:layout_width="match_parent"-->
            <!--android:layout_height="@dimen/dp44"-->
            <!--android:background="@color/M44C494"-->
            <!--android:text="播放语音"-->
            <!--/>-->

    </RelativeLayout>


    <com.motoband.ui.view.KeyboardListenRelativeLayout
        android:id="@+id/keyboardListenRelativeLayout"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_alignParentBottom="true">

        <ScrollView
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:fillViewport="true">

            <RelativeLayout
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:orientation="vertical">

                <!--发布评论-->
                <LinearLayout
                    android:id="@+id/layout_release"
                    android:layout_width="match_parent"
                    android:layout_height="wrap_content"
                    android:background="@color/M575A5B"
                    android:orientation="horizontal"
                    tools:ignore="UselessParent">

                    <ImageView
                        android:id="@+id/img_voice"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:layout_gravity="center"
                        android:layout_marginLeft="@dimen/dp12"
                        android:layout_marginStart="@dimen/dp12"
                        android:contentDescription="@null" />

                    <!--//文字  与录音-->
                    <RelativeLayout
                        android:layout_width="match_parent"
                        android:layout_height="wrap_content"
                        android:layout_weight="1">

                        <com.motoband.ui.view.MyEditText
                            android:id="@+id/txt_im_message"
                            android:layout_width="280dp"
                            android:layout_height="@dimen/dp30"
                            android:layout_gravity="center_vertical"
                            android:layout_marginBottom="@dimen/dp8"
                            android:layout_marginLeft="@dimen/dp15"
                            android:layout_marginStart="@dimen/dp15"
                            android:layout_marginTop="@dimen/dp8"
                            android:background="@drawable/shape_d8d8d8"
                            android:gravity="start|top"
                            android:hint="@string/say_some"

                            android:imeOptions="actionDone"

                            android:inputType="textMultiLine"
                            android:maxLines="6"
                            android:paddingBottom="@dimen/dp7"
                            android:paddingLeft="@dimen/dp7"

                            android:paddingRight="@dimen/dp7"
                            android:paddingTop="@dimen/dp7"
                            android:singleLine="false"
                            android:textColor="@color/M828282"
                            android:textColorHint="@color/M828282"
                            android:textCursorDrawable="@drawable/shape_cursor_color"
                            android:textSize="@dimen/sp12"

                            />

                        <TextView
                            android:id="@+id/txt_record"
                            android:layout_width="match_parent"
                            android:layout_height="@dimen/dp30"
                            android:layout_marginBottom="@dimen/dp8"
                            android:layout_marginLeft="@dimen/dp15"
                            android:layout_marginStart="@dimen/dp15"
                            android:layout_marginTop="@dimen/dp8"
                            android:background="@drawable/shape_im_chat_voice_up"
                            android:gravity="center"
                            android:paddingBottom="@dimen/dp7"
                            android:paddingLeft="@dimen/dp7"
                            android:paddingRight="@dimen/dp7"
                            android:paddingTop="@dimen/dp7"
                            android:text="@string/txt_record"
                            android:visibility="gone" />

                    </RelativeLayout>


                    <ImageView
                        android:id="@+id/img_expression"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:layout_gravity="center"
                        android:layout_marginLeft="@dimen/dp12"
                        android:layout_marginStart="@dimen/dp12"

                        android:contentDescription="@null" />

                    <ImageView
                        android:id="@+id/img_other"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                        android:layout_gravity="center"
                        android:layout_marginEnd="@dimen/dp12"
                        android:layout_marginLeft="@dimen/dp12"
                        android:layout_marginRight="@dimen/dp12"
                        android:layout_marginStart="@dimen/dp12"
                        android:contentDescription="@null" />


                </LinearLayout>


                <!--//表情-->
                <RelativeLayout
                    android:id="@+id/layout_expression"
                    android:layout_width="match_parent"
                    android:layout_height="200dp"
                    android:layout_below="@+id/layout_release"
                    android:background="@color/MFFFFFF"
                    android:visibility="gone">

                    <android.support.v4.view.ViewPager
                        android:id="@+id/viewPager"
                        android:layout_width="match_parent"
                        android:layout_height="180dp" />

                    <LinearLayout
                        android:id="@+id/viewGroup"
                        android:layout_width="match_parent"
                        android:layout_height="wrap_content"
                        android:layout_alignParentBottom="true"
                        android:layout_marginBottom="@dimen/dp10"
                        android:background="@color/MFFFFFF"
                        android:gravity="center_horizontal"
                        android:orientation="horizontal"
                        android:paddingLeft="@dimen/dp20"
                        android:paddingRight="@dimen/dp20" />

                </RelativeLayout>

                <!--//其他  照片  拍摄   小视频  位置-->
                <RelativeLayout
                    android:id="@+id/layout_other"
                    android:layout_width="match_parent"
                    android:layout_height="200dp"
                    android:layout_below="@+id/layout_release"
                    android:background="@color/M323535"
                    android:visibility="gone">


                    <LinearLayout
                        android:id="@+id/layout_other_item"
                        android:layout_width="match_parent"
                        android:layout_height="wrap_content"
                        android:layout_marginTop="@dimen/dp25"
                        android:orientation="horizontal">

                        <ImageView
                            android:id="@+id/im_chat_poto"
                            android:layout_width="wrap_content"
                            android:layout_height="wrap_content"
                            android:layout_marginLeft="@dimen/dp16"
                            android:layout_marginStart="@dimen/dp16"
                            android:background="@mipmap/im_chat_poto"
                            android:contentDescription="@null" />

                        <ImageView
                            android:id="@+id/im_chat_camera"
                            android:layout_width="wrap_content"
                            android:layout_height="wrap_content"
                            android:layout_marginLeft="@dimen/dp16"
                            android:layout_marginStart="@dimen/dp16"
                            android:background="@mipmap/im_chat_camera"
                            android:contentDescription="@null" />

                        <ImageView
                            android:id="@+id/im_chat_video"
                            android:layout_width="wrap_content"
                            android:layout_height="wrap_content"
                            android:layout_marginLeft="@dimen/dp16"
                            android:layout_marginStart="@dimen/dp16"
                            android:background="@mipmap/im_chat_video"
                            android:contentDescription="@null" />

                        <ImageView
                            android:id="@+id/im_chat_location"
                            android:layout_width="wrap_content"
                            android:layout_height="wrap_content"
                            android:layout_marginLeft="@dimen/dp16"
                            android:layout_marginStart="@dimen/dp16"
                            android:background="@mipmap/im_chat_poto"
                            android:contentDescription="@null" />


                    </LinearLayout>


                    <LinearLayout
                        android:layout_width="match_parent"
                        android:layout_height="wrap_content"
                        android:layout_below="@+id/layout_other_item"
                        android:layout_marginEnd="@dimen/dp8"
                        android:layout_marginLeft="@dimen/dp8"
                        android:layout_marginRight="@dimen/dp8"
                        android:layout_marginStart="@dimen/dp8"
                        android:layout_marginTop="@dimen/dp7"
                        android:orientation="horizontal">

                        <TextView
                            android:layout_width="match_parent"
                            android:layout_height="wrap_content"
                            android:layout_gravity="center"
                            android:layout_weight="1"
                            android:gravity="center"
                            android:text="@string/newtype_photo"
                            android:textColor="@color/M969999"
                            android:textSize="@dimen/sp11" />


                        <TextView
                            android:layout_width="match_parent"
                            android:layout_height="wrap_content"
                            android:layout_gravity="center"
                            android:layout_weight="1"
                            android:gravity="center"
                            android:text="@string/select_takephoto"
                            android:textColor="@color/M969999"
                            android:textSize="@dimen/sp11" />

                        <TextView
                            android:layout_width="match_parent"
                            android:layout_height="wrap_content"
                            android:layout_gravity="center"
                            android:layout_weight="1"
                            android:gravity="center"
                            android:text="@string/newtype_video"
                            android:textColor="@color/M969999"
                            android:textSize="@dimen/sp11" />

                        <TextView
                            android:layout_width="match_parent"
                            android:layout_height="wrap_content"
                            android:layout_gravity="center"
                            android:layout_weight="1"
                            android:gravity="center"
                            android:text="@string/im_location"
                            android:textColor="@color/M969999"
                            android:textSize="@dimen/sp11" />


                    </LinearLayout>

                    <!--<ImageView-->
                    <!--android:id="@+id/img_bitmap"-->
                    <!--android:layout_width="wrap_content"-->
                    <!--android:layout_height="wrap_content" />-->

                </RelativeLayout>


            </RelativeLayout>


        </ScrollView>


    </com.motoband.ui.view.KeyboardListenRelativeLayout>


    <!--//存放当前位置照片-->
    <ScrollView
        android:id="@+id/scrollView_location_bitmap"
        android:layout_width="match_parent"
        android:layout_height="340dp"
        android:layout_marginTop="@dimen/dp800">

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="340dp"
            android:orientation="vertical"
            tools:ignore="ScrollViewSize">

            <RelativeLayout
                android:layout_width="match_parent"
                android:layout_height="203dp">

                <com.amap.api.maps.MapView
                    android:id="@+id/map_location"
                    android:layout_width="match_parent"
                    android:layout_height="203dp"
                    android:layout_gravity="center" />

                <ImageView
                    android:id="@+id/img_location_map"
                    android:layout_width="match_parent"
                    android:layout_height="203dp"
                    android:layout_gravity="center"
                    android:contentDescription="@null"
                    android:scaleType="centerCrop" />


            </RelativeLayout>
        </LinearLayout>
    </ScrollView>


</RelativeLayout>