频道栏目
首页 > 程序开发 > 移动开发 > Android > 正文
RemoteViews完全解析
2016-07-11 09:10:32         来源:文哥  
收藏   我要投稿

一、概述

什么是RemoteViews?从字面意思可以理解为远程View。需要注意的是,RemoteViews并不是View的子类,它是Object的子类。它的作用是可以跨进程更新界面,是不是功能很强大?它在实际应用中主要在通知栏和桌面小控件,下面就全部基于通知栏来分析。

二、演示

这里写图片描述

这里写图片描述

三、RemoteViews在通知栏上的应用

定义了两个按钮,分别用来发送不同的通知


    

java代码


    case R.id.btn_normal:
            //1.创建通知对象
            Notification nf = new Notification() ;
            //2.通知的一些常用设置
            //图标
            nf.icon = R.drawable.ic_launcher ;
            //通知时间
            nf.when = System.currentTimeMillis();
            //消息来临时显示的提示信息
            nf.tickerText = "这是普通的通知";
            //设置通知自动取消
            nf.flags = Notification.FLAG_AUTO_CANCEL;
            //3.创建延时意图
            Intent intent = new Intent(this,NormalNotificationActivity.class);
            PendingIntent pi = PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
            //
            nf.setLatestEventInfo(this, "普通通知", "这是来自普通通知的摘要信息", pi);
            //4.创建notificationmanager对象
            NotificationManager nm = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
            //这里的id最好保证每次都是不一样的,否则第二次发送无效
            nm.notify(nId++ , nf);
            break;

这只是一个简单的通知,并没有涉及RemoteViews,主要是知道普通的通知应该如何书写。


    case R.id.btn_zdy:
            //1.创建通知对象
            Notification myNf = new Notification() ;
            //2.通知的一些常用设置
            //图标
            myNf.icon = R.drawable.ic_launcher ;
            //通知时间
            myNf.when = System.currentTimeMillis();
            myNf.tickerText = "这是自定义的通知";
            myNf.flags = Notification.FLAG_AUTO_CANCEL;
            //3.创建延时意图
            Intent myIntent = new Intent(this,NormalNotificationActivity.class);
            PendingIntent myPi = PendingIntent.getActivity(this, 0, myIntent, PendingIntent.FLAG_UPDATE_CURRENT);
            /**
             * 注意:这个字段是要配合nf.contentView这个字段一起使用的,如果只是设置一个会报错
             * nf.contentIntent = pi ;
             */
            /******************
             *没有设置contentIntent时:java.lang.IllegalArgumentException: contentIntent required: pkg=com.lw.remoteviewsdemo id=0 notification=Notification(vibrate=null,sound=null,defaults=0x0,flags=0x10)
             * ****************************/
            //4.创建RemoteViews
            RemoteViews rv = new RemoteViews(getPackageName(),R.layout.activity_mynotification);

            //给remoteviews手动设置值
            rv.setTextViewText(R.id.msg, "我是自定义通知");
            rv.setTextViewText(R.id.des, "我是对自定义通知的一些简单描述信息");

            myNf.contentView = rv ;
            myNf.contentIntent = myPi ;
            //5.创建notificationmanager对象
            NotificationManager myNm= (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
            //这里的id最好保证每次都是不一样的,否则第二次发送无效
            myNm.notify(nId++ , myNf);
            break;

这是自定义通知,上面的都有注释,就几个注意的地方说下,使用自定义通知需要为通知的这两个属性赋值,否则就会报上面提到的异常,少一个都不行。


    myNf.contentView = rv ;
    myNf.contentIntent = myPi ;

还有一点就是在通知myNm.notify(nId++ , myNf)的第一个参数不要设置为一个常量,否则只能发送一个通知。

源码分析">四、RemoteViews源码分析

在概述中提到,RemoteViews是跨进程更新UI的,也就是通过Binder,那么也就是说RemoteViews肯定实现了序列化接口,看源码:


    public class RemoteViews implements Parcelable, Filter 

再看上面的例子,RemoteViews是如何自定义一些文本内容的呢,大部分都是通过setTextViewText()等方法完成的,看源码


    public void setTextViewText(int viewId, CharSequence text) {
        setCharSequence(viewId, "setText", text);
    }

调用了setCharSequence方法,注意:这里的第二个参数是setText,是不是和TextView的setText很像呢,点进去


    public void setCharSequence(int viewId, String methodName, CharSequence value) {
        addAction(new ReflectionAction(viewId, methodName, ReflectionAction.CHAR_SEQUENCE, value));
    }

那么ReflectionAction又是什么东西呢?从字面可以理解为反射动作。


    /**
     * Base class for the reflection actions.
     */
    private class ReflectionAction extends Action {
        static final int TAG = 2;

        static final int BOOLEAN = 1;
        static final int BYTE = 2;
        static final int SHORT = 3;
        static final int INT = 4;
        static final int LONG = 5;
        static final int FLOAT = 6;
        static final int DOUBLE = 7;
        static final int CHAR = 8;
        static final int STRING = 9;
        static final int CHAR_SEQUENCE = 10;
        static final int URI = 11;
        // BITMAP actions are never stored in the list of actions. They are only used locally
        // to implement BitmapReflectionAction, which eliminates duplicates using BitmapCache.
        static final int BITMAP = 12;
        static final int BUNDLE = 13;
        static final int INTENT = 14;

从源码可以看出,它是Action的子类,从注释可以看出它是反射类的基类,通过之前传递过来的setText来进行反射获取信息,这个类需要配合一会分析的RemoteViews的apply()方法配合看。再回到前面的addAction方法


     /**
     * Add an action to be executed on the remote side when apply is called.
     *
     * @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 inpidually before constructing the combined layout.");
        }
        if (mActions == null) {
            mActions = new ArrayList();
        }
        mActions.add(a);

        // update the memory usage stats
        a.updateMemoryUsageEstimate(mMemoryUsageCounter);
    }

可以看出,系统首先判断mActions是否为null,如果为null,则创建一个存放Action的List集合,然后就将传递过来的Action添加到mActions中。再来看一些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 static final int MERGE_REPLACE = 0;
        public static final int MERGE_APPEND = 1;
        public static final int MERGE_IGNORE = 2;

        public int describeContents() {
            return 0;
        }

        /**
         * Overridden by each class to report on it's own memory usage
         */
        public void updateMemoryUsageEstimate(MemoryUsageCounter counter) {
            // We currently only calculate Bitmap memory usage, so by default, don't do anything
            // here
            return;
        }

        public void setBitmapCache(BitmapCache bitmapCache) {
            // Do nothing
        }

        public int mergeBehavior() {
            return MERGE_REPLACE;
        }

        public abstract String getActionName();

        public String getUniqueKey() {
            return (getActionName() + viewId);
        }

        int viewId;
    }

从注释可以看出它是一个在被填充的展现出来的所有Action的基类,实现Parcelable接口。
简单来说setTextViewText(int viewId, CharSequence text) 方法首先将其封装成一个动作Action类,然后添加到一个actions集合中去。

接着,再来看看RemoteViews的apply方法


    public View apply(Context context, ViewGroup parent) {
        return apply(context, parent, null);
    }

再点进去


    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;
    }

