第五章理解RemoteViews（Android开发艺术探索）

5.1、remoteViews的应用（主要用于通知栏和桌面小部件）

通知栏和桌面小部件不能直接去更新view，因为2者的页面都运行在其他进程中，确切来说是系统的SystemServer进程，为了跨进程更新页面，RemoteViews提供了一系列的set方法进行更新。

5.1.1、在通知栏的应用：

通知栏除了默认的效果还可以自定义布局，下面分别说明这2种情况：

默认的布局：

Notification notification = new Notification();
//设置图标
notification.icon = R.drawable.ic_launcher;
//设置内容
notification.tickerText = "hello world";
//要显示的时间，一般是当即显示，故填入系统当前时间。
notification.when = System.currentTimeMillis();
//// FLAG_AUTO_CANCEL表明当通知被用户点击时，通知将被自动清除。
notification.flags = Notification.FLAG_AUTO_CANCEL;

Intent intent = new Intent(this, DemoActivity_2.class);
////该语句的作用是定义了一个不是当即显示的activity，
// 只有当用户拉下notify显示列表，并且单击对应的项的时候，才会触发系统跳转到该activity.
PendingIntent pendingIntent = PendingIntent.getActivity(this,
0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
//在此处设置在nority列表里的该norifycation得显示情况。
notification.setLatestEventInfo(this, "chapter_5", "this is notification.", pendingIntent);
NotificationManager manager = (NotificationManager)getSystemService(Context.NOTIFICATION_SERVICE);
// 通过通知管理器来发起通知。如果id不同，则每click，在statu那里增加一个提示
manager.notify(sId, notification);

自定义的布局（使用了remoteViews来加载）：

Notification notification = new Notification();
notification.icon = R.drawable.ic_launcher;
notification.tickerText = "hello world";
notification.when = System.currentTimeMillis();
notification.flags = Notification.FLAG_AUTO_CANCEL;
Intent intent = new Intent(this, DemoActivity_1.class);
intent.putExtra("sid", "" + sId);
PendingIntent pendingIntent = PendingIntent.getActivity(this,
0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
System.out.println(pendingIntent);
//包名和资源ID
RemoteViews remoteViews = new RemoteViews(getPackageName(), R.layout.layout_notification);
remoteViews.setTextViewText(R.id.msg, "chapter_5: " + sId);
remoteViews.setImageViewResource(R.id.icon, R.drawable.icon1);
PendingIntent openActivity2PendingIntent = PendingIntent.getActivity(this,
0, new Intent(this, DemoActivity_2.class), PendingIntent.FLAG_UPDATE_CURRENT);
remoteViews.setOnClickPendingIntent(R.id.open_activity2, openActivity2PendingIntent);
notification.contentView = remoteViews;
notification.contentIntent = pendingIntent;
NotificationManager manager = (NotificationManager)getSystemService(Context.NOTIFICATION_SERVICE);
manager.notify(sId, notification);

remoteViews使用起来很简单，2个参数即可创建，包名和资源id

更新remoteViews无法直接访问里面的view，必须通过remoteViews提供的方法进行更新

比如：

remoteViews.setTextViewText(R.id.msg, "chapter_5: " + sId);
remoteViews.setImageViewResource(R.id.icon, R.drawable.icon1);

5.1.2、在桌面小部件上面的应用：

Android系统为我们提供了一个实现桌面小部件的类：AppWidgetProvider ，它继承广播。

public class AppWidgetProvider extends BroadcastReceiver

1、自定义小部件界面：

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

<ImageView
android:id="@+id/imageView1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:src="@drawable/icon1" />

</LinearLayout>

2、定义小部件的配置信息，res/xml/myapp_widget.xml

<?xml version="1.0" encoding="utf-8"?>
<appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
android:initialLayout="@layout/widget"//初始化布局
android:minHeight="84dp"
android:minWidth="84dp"
android:updatePeriodMillis="86400000" //自动更新周期>

</appwidget-provider>

3、定义小部件的实现类

package com.ryg.chapter_5;

import android.app.PendingIntent;
import android.appwidget.AppWidgetManager;
import android.appwidget.AppWidgetProvider;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.os.SystemClock;
import android.util.Log;
import android.widget.RemoteViews;
import android.widget.Toast;

public class MyAppWidgetProvider extends AppWidgetProvider {
public static final String TAG = "MyAppWidgetProvider";
public static final String CLICK_ACTION = "com.ryg.chapter_5.action.CLICK";

public MyAppWidgetProvider() {
super();
}

@Override
public void onReceive(final Context context, Intent intent) {
super.onReceive(context, intent);
Log.i(TAG, "onReceive : action = " + intent.getAction());

// 这里判断是自己的action，做自己的事情，比如小工具被点击了要干啥，这里是做一个动画效果
if (intent.getAction().equals(CLICK_ACTION)) {
Toast.makeText(context, "clicked it", Toast.LENGTH_SHORT).show();

new Thread(new Runnable() {
@Override
public void run() {
Bitmap srcbBitmap = BitmapFactory.decodeResource(
context.getResources(), R.drawable.icon1);
AppWidgetManager appWidgetManager = AppWidgetManager.getInstance(context);
for (int i = 0; i < 37; i++) {
float degree = (i * 10) % 360;
RemoteViews remoteViews = new RemoteViews(context
.getPackageName(), R.layout.widget);
remoteViews.setImageViewBitmap(R.id.imageView1,
rotateBitmap(context, srcbBitmap, degree));
Intent intentClick = new Intent();
intentClick.setAction(CLICK_ACTION);
PendingIntent pendingIntent = PendingIntent
.getBroadcast(context, 0, intentClick, 0);
remoteViews.setOnClickPendingIntent(R.id.imageView1, pendingIntent);
appWidgetManager.updateAppWidget(new ComponentName(
context, MyAppWidgetProvider.class),remoteViews);
SystemClock.sleep(30);
}

}
}).start();
}
}

/**
* 每次窗口小部件被点击更新都调用一次该方法
*/
@Override
public void onUpdate(Context context, AppWidgetManager appWidgetManager,
int[] appWidgetIds) {
super.onUpdate(context, appWidgetManager, appWidgetIds);
Log.i(TAG, "onUpdate");

final int counter = appWidgetIds.length;
Log.i(TAG, "counter = " + counter);
for (int i = 0; i < counter; i++) {
int appWidgetId = appWidgetIds[i];
onWidgetUpdate(context, appWidgetManager, appWidgetId);
}

}

/**
* 窗口小部件更新
*
* @param context
* @param appWidgeManger
* @param appWidgetId
*/
private void onWidgetUpdate(Context context,
AppWidgetManager appWidgeManger, int appWidgetId) {

Log.i(TAG, "appWidgetId = " + appWidgetId);
RemoteViews remoteViews = new RemoteViews(context.getPackageName(),
R.layout.widget);

// "窗口小部件"点击事件发送的Intent广播
Intent intentClick = new Intent();
intentClick.setAction(CLICK_ACTION);
PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0,
intentClick, 0);
remoteViews.setOnClickPendingIntent(R.id.imageView1, pendingIntent);
appWidgeManger.updateAppWidget(appWidgetId, remoteViews);
}

private Bitmap rotateBitmap(Context context, Bitmap srcbBitmap, float degree) {
Matrix matrix = new Matrix();
matrix.reset();
matrix.setRotate(degree);
Bitmap tmpBitmap = Bitmap.createBitmap(srcbBitmap, 0, 0,
srcbBitmap.getWidth(), srcbBitmap.getHeight(), matrix, true);
return tmpBitmap;
}
}

上面的代码实现了一个简单的桌面小部件，在小部件上面显示一张图片，点击图片后，图片旋转一周。

桌面小部件不管是初始化界面和后续的更新界面都必须使用remoteViews来完成。

4、在AndoridMenifest中申明小部件（跟注册广播差不多）

<receiver android:name=".MyAppWidgetProvider" >
<meta-data
android:name="android.appwidget.provider"
android:resource="@xml/appwidget_provider_info" >
</meta-data>

<intent-filter>
<action android:name="com.ryg.chapter_5.action.CLICK" />
<action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
</intent-filter>
</receiver>

inten-filter中有2个action，第一个是小部件的点击行为，第二个是小部件的标识，必须存在

拓展AppWidgetProvider的方法：

● 1)onEnable：当窗口小部件第一次添加到桌面时会调用。

