Android RemoteViews源码分析以及扩展使用
一，写在前面
在前面两篇文章RemoteViews的基本使用(上)之通知栏 ，RemoteViews的基本使用(下)之窗口小部件 中讲述了RemoteViews的两个应用场景，这篇文章主要介绍RemoteViews的内部机制，以及一个小扩展，使用RemoteViews实现跨进程操作界面。本篇文章以窗口小部件为例，来分析RemoteViews如何实现跨进程操作界面。我们都知道在将小部件列表中将窗口小部件拖到桌面，会调用onUpdate方法，在该方法中会调用AppWidgetManager.updateAppWidget(appWidgetIds，remoteViews)来更新窗口小部件，调用RemoteViews方法的一些set..方法，修改窗口小部件的界面。对于这些不是很清楚的哥们，可以查看文章RemoteViews的基本使用(下)之窗口小部件 ，这篇文章对窗口小部件做了简单的介绍，本篇文章主要从源码角度分析RemoteViews，对窗口小部件的生命周期以及使用不再阐述。
二，以窗口小部件为例
查看AppWidgetManager$updateAppWidget源码：
public void updateAppWidget(int[] appWidgetIds, RemoteViews views) {
try {
sService.updateAppWidgetIds(appWidgetIds, views, mContext.getUserId());
}
catch (RemoteException e) {
throw new RuntimeException("system server dead?", e);
}
}
public static AppWidgetManager getInstance(Context context) {
synchronized (sManagerCache) {
if (sService == null) {
IBinder b = ServiceManager.getService(Context.APPWIDGET_SERVICE);
sService = IAppWidgetService.Stub.asInterface(b);
}
WeakReference ref = sManagerCache.get(context);
AppWidgetManager result = null;
if (ref != null) {
result = ref.get();
}
if (result == null) {
result = new AppWidgetManager(context);
sManagerCache.put(context, new WeakReference(result));
}
return result;
}
}
查看AppWidgetService$updateAppWidgetIds源码：
public void updateAppWidgetIds(int[] appWidgetIds, RemoteViews views) {
if (appWidgetIds == null) {
return;
}
if (appWidgetIds.length == 0) {
return;
}
final int N = appWidgetIds.length;
synchronized (mAppWidgetIds) {
for (int i=0; i updatedViews) {
int callingUid = enforceCallingUid(packageName);
synchronized (mAppWidgetIds) {
Host host = lookupOrAddHostLocked(callingUid, packageName, hostId);
host.callbacks = callbacks;
updatedViews.clear();
ArrayList instances = host.instances;
int N = instances.size();
int[] updatedIds = new int[N];
for (int i=0; i
查看类AppWidgetHost$startListening方法，源码如下：
public void startListening() {
int[] updatedIds;
ArrayList updatedViews = new ArrayList();
try {
if (mPackageName == null) {
mPackageName = mContext.getPackageName();
}
updatedIds = sService.startListening(mCallbacks, mPackageName, mHostId, updatedViews);
}
catch (RemoteException e) {
throw new RuntimeException("system server dead?", e);
}
final int N = updatedIds.length;
for (int i=0; i
我们可以查看sService实例化的位置，AppWidgetHost构造函数源码如下：
int mHostId;
Callbacks mCallbacks = new Callbacks();
final HashMap mViews = new HashMap();
public AppWidgetHost(Context context, int hostId) {
mContext = context;
mHostId = hostId;
mHandler = new UpdateHandler(context.getMainLooper());
synchronized (sServiceLock) {
if (sService == null) {
IBinder b = ServiceManager.getService(Context.APPWIDGET_SERVICE);
sService = IAppWidgetService.Stub.asInterface(b);
}
}
}
注意这样一行代码：Callbacks mCallbacks = new Callbacks()，mCallbacks 就是updatedIds = sService.startListening(mCallbacks, mPackageName, mHostId, updatedViews)中的mCallbacks参数。通过Binder机制，调用远程服务方法，即，AppWidgetService$startListening(IAppWidgetHost callbacks, String packageName, int hostId,List updatedViews)，前面提到的mCallbacks参数，传递过来就是callbacks。这样，终于找到了mCallbacks实例化的位置，它是AppwidgetHost里面的一个内部类Callbacks。
前面讲到更新窗口小部件，需要调用appWidgetManager.updateAppwidget(ids,remoteviews)，最后会调用id.host.callbacks.updateAppWidget(id.appWidgetId, views)，现在我们知道了callbacks的实例化位置，可以查看方法updateAppWidget里面到底做了些什么操作。
查看AppWidgetHost$Callbacks内部类源码如下：
class Callbacks extends IAppWidgetHost.Stub {
public void updateAppWidget(int appWidgetId, RemoteViews views) {
Message msg = mHandler.obtainMessage(HANDLE_UPDATE);
msg.arg1 = appWidgetId;
msg.obj = views;
msg.sendToTarget();
}
public void providerChanged(int appWidgetId, AppWidgetProviderInfo info) {
Message msg = mHandler.obtainMessage(HANDLE_PROVIDER_CHANGED);
msg.arg1 = appWidgetId;
msg.obj = info;
msg.sendToTarget();
}
}class UpdateHandler extends Handler {
public UpdateHandler(Looper looper) {
super(looper);
}
public void handleMessage(Message msg) {
switch (msg.what) {
case HANDLE_UPDATE: {
updateAppWidgetView(msg.arg1, (RemoteViews)msg.obj);
break;
}
case HANDLE_PROVIDER_CHANGED: {
onProviderChanged(msg.arg1, (AppWidgetProviderInfo)msg.obj);
break;
}
}
}
}
//继续查看方法updateAppWidgetView
void updateAppWidgetView(int appWidgetId, RemoteViews views) {
AppWidgetHostView v;
synchronized (mViews) {
v = mViews.get(appWidgetId);
}
if (v != null) {
v.updateAppWidget(views);
}
}/**
* Process a set of {@link RemoteViews} coming in as an update from the
* AppWidget provider. Will animate into these new views as needed
*/
public void updateAppWidget(RemoteViews remoteViews) {
if (LOGD) Log.d(TAG, "updateAppWidget called mOld=" + mOld);
boolean recycled = false;
View content = null;
Exception exception = null;
// Capture the old view into a bitmap so we can do the crossfade.
if (CROSSFADE) {
if (mFadeStartTime < 0) {
if (mView != null) {
final int width = mView.getWidth();
final int height = mView.getHeight();
try {
mOld = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
} catch (OutOfMemoryError e) {
// we just won't do the fade
mOld = null;
}
if (mOld != null) {
//mView.drawIntoBitmap(mOld);
}
}
}
}
if (remoteViews == null) {
if (mViewMode == VIEW_MODE_DEFAULT) {
// We've already done this -- nothing to do.
return;
}
content = getDefaultView();
mLayoutId = -1;
mViewMode = VIEW_MODE_DEFAULT;
} else {
// Prepare a local reference to the remote Context so we're ready to
// inflate any requested LayoutParams.
mRemoteContext = getRemoteContext(remoteViews);
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 {
remoteViews.reapply(mContext, mView);
content = mView;
recycled = true;
if (LOGD) Log.d(TAG, "was able to recycled existing layout");
} catch (RuntimeException e) {
exception = e;
}
}
// Try normal RemoteView inflation
if (content == null) {
try {
content = remoteViews.apply(mContext, this);
if (LOGD) Log.d(TAG, "had to inflate new layout");
} catch (RuntimeException e) {
exception = e;
}
}
mLayoutId = layoutId;
mViewMode = VIEW_MODE_CONTENT;
}
if (content == null) {
if (mViewMode == VIEW_MODE_ERROR) {
// We've already done this -- nothing to do.
return ;
}
Log.w(TAG, "updateAppWidget couldn't find any view, using error view", exception);
content = getErrorView();
mViewMode = VIEW_MODE_ERROR;
}
if (!recycled) {
prepareView(content);
addView(content);
}
if (mView != content) {
removeView(mView);
mView = content;
}
if (CROSSFADE) {
if (mFadeStartTime < 0) {
// if there is already an animation in progress, don't do anything --
// the new view will pop in on top of the old one during the cross fade,
// and that looks okay.
mFadeStartTime = SystemClock.uptimeMillis();
invalidate();
}
}
}
在84行，执行了this.addView(content)，这个this就是AppWidgetHostView，也就是说窗口小部件的界面添加在AppWidgetHostView里，也可以理解为AppWidgetHostView是窗口小部件的父容器。理解这个很重要，后面扩展使用的原理就来自于此。
三，小结
开发一个窗口小部件，我们需要在应用中创建AppWidgetProvider的子类，并重写一些生命周期的方法。在重写的onUpdate方法中，调用appWidgetManager.updateAppWidget(ids,remoteviews)更新窗口小部件，参数remoteViews一般会调用一些setXXX方法来确定如何更新界面。这里的remoteViews是在开发的应用中的，而窗口小部件的界面更新并不是在本应用中的，它的更新操作是放在SystemServer进程中。
所以窗口小部件的实现体现了一个非常重要的需求：跨进程更新界面。从上面的代码分析可知，界面具体更新是交给AppWidgetService处理，它是一个系统服务，开机启动就会执行。系统服务AppWidgetService处理界面的更新，最终会调用remoteViews$apply方法更新界面。这个remoteViews从本应用通过Binder机制，跨进程传递给了AppWidgetService，我们可以猜测它实现了Parcelable接口，事实也确实如此。
因此可以得出这样一个结论：若需要实现操作远程界面，首先需要调用apply方法并返回一个View，然后将该View添加到父容器中。
四，另外
前面代码这样那样跟下来，更新界面，最终是调用了Remoteviews$apply/reapply方法，那么apply是如何更新界面的呢？下面的分析才是本篇文章的重点，上面一系列代码跟进只是引出这个引子，并没有多大实际意义。只需要知道最终调用AppWidgetHostView$updateAppWidget方法，里面调用RemoteViews的方法apply/reapply更新界面，且AppWidgetHostView是更新界面的父容器。
五，RemoteViews源码分析
在分析RemoteViews$apply/reapply方法前，先分析RemoteViews的一些setXXX方法，至于为啥子看完就知道啦。
5.1，分析RemoteViews$setXXX方法
以RemoteViews$setTextViewText为例进行分析，查看源码如下：
public void setTextViewText(int viewId, CharSequence text) {
setCharSequence(viewId, "setText", text);
}
//继续看setCharSequence
public void setCharSequence(int viewId, String methodName, CharSequence value) {
addAction(new ReflectionAction(viewId, methodName, ReflectionAction.CHAR_SEQUENCE, value));
}
//继续看addAction
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();
}
mActions.add(a);
// update the memory usage stats
a.updateMemoryUsageEstimate(mMemoryUsageCounter);
}
查看内部类RemoteViews$Action源码：
private abstract static class Action implements Parcelable {
public abstract void apply(View root, ViewGroup rootParent,
OnClickHandler handler) throws ActionException;
//...code
}
当然，我们还可以使用AIDL接口实现跨进程通信，这样我们需要定义大量的AIDL接口去替代RemoteViews$setXXX方法。同时，由于Action都存放到list集合中，在处理时只需要获取到list集合，便可以批量处理RemoteViews更新界面的操作，不需要频繁的进行IPC操作，提高了程序的性能。但是，在文章 RemoteViews的基本使用(上)之通知栏中有讲到，RemoteViews的缺陷是不能支持所有的View，它只能支持部分的布局控件，部分的View。具体支持哪些， RemoteViews的基本使用(上)之通知栏有详细介绍，这里不再阐述。
前面讲述了在list集合中存放了Action对象，那么在哪里取出集合里的元素，并执行界面更新的处理呢？这就是下面要讲的，继续看下来呗~
5.2，分析RemoteViews$apply/reapply方法
通过上面的分析，可以猜测RemoteViews$apply/reapply方法中取出了list集合里的元素，然后执行更新操作。当然是SystemServer进程中执行的，文章前半部分已经有很详细的分析了。
查看RemoteViews$apply源码：
public View apply(Context context, ViewGroup parent) {
return apply(context, parent, null);
}
/** @hide */
public View apply(Context context, ViewGroup parent, OnClickHandler handler) {
RemoteViews rvToApply = getRemoteViewsToApply(context);
View result;
Context c = prepareContext(context);
LayoutInflater inflater = (LayoutInflater)
c.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
inflater = inflater.cloneInContext(c);
inflater.setFilter(this);
result = inflater.inflate(rvToApply.getLayoutId(), parent, false);
rvToApply.performApply(result, parent, handler);
return result;
}
//继续看performApply
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);
}
}
}
performApply证实了前面的猜测，遍历list集合，取出Action对象，调用action.apply(...)更新窗口小部件。Action$apply是如何更新界面的呢，继续往下看~
5.3，分析Action$apply方法
前面以RemoteViews$setTextViewText为例，封装更新界面数据的Action是ReflectionAction，以其为例。
源码如下：
private class ReflectionAction extends Action {
ReflectionAction(int viewId, String methodName, int type, Object value) {
this.viewId = viewId;
this.methodName = methodName;
this.type = type;
this.value = value;
}
//...code
@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);
}
Class klass = view.getClass();
Method method;
try {
method = klass.getMethod(this.methodName, getParameterType());
}
catch (NoSuchMethodException ex) {
throw new ActionException("view: " + klass.getName() + " doesn't have method: "
+ this.methodName + "(" + param.getName() + ")");
}
if (!method.isAnnotationPresent(RemotableViewMethod.class)) {
throw new ActionException("view: " + klass.getName()
+ " can't use method with RemoteViews: "
+ this.methodName + "(" + param.getName() + ")");
}
try {
//noinspection ConstantIfStatement
if (false) {
Log.d(LOG_TAG, "view: " + klass.getName() + " calling method: "
+ this.methodName + "(" + param.getName() + ") with "
+ (this.value == null ? "null" : this.value.getClass().getName()));
}
method.invoke(view, this.value);
}
catch (Exception ex) {
throw new ActionException(ex);
}
}
}
上面大量篇幅从源码角度分析，窗口小部件如何更新界面，前面我们提到这里隐藏了一个非常重要的需求：跨进程更新界面。AppWidgetService是系统服务的一种，在SystemServer进程中执行。还是以窗口小部件为例，RemoteViews通过Binder机制传递到AppWidgetService中，并调用remoteViews$apply方法更新界面，并返回一个view，最后执行appWidgetHostView.addView(view)。好了，下面会给出源码分析后的扩展使用。
六，RemoteViews的扩展使用
上面通过Binder机制传递RemoteViews，这里不想这么复杂去处理，尝试使用广播去完成进程间传递RemoteViews的工作。在应用RvSender中发送广播，并将RemoteViews对象放入intent的extra中；在应用RvReceiver中接受广播，取出intent中的数据，并在该应用中完成界面更新。
应用RvSender：
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
public void clickButton(View v) {
//发送广播
Intent intent = new Intent();
intent.setAction("com.example.remoteview");
RemoteViews rv = new RemoteViews(getPackageName(), R.layout.rv_layout);
rv.setTextViewText(R.id.tv, "hello, from Sender");
intent.putExtra("remoteview", rv);
sendBroadcast(intent);
}
}
应用RvReceiver：
public class MainActivity extends Activity {
private RelativeLayout rl;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
init();
}
public void init() {
IntentFilter filter = new IntentFilter();
filter.addAction("com.example.remoteview");
MyReceiver receiver = new MyReceiver();
registerReceiver(receiver, filter);
rl = (RelativeLayout) findViewById(R.id.rl);
}
private class MyReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
if ("com.example.remoteview".equals(intent.getAction())) {
RemoteViews remoteViews = intent.getParcelableExtra("remoteview");
View view = remoteViews.apply(context, rl);
rl.addView(view);
}
}
}
}
这篇文章就分享到这里啦，有疑问可以留言，亦可纠错，亦可补充，互相学习...^_^