首先,通过上下文获取RemoteViews,然后调用performApply()方法,再看下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);
            }
        }
    }

这里就可以看出来了,首先判断mActions集合是否为null,不为null,依次遍历actions,然后将处理交给action的apply方法,由于之前我调用的是setTextViewText方法,在那里添加的action的是ReflectionAction,所以这里查看的是ReflectionAction的apply方法,


     @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);
            }
        }

从上面的代码可以看出,主要是通过反射来执行代码,而方法名之前也已经有了,只需要调用invoke即可。OK,这就是RemoteViews的大致流程了。下面就这种思想使用RemoteViews来实现一个跨进程更新UI的例子

五、使用RemoteViews跨进程更新UI的Demo

1.思路

创建两个应用,一个作为本地,一个作为远程,当然如果想要在一个应用使用两个Activity实现也是可以的,只需要在其中一个你想要的Activity作为远程Activity中的配置文件中指定以下代码即可,我这里就是使用两个应用,效果观看更加明显。

    android:process=":remote"

通知栏的跨进程是通过Binder实现的,我这里就通过广播接受者来实现。OK,上代码

2.代码

本地布局文件


    

    
    

     

子LinearLayout是用来存放从远程传递过来的布局的。

本地java代码


    public class MainActivity extends Activity {
    private IntentFilter filter;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ll_layout = (LinearLayout) findViewById(R.id.ll_layout);
        filter = new IntentFilter("com.lw.remoteviewstest1");
        registerReceiver(mRemoteViewsReceiver, filter);

    }

    private BroadcastReceiver mRemoteViewsReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            RemoteViews remoteViews = intent
                    .getParcelableExtra("remoteViews");
            if (remoteViews != null) {
                updateLayout(remoteViews);
            }
        }
    };
    private LinearLayout ll_layout;

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //反注册广播接受者
        if(mRemoteViewsReceiver != null ){
            unregisterReceiver(mRemoteViewsReceiver);
        }
    }
    /**
     * 根据remoteViews更新ui
     * @param remoteViews
     */
    protected void updateLayout(RemoteViews remoteViews) {
        View view = remoteViews.apply(this, ll_layout);
        ll_layout.addView(view);
    };

}