● 2)onUpdate：小部件被添加时或者每次小部件更新时会调用。

● 3)onDeleted：每删除一次桌面小部件jiuhuidiaoy。

● 4)onDisabled：当最后一个桌面小部件被删除时会调用。

● 5)onReceive：广播的内置方法。

*启动时AppWidgetProvider的执行流程：

*第一步：onReceive()

* 接到广播事件：android.appwidget.action.APPWIDGET_ENABLED

*第二步：onEnabled()

*第三步：onReceive()

* 接到广播事件：android.appwidget.action.APPWIDGET_UPDATE

*第四步：onUpdate()

*

*被删除时AppWidgetProvider

*第一步：onReceive()

* 接到广播事件：android.appwidget.action.APPWIDGET_DELETED

*第二步：onDelete();

*第三步：onReceive()

* 接到广播事件：android.appwidget.action.APPWIDGET_DISABLED

*第四步：onDisabled()

5.1.3、PendingIntent概述

pending ： 等待，即将发生

pendingIntent表示将来某个不确定的时刻发生，Intent表示立刻发生

pendingIntent的典型事例是给remoteViews添加点击事件，因为remoteViews运行在远程进程中，所以无法像普通的View一样添加点击事件

pendingIntent支持3种待定意图：

启动activity，

public static PendingIntent getActivity(Context context, int requestCode,
Intent intent, int flags) {
return getActivity(context, requestCode, intent, flags, null);
}
启动service，
public static PendingIntent getService(Context context, int requestCode,
Intent intent, int flags) {
发送广播，
public static PendingIntent getBroadcast(Context context, int requestCode,
Intent intent, int flags) {
return getBroadcastAsUser(context, requestCode, intent, flags,
new UserHandle(UserHandle.myUserId()));
}

第一个参数和第三个参数好理解，我们来说说第二个参数requestCode和第四个参数flags

在了解这2个参数之前先要知道PendingIntent的匹配规则

PendingIntent的匹配规则是：intent和requestCode都相同，那么这2个pendingIntent就相同
Intent的匹配规则是：componentName和intent-filter相同

flags的类型：

//pendingIntent只能被使用一次，就会自动cancel
public static final int FLAG_ONE_SHOT = 1<<30;
//没有什么使用意义
public static final int FLAG_NO_CREATE = 1<<29;
//如果pendingIntent已经存在，那么它们都会被取消，然后创建一个新的pendingIntent
public static final int FLAG_CANCEL_CURRENT = 1<<28;
///如果pendingIntent已经存在，它们都会被更新，即Intent中的Extras会被替换成新的
public static final int FLAG_UPDATE_CURRENT = 1<<27;

下面结合通知栏消息再详细描述一下4个标记位：

manager.notify(id,notification)

第一种情况：如果id是常量，那么多次调用notify只能弹出一个通知，后面的通知会覆盖前面的

第二种情况：每次id都不一样，多次调用notify会弹出多个通知

5.2、RemoteViews的内部机制

remoteViews的作用是跨进程显示并更新UI，

remoteViews不支持自定义view，只支持下列view，下列view的子类也不支持

否则就会抛异常：android.view.inflateException

因为remoteViews是跨进程显示页面，所以无法findviewbyid获得view，但是它提供了一系列的set方法来控制view，这些方法都是通过反射来完成的

我们知道，

通知栏和桌面小程序分别由NotificationManager和AppWidgetManager管理；

而NotificationManager是通过Binder和NotificationManagerService通信，

AppWidgetManager是通过Binder和AppWidgetService通信 。

由此可见：

通知栏是在NotificationManagerService中被加载的

桌面小部件是在AppWidgetService中被加载的

而它们运行在系统的SystemServer中，那么就是跨进程通信的场景

第一步：RemoteViews会通过Binder传递到SystemServer进程（因为RemoteViews实现了Parcelable接口）
第二步：通过LayoutInflater加载RemoteViews中的layout布局（在SystemServer进程中返回的是一个普通的view）
第三步：调用RemoteViews的set方法进行UI的更新
第四步：通过NotificationManager和AppWidgetManager提交UI更新任务
这样，RemoteViews就在SystemServer进程中显示了（就是我们看到的通知栏消息和桌面小部件）

从理论上说：

系统完全可以通过Binder去支持所有的view和view的操作，但这样做代价太大了，因为view的方法太多了，另外就是大量的IPC操作会影响效率

Andorid系统怎么做的呢？

Android系统提供了一个Action，Action代表view的操作，action也实现了Parceable接口
Android系统在RemoteViews调用apply进行更新任务的提交时，其实是间接的调用了Action对象的apply方法进行提交的；然后在远程进程中批量执行RemoteViews的更新操作，避免了大量的IPC操作，提高了程序的性能，Android系统在这方面的确设计的很精妙。
（Action其实是利用了反射进行UI的更新）

RemoteViews在通知栏和桌面小部件的工作过程和上面描述的是一样的。

当我们调用set方法时它们并不会立即去更新UI，而是

通知栏必须要通过NotificationManager的notify方法更新页面

桌面小部件必须要通过AppWidgetManager的updateAppWidget方法更新页面

实际上在NotificationManager和AppWidgetManager的内部实现中，它们的确是通过RemoteViews的apply（加载并且更新页面）和reapply（只更新页面）来加载和更新页面的

//RemoteViews的内部类ReflectionAction
private final class ReflectionAction extends Action {
@Override
public void apply(View root, ViewGroup rootParent, OnClickHandler handler) {
final View view = root.findViewById(viewId);
if (view == null) return;

Class<?> param = getParameterType();
if (param == null) {
throw new ActionException("bad type: " + this.type);
}

try {
getMethod(view, this.methodName, param).invoke(view, wrapArg(this.value));
} catch (ActionException e) {
throw e;
} catch (Exception ex) {
throw new ActionException(ex);
}
}
}

看代码可以知道，ReflectionAction其实表示的是一个反射的动作

关于单击事件，RemoteViews只支持PendingIntent，另外注意，setOnclickPendingIntent给普通view设置点击事件，如果想给listview设置点击事件必须使用setPendingIntentTemplate和setOnclickFillInIntent

5.2、RemoteViews的意义

比如现在有2个应用，一个应用能够更新另一个应用的页面，这个时候我们当然可以选择AIDL实现，但是如果界面更新比较频繁，那么效率就会降低，AIDL接口也会变得复杂，这个时候如果采用RemoteViews就没有问题了，但是RemoteViews只支持一些简单的view，如果更新的界面比较简单可以采用RemoteViews。

//如果采用RemoteViews进行页面的更新，那么还有一个问题：布局文件加载的问题
View view = remoteViews.apply(this, mContent);
mContent.addView(view);

这种写法在同一个应用中的多进程是可以的，但是不同应用就访问不到了，

我们可以通过加载资源名称进行加载，两个应用约定好布局文件的名称。

可以通过如下代码实现：

int layoutId = getResources.getIdentifier("layoutId");
View view = getInflate.inflate(layoutId, mContent);
remoteViews.reapply(this, view);
mContent.addView(view);