本文基于android-27编译并进行源码分析
一、概述
什么是RemoteViews?
A class that describes a view hierarchy that can be displayed in another process.
The hierarchy is inflated from a layout resource file, and this class provides some basic operations for modifying the content of the inflated hierarchy.
RemoteViews这个类用于跨进程展示一个View结构，构造时需要制定一个layout资源文件，用于解析生成View；并提供了更新View内容的一些基本操作。
其和远程Service很像，由源进程提供layout资源，RemoteViews可以跨进程显示，并且可以利用提供的基本操作来远程更新界面。其常见的用途有两种：通知栏和桌面小部件。
二、应用
2.1 通知栏
使用系统默认样式弹出一个通知栏是很简单的，但是如果有通知栏自定义布局的需求，RemoteViews就派上用场了：
Notification notification =new Notification();
notification.icon = R.mipmap.ic_launcher;
notification.tickerText ="hello notification";
notification.when = System.currentTimeMillis();
notification.flags = Notification.FLAG_AUTO_CANCEL;
Intent intent =new Intent(this, RemoteViewsActivity.class);
PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
RemoteViews remoteViews =new RemoteViews(getPackageName(), R.layout.layout_notification);//RemoveViews所加载的布局文件
remoteViews.setTextViewText(R.id.tv, "这是一个Test");//设置文本内容
remoteViews.setTextColor(R.id.tv, Color.parseColor("#abcdef"));//设置文本颜色
remoteViews.setImageViewResource(R.id.iv, R.mipmap.ic_launcher);//设置图片
PendingIntent openActivity2Pending = PendingIntent.getActivity (this, 0, new Intent(this, MainActivity.class), PendingIntent.FLAG_UPDATE_CURRENT);//设置RemoveViews点击后启动界面
remoteViews.setOnClickPendingIntent(R.id.tv, openActivity2Pending);
notification.contentView = remoteViews;
notification.contentIntent = pendingIntent;
NotificationManager manager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
manager.notify(2, notification);
2.2 桌面小部件
共分为四步：准备要显式的布局文件、定义小部件配置信息、自定义AppWidgetProvider的实现类、在AndroidManifest.xml中声明。
res/layout下的widget.xml
<?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/iv_desk"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:src="@mipmap/ic_launcher"/>
</LinearLayout>
res/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="100dp"
android:minWidth="100dp"
android:updatePeriodMillis="3000">
</appwidget-provider>
MyAppWidgetProvider.java
public class MyAppWidgetProvider extends AppWidgetProvider {
private static final String TAG = "MyAppWidgetProvider";
private static final String CLICK_ACTION = "com.satellite.remoteviews";
public MyAppWidgetProvider(){
super();
}
@Override
public void onReceive(final Context context, Intent intent) {
super.onReceive(context,intent);
Log.i(TAG,"onReceive : action = "+intent.getAction());
if(intent.getAction().equals(CLICK_ACTION)){
Toast.makeText(context,"click it",Toast.LENGTH_SHORT).show();
new Thread(){
@Override
public void run() {
super.run();
// 更新view
......
}
}.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);
}
}
private void onWidgetUpdate(Context context,AppWidgetManager appWidgetManager,int appWidgetId){
Log.i(TAG,"appWidgetId = "+appWidgetId);
RemoteViews remoteViews = new RemoteViews(context.getPackageName(),R.layout.widget);
Intent intentClick = new Intent();
intentClick.setAction(CLICK_ACTION);
PendingIntent pendingIntent = PendingIntent.getBroadcast(context,0,intentClick,0);
remoteViews.setOnClickPendingIntent(R.id.iv_desk,pendingIntent);
appWidgetManager.updateAppWidget(appWidgetId,remoteViews);
}
}
AndroidManifest中注册（注意两个Action）：
<receiver android:name=".MyAppWidgetProvider">
<meta-data
android:name="android.appwidget.provider"
android:resource="@xml/appwidget_provider_info" />
<intent-filter>
<!--自定义的action用于响应点击AppWidget-->
<action android:name="com.satellite.remoteviews" />
<!--必须要显示声明的action！因为所有的widget的广播都是通过它来发送的；要接收widget的添加、删除等广播，就必须包含它-->
<action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
</intent-filter>
</receiver>
要注意，AppWidgetProvider的父类是BroadcastReceiver，其本质就是一个广播接收器，广播到来的时候，AppWidgetProvider会自动根据广播的Action通过onReceive方法来分发广播，内部方法如下：
onEnable: 当该窗口小部件第一次添加到桌面时调用的方法，可添加多次但只在第一次调用。
onUpdate: 小部件被添加时或者每次小部件更新时都会调用一次该方法，小部件的更新时机是有updatePeriodMillis来指定，每个周期小部件就会自动更新一次。
onDeleted: 每删除一次桌面小部件就调用一次。
onDisabled: 当最后一个该类型的小部件被删除时调用该方法。
onReceive: 这是广播的内置方法，用于分发具体事件给其他方法。
三、原理分析
3.1 问题
1、RemoteViews为什么可以通过一次IPC实现对多个View的操作。
2、其他进程怎么获取布局文件。
3.2 具体分析
3.2.1 PendingIntent
上面的通知栏消息和桌面小部件，都用到了PendingIntent。
PendingIntent表示一种处于pending（待定、等待、即将发生）状态的意图；PendingIntent通过send和cancel方法来发送和取消特定的待定Intent。
PendingIntent支持三种待定意图：启动Activity、启动Service和发送广播。分别对应：
getActivity / getService / getBroadcast
参数相同，都为：(Context context, int requestCode, Intent intent, int flags)
其中第二个参数，requestCode表示PendingIntent发送方的请求码，多少情况下为0即可，requestCode会影响到flags的效果。
PendingIntent的匹配规则是：如果两个PendingIntent他们内部的Intent相同并且requestCode也相同，那么这两个PendingIntent就是相同的。那么什么情况下Intent相同呢？Intent的匹配规则是，如果两个Intent的ComponentName和intent-filter都相同；那么这两个Intent也是相同的。
flags参数的含义：
FLAG_ONE_SHOT 当前的PendingIntent只能被使用一次，然后他就会自动cancel，如果后续还有相同的PendingIntent，那么它们的send方法就会调用失败。
FLAG_NO_CREATE 当前描述的PendingIntent不会主动创建，如果当前PendingIntent之前存在，那么getActivity、getService和getBroadcast方法会直接返回Null，即获取PendingIntent失败，无法单独使用，平时很少用到。
FLAG_CANCEL_CURRENT 当前描述的PendingIntent如果已经存在，那么它们都会被cancel，然后系统会创建一个新的PendingIntent。对于通知栏消息来说，那些被cancel的消息单击后无法打开。
FLAG_UPDATE_CURRENT 当前描述的PendingIntent如果已经存在，那么它们都会被更新，即它们的Intent中的Extras会被替换为最新的。
manager.notify(2, notification);
// 结合通知栏功能说明一下，多次调用notify()后如果PendingIntent匹配时即Intent和requestCode相同：
// 1、FLAG_ONE_SHOT：点击任何一条通知，剩余的通知都无法打开，所有通知被清除后，再次循环这个过程；
// 2、FLAG_CANCEL_CURRENT：只有最新的通知可以打开，之前的通知都无法打开；
// 3、FLAG_UPDATE_CURRENT：之前弹出的通知中的PendingIntent会更新，和最新通知保持一致，并且所有的通知都可以打开。
3.2.2 RemoteViews
接下来结合上面的代码来分析RemoteViews的工作原理：
1、当用户将AppWidget拖到桌面上时，MyAppWidgetProvider继承AppWidgetProvider原有的onReceive方法，回调其onUpdate方法
@Override
public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
super.onUpdate(context, appWidgetManager, appWidgetIds);
......
onWidgetUpdate(context,appWidgetManager,appWidgetId);
......
}
}
2、在onWidgetUpdate方法中建立RemoteViews，之后调用appWidgetManager的updateAppWidget发起IPC。
private void onWidgetUpdate(Context context,AppWidgetManager appWidgetManager,int appWidgetId){
RemoteViews remoteViews = new RemoteViews(context.getPackageName(),R.layout.widget);
Intent intentClick = new Intent();
intentClick.setAction(CLICK_ACTION);
PendingIntent pendingIntent = PendingIntent.getBroadcast(context,0,intentClick,0);
remoteViews.setOnClickPendingIntent(R.id.iv_desk,pendingIntent);
appWidgetManager.updateAppWidget(appWidgetId,remoteViews);
}
3、这里实例化了RemoteViews，俩参数分别是包名和布局资源id
/**
* Create a new RemoteViews object that will display the views contained
* in the specified layout file.
*
* @param packageName Name of the package that contains the layout resource
* @param layoutId The id of the layout resource
*/
public RemoteViews(String packageName, int layoutId) {
this(getApplicationInfo(packageName, UserHandle.myUserId()), layoutId);
}
/**
* Create a new RemoteViews object that will display the views contained
* in the specified layout file.
*
* @param application The application whose content is shown by the views.
* @param layoutId The id of the layout resource.
*
* @hide
*/
protected RemoteViews(ApplicationInfo application, int layoutId) {
mApplication = application;
mLayoutId = layoutId;
mBitmapCache = new BitmapCache();
// setup the memory usage statistics
mMemoryUsageCounter = new MemoryUsageCounter();
recalculateMemoryUsage();
}
4、之后RemoteViews调用了setOnClickPendingIntent方法。
remoteViews.setOnClickPendingIntent(R.id.iv_desk,pendingIntent);
// RemoteViews源码
public void setOnClickPendingIntent(int viewId, PendingIntent pendingIntent) {
addAction(new SetOnClickPendingIntent(viewId, pendingIntent));
}
/**
* Add an action to be executed on the remote side when apply is called.
* 译：当apply()方法被调用时，添加的action会在远程被执行。
* @param a The action to add
*/
private void addAction(Action a) {
if (hasLandscapeAndPortraitLayouts()) {
throw new RuntimeException("RemoteViews specifying separate landscape and portrait" +
" layouts cannot be modified. Instead, fully configure the landscape and" +
" portrait layouts individually before constructing the combined layout.");
}
if (mActions == null) {
mActions = new ArrayList<Action>();
}
mActions.add(a);
// update the memory usage stats
a.updateMemoryUsageEstimate(mMemoryUsageCounter);
}
setOnClickPendingIntent方法在内部利用viewId, pendingIntent生成SetOnClickPendingIntent对象，并将此对象作为参数传入addAction中，而SetOnClickPendingIntent和Action是继承的关系,是Action的子类。先看addAction的具体逻辑，发现addAction中将传入的参数添加至RemoteViews的成员变量mActions中，并且未来会在远程调用Action的apply方法来执行Action，下面来看Action类的信息。
5、Action
/**
* Base class for all actions that can be performed on an
* inflated view.
*
* SUBCLASSES MUST BE IMMUTABLE SO CLONE WORKS!!!!!
*/
private abstract static class Action implements Parcelable {
public abstract void apply(View root, ViewGroup rootParent,
OnClickHandler handler) throws ActionException;
public abstract String getActionName();
......
}
Action类为一个抽象类，同时实现了Parcelable接口，支持IPC。最关键的一个抽象方法apply。再看其实现click的子类SetOnClickPendingIntent ：
/**
* Equivalent to calling(等同于调用View#setOnClickListener)
* {@link android.view.View#setOnClickListener(android.view.View.OnClickListener)}
* to launch the provided {@link PendingIntent}.
*/
private class SetOnClickPendingIntent extends Action {
public SetOnClickPendingIntent(int id, PendingIntent pendingIntent) {
this.viewId = id;
this.pendingIntent = pendingIntent;
}
.....
@Override
public void apply(View root, ViewGroup rootParent, final OnClickHandler handler) {
final View target = root.findViewById(viewId);
if (target == null) return;
......
// If the pendingIntent is null, we clear the onClickListener
OnClickListener listener = null;
if (pendingIntent != null) {
listener = new OnClickListener() {
public void onClick(View v) {
// Find target view location in screen coordinates and
// fill into PendingIntent before sending.
final Rect rect = getSourceBounds(v);
final Intent intent = new Intent();
intent.setSourceBounds(rect);
handler.onClickHandler(v, pendingIntent, intent);
}
};
}
target.setOnClickListener(listener);
}
public String getActionName() {
return "SetOnClickPendingIntent";
}
PendingIntent pendingIntent;
}
RemoteViews的setOnClickPendingIntent方法可以这么理解：将添加监听的一个View动作，封装成一个Action类，保存在RemoteViews的mActions中。其实查看RemoteViews的每一个set方法，不难发现都是把对View操作的动作封装成Action类，最终保存在RemoteViews的mActions中。这个过程可以理解为：
到目前为止发现RemoteViews更多承担的是信息的一个载体，这些信息包括：要显示View的资源ID值、mActions等等。
上面介绍了RemoteViews如何通过Action来封装和组合View的多个操作，下面开始介绍如何执行这些Action的即如何远程加载布局并执行更新操作。
6、appWidgetManager.updateAppWidget
上面无论是onWidgetUpdate还是onReceive中收到CLICK_ACTION时，最后都调用了：
appWidgetManager.updateAppWidget(appWidgetId,remoteViews);
我们来看看里面的流程：
private final IAppWidgetService mService;
public void updateAppWidget(int appWidgetId, RemoteViews views) {
if (mService == null) {
return;
}
updateAppWidget(new int[] { appWidgetId }, views);
}
public void updateAppWidget(int[] appWidgetIds, RemoteViews views) {
if (mService == null) {
return;
}
try {
mService.updateAppWidgetIds(mPackageName, appWidgetIds, views);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
看到了RemoteException猜测这里就开始了远程服务的调用，而这个远程服务对象mService的类型是 IAppWidgetService。之后由AppWidgetService发送消息，AppWidgetHost监听来自AppWidgetService的事件(链接：AppWidget的详细流程)，AppWidgetHost收到AppWidgetService发送的消息，创建AppWidgetHostView，然后通过AppWidgetService查询appWidgetId对应的RemoteViews，最后把RemoteViews传递给AppWidgetHostView去updateAppWidget。
AppWidgetHost的内部流程：
// AppWidgetHost源码
/**
* Create the AppWidgetHostView for the given widget.
* The AppWidgetHost retains a pointer to the newly-created View.
*/
public final AppWidgetHostView createView(Context context, int appWidgetId,
AppWidgetProviderInfo appWidget) {
if (sService == null) {
return null;
}
AppWidgetHostView view = onCreateView(context, appWidgetId, appWidget);
view.setOnClickHandler(mOnClickHandler);
view.setAppWidget(appWidgetId, appWidget);
synchronized (mViews) {
mViews.put(appWidgetId, view);
}
RemoteViews views;
try { // 通过AppWidgetService查询appWidgetId对应的RemoteViews
views = sService.getAppWidgetViews(mContextOpPackageName, appWidgetId);
} catch (RemoteException e) {
throw new RuntimeException("system server dead?", e);
}
// 最后把RemoteViews传递给AppWidgetHostView去updateAppWidget。
view.updateAppWidget(views);
return view;
}
7、AppWidgetHostView.updateAppWidget()
注意：1、layoutId出场了；
2、remoteViews的apply和reapply在调用中第二个参数的不同
public void updateAppWidget(RemoteViews remoteViews) {
applyRemoteViews(remoteViews, true);
}
protected void applyRemoteViews(RemoteViews remoteViews, boolean useAsyncIfPossible) {
......
if (remoteViews == null) {
......
} else {
......
// Prepare a local reference to the remote Context so we're ready to
// inflate any requested LayoutParams.
mRemoteContext = getRemoteContext();
int layoutId = remoteViews.getLayoutId();
// If our stale view has been prepared to match active, and the new
// layout matches, try recycling it(已经加载过了直接复用)
if (content == null && layoutId == mLayoutId) {
try { // reapply的第二个参数是layoutId的布局
remoteViews.reapply(mContext, mView, mOnClickHandler);
content = mView;
recycled = true;
if (LOGD) Log.d(TAG, "was able to recycle existing layout");
} catch (RuntimeException e) {
exception = e;
}
}
// Try normal RemoteView inflation(layoutId不匹配，重新加载布局)
if (content == null) {
try { // apply的第二个参数是AppWidgetHostView
content = remoteViews.apply(mContext, this, mOnClickHandler);
if (LOGD) Log.d(TAG, "had to inflate new layout");
} catch (RuntimeException e) {
exception = e;
}
}
mLayoutId = layoutId;
mViewMode = VIEW_MODE_CONTENT;
}
applyContent(content, recycled, exception);
updateContentDescription(mInfo);
}
AppWidgetHostView.updateAppWidget()的实现逻辑很好理解（当然这里只是保留了主要的逻辑代码），通过匹配layoutId ，如果没有加载过，remoteViews的布局则调用remoteViews.apply方法，若加载过了则调用remoteViews.reapply方法。
其实这个时候所有的操作已经处于systemServer进程中了，最后看一下remoteViews的apply和reapply方法。
8、remoteViews的apply和reapply（注意俩方法第二个参数的不同）
apply比reapply多一步inflate的过程，只分析apply：
public View apply(Context context, ViewGroup parent) {
return apply(context, parent, null);
}
// apply流程如下：
// 1、通过RemoteViews的getLayoutId方法获取要显示的资源ID值
// 2、利用LayoutInflater加载要加载的xml文件，生成View。
// 3、调用RemoteViews的performApply方法。
public View apply(Context context, ViewGroup parent, OnClickHandler handler) {
RemoteViews rvToApply = getRemoteViewsToApply(context);
// 1、通过RemoteViews的getLayoutId方法获取要显示的资源ID值
// 2、利用LayoutInflater加载要加载的xml文件，生成View。
View result = inflateView(context, rvToApply, parent);
loadTransitionOverride(context, handler);
// 3、调用RemoteViews的performApply方法。
rvToApply.performApply(result, parent, handler);
return result;
}
private View inflateView(Context context, RemoteViews rv, ViewGroup parent) {
// ......
final Context contextForResources = getContextForResources(context);
Context inflationContext = new RemoteViewsContextWrapper(context, contextForResources);
LayoutInflater inflater = (LayoutInflater)
context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
// Clone inflater so we load resources from correct context and
// we don't add a filter to the static version returned by getSystemService.
inflater = inflater.cloneInContext(inflationContext);
inflater.setFilter(this);
View v = inflater.inflate(rv.getLayoutId(), parent, false);
v.setTagInternal(R.id.widget_frame, rv.getLayoutId());
return v;
}
// 将前面存入mActions中的Action遍历取出来，并调用action的apply方法
private void performApply(View v, ViewGroup parent, OnClickHandler handler) {
if (mActions != null) {
handler = handler == null ? DEFAULT_ON_CLICK_HANDLER : handler;
final int count = mActions.size();
for (int i = 0; i < count; i++) {
Action a = mActions.get(i);
a.apply(v, parent, handler);
}
}
}
9、action的apply方法
performApply()中取出所有的Action并调用其apply()方法，回过头分析SetOnClickPendingIntent的apply，分三步来分析：
// 1、通过viewId获取对应的view
// 2、如果pendingIntent不为空，为target生成OnClickListener
// 3、target绑定监听
@Override
public void apply(View root, ViewGroup rootParent, final OnClickHandler handler) {
// 1、通过viewId获取对应的view
final View target = root.findViewById(viewId);
if (target == null) return;
......
// If the pendingIntent is null, we clear the onClickListener
OnClickListener listener = null;
// 2、如果pendingIntent不为空，为target生成OnClickListener
if (pendingIntent != null) {
listener = new OnClickListener() {
public void onClick(View v) {
// Find target view location in screen coordinates and
// fill into PendingIntent before sending.
final Rect rect = getSourceBounds(v);
final Intent intent = new Intent();
intent.setSourceBounds(rect);
handler.onClickHandler(v, pendingIntent, intent);
}
};
}
// 3、target绑定监听
target.setOnClickListener(listener);
这样便完成了View的setOnClickListener
这里就分析了一个相对简单的Action——SetOnClickPendingIntent，其他的Action逻辑也是相同的，有的会使用反射技术来修改View的某些属性。
3.2.3 小结
至于3.1开头提出的俩问题，应该已经有明确的答案了，这里不再赘述
1、RemoveViews并不能支持所有View类型，支持以下：
Layout：FrameLayout、LinearLayout、RelativeLayout、GridLayout。
View：Button、ImageButton、ImageView、ProgressBar、TextView、ListView、GridView、ViewStub等（例如EditText是不允许在RemoveViews中使用的，使用会抛异常）。
2、RemoteView没有findViewById方法，因此无法访问里面的View元素，而必须通过RemoteViews所提供的一系列set方法来完成，这是通过反射调用的。
3、通知栏和小组件分别由NotificationManager(NM)和AppWidgetManager(AWM)管理，而NM和AWM通过Binder分别和SystemService进程中的NotificationManagerService以及AppWidgetService中加载的，而它们运行在系统的SystemService中，这就和我们进程构成了跨进程通讯。
4、工作流程：首先RemoteViews会通过Binder传递到SystemService进程，因为RemoteViews实现了Parcelable接口，因此它可以跨进程传输，系统会根据RemoteViews的包名等信息拿到该应用的资源；然后通过LayoutInflater去加载RemoteViews中的布局文件。接着系统会对View进行一系列界面更新任务，这些任务就是之前我们通过set来提交的。set方法对View的更新并不会立即执行，会记录下来，等到RemoteViews被加载以后才会执行。
5、为了提高效率，系统没有直接通过Binder去支持所有的View和View操作。而是提供一个Action概念，Action同样实现Parcelable接口。系统首先将View操作封装到Action对象并将这些对象跨进程传输到SystemService进程，接着SystemService进程执行Action对象的具体操作。远程进程通过RemoteViews的apply方法来进行View的更新操作，RemoteViews的apply方法会去遍历所有的Action对象并调用他们的apply方法。这样避免了定义大量的Binder接口，也避免了大量IPC操作。
6、apply和reApply的区别在于：apply会加载布局并更新界面，而reApply则只会更新界面。
7、关于单击事件，RemoteViews中只支持发起PendingIntent，不支持onClickListener那种模式。setOnClickPendingIntent用于给普通的View设置单击事件，不能给集合（ListView/StackView）中的View设置单击事件（开销大，系统禁止了这种方式）。如果要给ListView/StackView中的item设置单击事件，必须将setPendingIntentTemplate和setOnClickFillInIntent组合使用才可以。
四、RemoteViews的意义
分析了RemoteViews的原理后，我们可以模拟一下跨进程UI更新，场景如下：一个应用的两个Activity A、B，修改A的process属性让其运行在独立的进程中，构建多进程环境。
<activity android:name=".FirstActivity"
android:process=":remote">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity android:name=".SendMsgActivity"></activity>
A启动后再启动B，B通过广播发送RemoteViews，A接收后更新RemoteViews。
这里要注意的是，如果A哈B不在一个应用内，那么B中的资源文件Id传到A中可能就是无效的，此时最好提前约定好RemoteViews中要加载的布局文件名称，A在收到RemoteViews后根据布局名称加载布局：
// 假如RemoteViews跨应用显示,那么就不能通过id来加载layout了，需要根据名称来加载布局
// 注意：第三个参数：包名，一定要写RemoteViews来源的应用包名
int layoutId = getResources().getIdentifier("layout_simulated_notification",
"layout", getPackageName());
View view = getLayoutInflater().inflate(layoutId, remote_views_content, false);
// reapply方法不需要加载layout
remoteViews.reapply(this, view);
remote_views_content.addView(view);
github地址：RemoteViewsDemo
附录
参考：
1、《Android开发艺术探索》
2、Android神奇“控件”-----RemoteViews
3、Android开发艺术探索 第5章 理解RemoteViews 读书笔记
