Android RemoteViews 11问11答

1.什么是RemoteView？

答：其实就是一种特殊的view结构，这种view 能够跨进程传输。并且这种remoteview 还提供了一些方法 可以跨进程更新界面。具体在android里面 一个是通知 一个是桌面小部件。

这2个就是remoteview 最直接的应用了

2.RemoteView在通知上的应用？

答：这里给出一个小例子，比较粗糙 仅做演示使用。

  //默认样式的notification
     private void normalStyleNotification() {
         Intent intent = new Intent(MainActivity.this, MainActivity.class);
         PendingIntent pendingIntent = PendingIntent.getActivity(MainActivity.this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
         Notification.Builder builder = new Notification.Builder(MainActivity.this);
         Notification notification = builder.setContentIntent(pendingIntent).setContentTitle("title").setContentText("text").setSmallIcon(R.mipmap.ic_launcher).build();
         NotificationManager manager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
         manager.notify(1, notification);
     }

     //自定义样式
     private void customStyleNotification() {
         Intent intent = new Intent(MainActivity.this, MainActivity.class);
         PendingIntent pendingIntent = PendingIntent.getActivity(MainActivity.this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
         Notification.Builder builder = new Notification.Builder(MainActivity.this);
         RemoteViews remoteViews = new RemoteViews(getPackageName(), R.layout.notification_layout);
         remoteViews.setTextViewText(R.id.tv, "自定义样式的文本");
         remoteViews.setImageViewResource(R.id.iv, R.mipmap.ic_launcher);
         Notification notification = builder.setSmallIcon(R.mipmap.ic_launcher).setContentIntent(pendingIntent).setContent(remoteViews).build();
         NotificationManager manager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
         manager.notify(2, notification);
     }

效果如下：

3.小部件开发 大概流程如何？

答：android的小部件开发就全都是用的remoteviews。其实就是一个广播接收器+ui显示 ，诸如下图显示：

启动某个小部件以后就可以看到：

下面给出一个简单的例子 ，示范下小部件的基本开发流程，其实非常简单，毕竟就只是一个广播而已。只不过在具体app中 小部件或许会变的非常复杂。

既然是广播，我们就首先要给他一个接收器，保证能接收到广播：

  <receiver android:name=".MyWidgetProvider">
             <meta-data
                 android:name="android.appwidget.provider"
                 android:resource="@xml/widget_info"></meta-data>
             <intent-filter>
                 <!--这个是单击事件的action-->
                 <action android:name="com.example.administrator.remoteviewtest.CLICK"></action>
                 <!--这个必须要有 属于默认需要添加的-->
                 <action android:name="android.appwidget.action.APPWIDGET_UPDATE"></action>
             </intent-filter>
         </receiver>

然后在res/xml下 建立我们的widget配置文件：

 <?xml version="1.0" encoding="utf-8"?>
 <appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
     android:initialLayout="@layout/layout_widget"
     android:minHeight="100dp"
     android:minWidth="200dp"
     android:updatePeriodMillis="160000"
     ></appwidget-provider>

然后写一个最简单的widget 的 layout文件:

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

     <ImageView
         android:id="@+id/iv2"
         android:layout_gravity="center"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:src="@mipmap/shuqi" />

 </LinearLayout>

最后 我们来编写我们的appwidgetProvider:　只完成一件事　就是点击他以后　图片就翻转

 package com.example.administrator.remoteviewtest;

 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;

 /**
  * Created by Administrator on 2016/2/5.
  */
 public class MyWidgetProvider extends AppWidgetProvider {

     public static final String CLICK_ACTION = "com.example.administrator.remoteviewtest.CLICK";

     @Override
     public void onReceive(final Context context, Intent intent) {
         super.onReceive(context, intent);
         if (intent.getAction().equals(CLICK_ACTION)) {
             Toast.makeText(context, "收到单击事件", Toast.LENGTH_SHORT).show();
             new Thread(new Runnable() {
                 @Override
                 public void run() {

                     Bitmap srcBitmap = BitmapFactory.decodeResource(context.getResources(), R.mipmap.shuqi);
                     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.layout_widget);
                         remoteviews.setImageViewBitmap(R.id.iv2, rotateBitmap(context, srcBitmap, degree));
                         //每次更新的时候 都别忘记了给他添加点击事件
                         Intent intentClick = new Intent();
                         intentClick.setAction(CLICK_ACTION);
                         PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, intentClick, 0);
                         remoteviews.setOnClickPendingIntent(R.id.iv2, pendingIntent);
                         appwidgetManager.updateAppWidget(new ComponentName(context, MyWidgetProvider.class), remoteviews);
                         SystemClock.sleep(30);
                     }
                 }
             }).start();
         }
     }

     @Override
     public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
         super.onUpdate(context, appWidgetManager, appWidgetIds);
         //这个地方couter 其实就是你widget 布局里面 带有id的 view的总数，比如我们这个例子里面就只有
         //一个imageview 有id 所以这个地方counter的值就是1
         final int counter = appWidgetIds.length;
         for (int i = 0; i < counter; i++) {
             int appWidgetId = appWidgetIds[i];
             //每次添加小部件或者小部件自己有更新时，我们都要重新更新小部件里面点击事件 等view相关的资源
             updateWidget(context, appWidgetManager, appWidgetId);
         }
     }

     private void updateWidget(Context context, AppWidgetManager appWidgetManager, int appWidgetId) {
         RemoteViews remoteviews = new RemoteViews(context.getPackageName(), R.layout.layout_widget);

         //单击小部件以后发生的事
         Intent intentClick = new Intent();
         intentClick.setAction(CLICK_ACTION);
         PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, intentClick, 0);
         remoteviews.setOnClickPendingIntent(R.id.iv2, pendingIntent);
         appWidgetManager.updateAppWidget(appWidgetId, remoteviews);
     }

     //将图片翻转一定的角度
     private Bitmap rotateBitmap(Context context, Bitmap srcBitmap, float degree) {
         Matrix matrix = new Matrix();
         matrix.reset();
         matrix.setRotate(degree);
         Bitmap dstBitmap = Bitmap.createBitmap(srcBitmap, 0, 0, srcBitmap.getWidth(), srcBitmap.getHeight(), matrix, true);
         return dstBitmap;
     }

 }