主要在onCreate动态创建一个广播接收者,然后再onDestory中反注册,当从远程获取到remoteViews的时候调用updateLayout的方法,通过remoteViews的apply方法,这个方法前面已经详细分析了,就不在谈了。

远程布局文件


    

    

远程java代码


     public void send(View view){
        //创建remoteviews
        RemoteViews rv = new RemoteViews(getPackageName(),R.layout.activity_notification);
        //创建intent,设置当点击按钮时要跳转的Activity
        Intent sendIntent = new Intent(this,SecondActivity.class);
        //创建延时意图
        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, sendIntent, PendingIntent.FLAG_UPDATE_CURRENT);
        //为延时意图中的按钮设置点击事件
        rv.setOnClickPendingIntent(R.id.btn_toast, pendingIntent) ;
        //创建隐式跳转
        Intent intent = new Intent("com.lw.remoteviewstest1");
        //将RemoteViews带到应用一中去
        intent.putExtra("remoteViews", rv);
        //发送广播
        sendBroadcast(intent);
    }

这里提下,如果想要为remoteviews添加点击事件,则必须使用PendingIntent,其实最后还是通过添加action,不过这里的action不是前面提到的反射action,而是SetOnClickPendingIntent,我们可以看下这个类的apply方法,这里只需要看最后一个代码,最后调用了setOnclickListener方法,其它的注释都比较详细,就不说了。


     @Override
        public void apply(View root, ViewGroup rootParent, final OnClickHandler handler) {
            final View target = root.findViewById(viewId);
            if (target == null) return;

            // If the view is an AdapterView, setting a PendingIntent on click doesn't make much
            // sense, do they mean to set a PendingIntent template for the AdapterView's children?
            if (mIsWidgetCollectionChild) {
                Log.w(LOG_TAG, "Cannot setOnClickPendingIntent for collection item " +
                        "(id: " + viewId + ")");
                ApplicationInfo appInfo = root.getContext().getApplicationInfo();

                // We let this slide for HC and ICS so as to not break compatibility. It should have
                // been disabled from the outset, but was left open by accident.
                if (appInfo != null &&
                        appInfo.targetSdkVersion >= Build.VERSION_CODES.JELLY_BEAN) {
                    return;
                }
            }

            if (target != null) {
                // 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 float appScale = v.getContext().getResources()
                                    .getCompatibilityInfo().applicationScale;
                            final int[] pos = new int[2];
                            v.getLocationOnScreen(pos);

                            final Rect rect = new Rect();
                            rect.left = (int) (pos[0] * appScale + 0.5f);
                            rect.top = (int) (pos[1] * appScale + 0.5f);
                            rect.right = (int) ((pos[0] + v.getWidth()) * appScale + 0.5f);
                            rect.bottom = (int) ((pos[1] + v.getHeight()) * appScale + 0.5f);

                            final Intent intent = new Intent();
                            intent.setSourceBounds(rect);
                            handler.onClickHandler(v, pendingIntent, intent);
                        }
                    };
                }
                target.setOnClickListener(listener);
            }
        }

Demo整体思路:远程主要通过Intent携带RemoteViews传递到本地连接,本地连接获取到RemoteViews之后,调用apply方法返回个View对象,这个view对象就是远程RotateViews携带的布局,然后添加到本地对应的布局中去。

OK,这篇关于RemoteViews的学习总结就到这了

点击复制链接 与好友分享!回本站首页
相关TAG标签
上一篇:Android 推荐几款好用的开源作品(二)之万能RecyclerView适配器
下一篇:Android EventBus3.0使用及源码解析
相关文章
图文推荐
点击排行

关于我们 | 联系我们 | 广告服务 | 投资合作 | 版权申明 | 在线帮助 | 网站地图 | 作品发布 | Vip技术培训 | 举报中心

版权所有: 红黑联盟--致力于做实用的IT技术学习网站