最后看一下简单的效果：

4.简述一下 widget开发中 几个重要的生命周期函数 都在什么情况下被调用？

答：onEnable ：当widget第一次被添加到桌面时调用，添加行为可以多次，但是这个函数只有在第一次时能得到执行。

　　onUpdate:widget被添加或者更新时就会执行

　　onDeleted：删除的时候执行

　　onDisabled:最后一个该类型的widget被删除的时候 调用他

　　onReceive：分发广播的。我们主要的逻辑一般都写在这里。

5.intent和PendingIntent有什么区别。

答：intent代表的行为 是马上就要发生。而pendingIntent代表 这个行为是在将来的某个不确定的时间发生。 我们给RemoteView 添加点击事件的时候 都用pendingIntent。

pendingIntent通过set和cancel 方法来发送和取消 那些intent。

6.pendingIntent 支持哪几种？

答：三种。分别是getActivity getService 和getBroadcast。

7.pendingIntent的匹配规则是什么？

答：内部的intent和requestCode 都相同的时候 系统就认为这2个pendingIntent是相同的。intent相同的判定原则是 intent-filter和componentName相同。

8.如何理解pendingIntent的 flags 标志位？

答：可以从通知的角度来理解。manager.notify(1, notification); 我们平常发通知的时候 这个函数的 第一个参数 ，我们一般都是写一个常量。注意notification里面是有pendingintent的。

当我们这一个参数是写死的常量的时候 那不管notification里面的pendingIntent 是什么，这个通知都是永远老的被新的直接替代。

如果这notify的第一个参数 每次都不相同，情况就复杂的多，要分开来看：

notify函数的第一个参数不相同，notification里的pendingintent不相同时：通知和通知之间互相不干扰，可以看看效果：

notify函数的第一个参数不相同，notification里的pendingintent相同时，这个时候就要看flags的参数了。

如果flag=FLAG_ONE_SHOT，那后续的pendingIntent就和第一个保持一致，哪怕是intent里面的参数extras 都是一致的。

而且如果点击任何一个通知，其他的通知都无法打开了。

flag=FLAG_CANCEL_CURRENT 只有最新的通知才能打开，以前的通知点击都无效无法打开。

flag=FLAG_UPDATE_CURRENT 之前的通知会被更新成 和最新的那条通知是一样的 里面的extras都是一样的。并且都可以打开。

9.remoteView 支持所有的view类型吗？

答：remoteview 仅仅支持少部分系统自带的view。开发者的自定义view 是一律都不支持的，具体支持哪些系统的view和viewgroup，可以自行谷歌。

10.简述remoteViews的 原理？

答：通知栏和widget 都是运行在 NotificationManagerService和AppWidgetService的，并且是在systemt server进程中。我们在apk代码里

使用notificationmanager或者appwidgetmanager实际上都是通过binder 来进行与system server的进程间通信的。

 public class RemoteViews implements Parcelable, Filter {

可以看到remotviews是继承了Parcelable接口。所以这个remoteviews会通过binder 传递到system server 这个系统进程里。然后系统进程

会解析这个remotview 拿到他的包名和布局文件等信息 然后就通过layoutInflater 来加载这个布局了。

对于system server来说  remoteview就好像是自己这个进程里的 资源一样，而对于调用者 也就是我们自己的apk程序员来说，这个view

就显然是remoteviews 远程的了。并且值得注意的是，view的更新操作 是由action对象的apply方法来执行的！这一点千万要记住。

我们可以从源码的角度来逐一分析。

 //假设我们remoteviews是调用了这个方法 我们就来看看这个方法的过程
    public void setTextViewText(int viewId, CharSequence text) {
         setCharSequence(viewId, "setText", text);
     }

 //这里就明白了 你看 到这还没有实际调用view的方法，而是调用了addAciton方法 好像是新增了一个action
      public void setCharSequence(int viewId, String methodName, CharSequence value) {
         addAction(new ReflectionAction(viewId, methodName, ReflectionAction.CHAR_SEQUENCE, value));
     }

 //这个方法就很简单 就是remoteviews内部有一个mActions对象 他是一个list 每次我们调用remoteviews的set方法的时候
 //实际上都是往这个列表里面 新增了一个action
 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);
     }

 //真正的执行view的方法 就是在apply函数里
     public View apply(Context context, ViewGroup parent, OnClickHandler handler) {
         RemoteViews rvToApply = getRemoteViewsToApply(context);

         View result;
         // RemoteViews may be built by an application installed in another
         // user. So build a context that loads resources from that user but
         // still returns the current users userId so settings like data / time formats
         // are loaded without requiring cross user persmissions.
         final Context contextForResources = getContextForResources(context);
         Context inflationContext = new ContextWrapper(context) {
             @Override
             public Resources getResources() {
                 return contextForResources.getResources();
             }
             @Override
             public Resources.Theme getTheme() {
                 return contextForResources.getTheme();
             }
             @Override
             public String getPackageName() {
                 return contextForResources.getPackageName();
             }
         };

         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);
         result = inflater.inflate(rvToApply.getLayoutId(), parent, false);
         //前面的就是加载资源而已 真正的调用 还是在perform函数里
         rvToApply.performApply(result, parent, handler);

         return result;
     }

 //每次remoteviews的apply方法 实际上就是遍历里面的action 然后调用每个action的 applay方法
 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);
             }
         }
     }

 //继续跟 我们会发现action是一个抽象类 他的apply方法要交给他的子类自己去实现
      private abstract static class Action implements Parcelable {
         public abstract void apply(View root, ViewGroup rootParent,
                 OnClickHandler handler) throws ActionException;
 //我们就看看ReflectionAction 这个子类的实现吧
 //很明显的 最终的反射调用 都是由子类自己来实现的，action的子类很多 有兴趣可以自己查
         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);
             }
         }

基本流程就是这样，另外注意apply和reapply的区别，后者只更新界面 而前者还要加载布局。

11.除了 通知和widget 我们还能怎样使用remoteviews？

答：remoteview 既然是被设计用来 跨进程 更新ui的。所有跨进程更新ui的 场景都可以使用他来做，这里给出2个范例。

第一个范例：同一个apk下，2个进程 ，其中一个activity另外一个activity的ui。

首先我们看主activity，就是用广播接收一个remoteviews 然后显示出来而已

 package com.example.administrator.remoteviewsameproject;

 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.os.Bundle;
 import android.support.design.widget.FloatingActionButton;
 import android.support.design.widget.Snackbar;
 import android.support.v7.app.AppCompatActivity;
 import android.support.v7.widget.Toolbar;
 import android.view.View;
 import android.view.Menu;
 import android.view.MenuItem;
 import android.widget.Button;
 import android.widget.LinearLayout;
 import android.widget.RemoteViews;

 public class MainActivity extends AppCompatActivity {

     private Button bt;

     private BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {

         @Override
         public void onReceive(Context context, Intent intent) {
             RemoteViews remoteViews = intent.getParcelableExtra("remoteViewsFlag");
             if (remoteViews != null) {
                 View view = remoteViews.apply(MainActivity.this, remoteViewsLayout);
                 remoteViewsLayout.addView(view);
             }
         }
     };

     private LinearLayout remoteViewsLayout;

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
         registerReceiver(mBroadcastReceiver,new IntentFilter("updateRemoteview"));
         remoteViewsLayout = (LinearLayout) findViewById(R.id.ll);
         bt = (Button) findViewById(R.id.bt);
         bt.setOnClickListener(new View.OnClickListener() {

             @Override
             public void onClick(View v) {
                 Intent intent = new Intent();
                 intent.setClass(MainActivity.this, OtherActivity.class);
                 startActivity(intent);
             }
         });

         Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
         setSupportActionBar(toolbar);

         FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
         fab.setOnClickListener(new View.OnClickListener() {
             @Override
             public void onClick(View view) {
                 Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
                         .setAction("Action", null).show();
             }
         });
     }

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

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

         //noinspection SimplifiableIfStatement
         if (id == R.id.action_settings) {
             return true;
         }

         return super.onOptionsItemSelected(item);
     }
 }

然后看运行在另外一个进程里的activity 这个activity负责发送remoteviews，注意你们自己写的时候 要在manifest里 更改android:process的值

 package com.example.administrator.remoteviewsameproject;

 import android.app.PendingIntent;
 import android.content.Intent;
 import android.os.Bundle;
 import android.support.design.widget.FloatingActionButton;
 import android.support.design.widget.Snackbar;
 import android.support.v7.app.AppCompatActivity;
 import android.support.v7.widget.Toolbar;
 import android.view.View;
 import android.widget.RemoteViews;
 import android.widget.TextView;

 public class OtherActivity extends AppCompatActivity {

     private TextView tv;

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_other);
         tv=(TextView)findViewById(R.id.tv);
         tv.setOnClickListener(new View.OnClickListener() {

             @Override
             public void onClick(View v) {
                 RemoteViews remoteViews=new RemoteViews(getPackageName(),R.layout.content_other);
                 remoteViews.setTextViewText(R.id.tv,"虽然是otherActivity的布局 但是我显示在mainActivity了");
                 PendingIntent pendingIntent=PendingIntent.getActivity(OtherActivity.this,0,new Intent(OtherActivity.this,MainActivity.class),PendingIntent.FLAG_UPDATE_CURRENT);
                 remoteViews.setOnClickPendingIntent(R.id.tv,pendingIntent);
                 Intent intent=new Intent("updateRemoteview");
                 intent.putExtra("remoteViewsFlag",remoteViews);
                 sendBroadcast(intent);

             }
         });

         Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
         setSupportActionBar(toolbar);

         FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
         fab.setOnClickListener(new View.OnClickListener() {
             @Override
             public void onClick(View view) {
                 Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
                         .setAction("Action", null).show();
             }
         });
     }

 }

然后看一下运行效果：

然后考虑第二种场景，就是不同apk 不同进程之间用remoteview 更新ui的例子。

因为不同apk的话，资源id是不同的，所以remoteview更新的时候 方法要改变一下。

你看我们上面的例子，取view 什么的 都是直接通过id 因为是一个apk么。

但是你想一下 2个apk的时候，你的id 和我的id 怎么可能一样？所以这种情况

我们2个apk 就要事先约定好remoteview里面的 资源名称。

然后我们在 根据名称 查找对应的布局文件 再进行加载。

针对这种情况 实际上我们只要修改主activity的代码即可

  public void onReceive(Context context, Intent intent) {
             RemoteViews remoteViews = intent.getParcelableExtra("remoteViewsFlag");
             if (remoteViews != null) {
                 int layoutId = getResources().getIdentifier("content_main", "layout", getPackageName());
                 ViewGroup view =(ViewGroup) getLayoutInflater().inflate(layoutId, remoteViewsLayout, false);
                 remoteViews.reapply(MainActivity.this, view);
                 remoteViewsLayout.addView(view);

             }
         }

然后我们就可以看到 另外一个apk的 remoteview  显示在我们的主apk的主页面里了