Android中Window添加View的底层原理

一，WIndow和windowManager

Window是一个抽象类，它的具体实现是PhoneWindow，创建一个window很简单，只需要创建一个windowManager即可，window具体实现在windowManagerService中，windowManager和windowManagerService的交互是一个IPC的过程。

下面是用windowManager的例子:

 mFloatingButton = new Button(this);
            mFloatingButton.setText( "window");
            mLayoutParams = new WindowManager.LayoutParams(
                    LayoutParams. WRAP_CONTENT, LayoutParams.WRAP_CONTENT, 0, 0,
                    PixelFormat. TRANSPARENT);
            mLayoutParams. flags = LayoutParams.FLAG_NOT_TOUCH_MODAL
                    | LayoutParams. FLAG_NOT_FOCUSABLE
                    | LayoutParams. FLAG_SHOW_WHEN_LOCKED;
            mLayoutParams. type = LayoutParams. TYPE_SYSTEM_ERROR;
            mLayoutParams. gravity = Gravity. LEFT | Gravity. TOP;
            mLayoutParams. x = 100;
            mLayoutParams. y = 300;
            mFloatingButton.setOnTouchListener( this);
             mWindowManager.addView( mFloatingButton, mLayoutParams);

flags和type两个属性很重要，下面对一些属性进行介绍，首先是flags：

FLAG_NOT_TOUCH_MODAL表示不需要获取焦点，也不需要接收各种输入，最终事件直接传递给下层具有焦点的window。

FLAG_NOT_FOCUSABLE：在此window外的区域单击事件传递到底层window中。当前的区域则自己处理，这个一般都要设置，很重要。

FLAG_SHOW_WHEN_LOCKED ：开启可以让window显示在锁屏界面上。

再来看下type这个参数：

window有三种类型：应用window，子window，系统window。应用类对应一个Activity，子Window不能单独存在，需要附属在父Window上，比如常用的Dialog。系统Window是需要声明权限再创建的window，如toast等。

window有z-ordered属性，层级越大，越在顶层。应用window层级1-99，子window1000-1999，系统2000-2999。这此层级对应着windowManager的type参数。系统层级常用的有两个TYPE_SYSTEM_OVERLAY或者TYPE_SYSTEM_ERROR。比如想用TYPE_SYSTEM_ERROR，只需

mLayoutParams.type = LayoutParams.TYPE_SYSTEM_ERROR。还要添加权限<uses-permission andorid:name="android.permission.SYSTEM_ALERT_WINDOW"/>。

有了对window的基本认识之后，我们来看下它底层如何实现加载View的。

二，window的创建。

其实Window的创建跟之前我写的一篇博客LayoutInflater源码分析有点相似。Window的创建是在Activity创建的attach方法中，通过PolicyManager的makeNewWindow方法。Activity中实现了Window的Callback接口，因此当window状态改变时就会回调Activity方法。如onAttachedToWindow等。PolicyManager的真正实现类是Policy，看下它的代码：

 public Window makeNewWindow(Context context) {
        return new PhoneWindow(context);
    }

到此Window创建完成。

下面分析view是如何附属到window上的。看Activity的setContentView方法。

public void setContentView(int layoutResID) {
        getWindow().setContentView(layoutResID);
        initWindowDecorActionBar();
    }

两部分，设置内容和设置ActionBar。window的具体实现是PhoneWindow，看它的setContent。

public void setContentView(int layoutResID) {
        // Note: FEATURE_CONTENT_TRANSITIONS may be set in the process of installing the window
        // decor, when theme attributes and the like are crystalized. Do not check the feature
        // before this happens.
        if (mContentParent == null) {
            installDecor();
        } else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
            mContentParent.removeAllViews();
        }

        if (hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
            final Scene newScene = Scene.getSceneForLayout(mContentParent, layoutResID,
                    getContext());
            transitionTo(newScene);
        } else {
            mLayoutInflater.inflate(layoutResID, mContentParent);
        }
        final Callback cb = getCallback();
        if (cb != null && !isDestroyed()) {
            cb.onContentChanged();
        }
   }

看到了吧，又是分析它。

这里分三步执行：

1.如果没有DecorView，在installDecor中的generateDecor()创建DecorView。之前就分析过，这次就不再分析它了。

2.将View添加到decorview中的mContentParent中。

3.回调Activity的onContentChanged接口。

经过以上操作，DecorView创建了，但还没有正式添加到Window中。在ActivityResumeActivity中首先会调用Activity的onResume，再调用Activity的makeVisible，makeVisible中真正添加view ，代码如下：

  void makeVisible() {
        if (!mWindowAdded) {
            ViewManager wm = getWindowManager();
            wm.addView(mDecor, getWindow().getAttributes());
            mWindowAdded = true;
        }
        mDecor.setVisibility(View.VISIBLE);
    }

通过上面的addView方法将View添加到Window。

三，Window操作View内部机制

1.window的添加

一个window对应一个view和一个viewRootImpl,window和view通过ViewRootImpl来建立联系，它并不存在，实体是view。只能通过 windowManager来操作它。

windowManager的实现类是windowManagerImpl。它并没有直接实现三大操作，而是委托给WindowManagerGlobal。addView的实现分为以下几步：

1.检查参数是否合法。

if (view == null) {
            throw new IllegalArgumentException("view must not be null");
        }
        if (display == null) {
            throw new IllegalArgumentException("display must not be null");
        }
        if (!(params instanceof WindowManager.LayoutParams)) {
            throw new IllegalArgumentException("Params must be WindowManager.LayoutParams");
        }

        final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams)params;
        if (parentWindow != null) {
            parentWindow.adjustLayoutParamsForSubWindow(wparams);
        } else {
            // If there's no parent and we're running on L or above (or in the
            // system context), assume we want hardware acceleration.
            final Context context = view.getContext();
            if (context != null
                    && context.getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.LOLLIPOP) {
                wparams.flags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED;
            }
        }

2.创建ViewRootImpl并将View添加到列表中。

 root = new ViewRootImpl(view.getContext(), display);

            view.setLayoutParams(wparams);

            mViews.add(view);
            mRoots.add(root);
            mParams.add(wparams);

3.通过ViewRootImpl来更新界面并完成window的添加过程 。

root.setView(view, wparams, panelParentView);

上面的root就是ViewRootImpl，setView中通过requestLayout()来完成异步刷新，看下requestLayout：

 public void requestLayout() {
        if (!mHandlingLayoutInLayoutRequest) {
            checkThread();
            mLayoutRequested = true;
            scheduleTraversals();
        }
    }

接下来通过WindowSession来完成window添加过程，WindowSession是一个Binder对象，真正的实现类是 Session，window的添加是一次IPC调用。

 try {
                    mOrigWindowType = mWindowAttributes.type;
                    mAttachInfo.mRecomputeGlobalAttributes = true;
                    collectViewAttributes();
                    res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
                            getHostVisibility(), mDisplay.getDisplayId(),
                            mAttachInfo.mContentInsets, mAttachInfo.mStableInsets, mInputChannel);
                } catch (RemoteException e) {
                    mAdded = false;
                    mView = null;
                    mAttachInfo.mRootView = null;
                    mInputChannel = null;
                    mFallbackEventHandler.setView(null);
                    unscheduleTraversals();
                    setAccessibilityFocus(null, null);
                    throw new RuntimeException("Adding window failed", e);
}

在Session内部会通过WindowManagerService来实现Window的添加。

  public int addToDisplay(IWindow window, int seq, WindowManager.LayoutParams attrs,
            int viewVisibility, int displayId, Rect outContentInsets, Rect outStableInsets,
            InputChannel outInputChannel) {
        return mService.addWindow(this, window, seq, attrs, viewVisibility, displayId,
                outContentInsets, outStableInsets, outInputChannel);
    }

在WindowManagerService内部会为每一个应用保留一个单独的session。

2.window的删除

看下WindowManagerGlobal的removeView：

public void removeView(View view, boolean immediate) {
        if (view == null) {
            throw new IllegalArgumentException("view must not be null");
        }

        synchronized (mLock) {
            int index = findViewLocked(view, true);
            View curView = mRoots.get(index).getView();
            removeViewLocked(index, immediate);
            if (curView == view) {
                return;
            }

            throw new IllegalStateException("Calling with view " + view
                    + " but the ViewAncestor is attached to " + curView);
        }
    }

首先调用findViewLocked来查找删除view的索引，这个过程就是建立数组遍历。然后再调用removeViewLocked来做进一步的删除。

private void removeViewLocked(int index, boolean immediate) {
        ViewRootImpl root = mRoots.get(index);
        View view = root.getView();

        if (view != null) {
            InputMethodManager imm = InputMethodManager.getInstance();
            if (imm != null) {
                imm.windowDismissed(mViews.get(index).getWindowToken());
            }
        }
        boolean deferred = root.die(immediate);
        if (view != null) {
            view.assignParent(null);
            if (deferred) {
                mDyingViews.add(view);
            }
        }
    }

真正删除操作是viewRootImpl来完成的。windowManager提供了两种删除接口，removeViewImmediate，removeView。它们分别表示异步删除和同步删除。具体的删除操作由ViewRootImpl的die来完成。

boolean die(boolean immediate) {
        // Make sure we do execute immediately if we are in the middle of a traversal or the damage
        // done by dispatchDetachedFromWindow will cause havoc on return.
        if (immediate && !mIsInTraversal) {
            doDie();
            return false;
        }

        if (!mIsDrawing) {
            destroyHardwareRenderer();
        } else {
            Log.e(TAG, "Attempting to destroy the window while drawing!\n" +
                    "  window=" + this + ", title=" + mWindowAttributes.getTitle());
        }
        mHandler.sendEmptyMessage(MSG_DIE);
        return true;
    }

由上可知如果是removeViewImmediate，立即调用doDie，如果是removeView，用handler发送消息，ViewRootImpl中的Handler会处理消息并调用doDie。重点看下doDie:

void doDie() {
        checkThread();
        if (LOCAL_LOGV) Log.v(TAG, "DIE in " + this + " of " + mSurface);
        synchronized (this) {
            if (mRemoved) {
                return;
            }
            mRemoved = true;
            if (mAdded) {
                dispatchDetachedFromWindow();
            }

            if (mAdded && !mFirst) {
                destroyHardwareRenderer();

                if (mView != null) {
                    int viewVisibility = mView.getVisibility();
                    boolean viewVisibilityChanged = mViewVisibility != viewVisibility;
                    if (mWindowAttributesChanged || viewVisibilityChanged) {
                        // If layout params have been changed, first give them
                        // to the window manager to make sure it has the correct
                        // animation info.
                        try {
                            if ((relayoutWindow(mWindowAttributes, viewVisibility, false)
                                    & WindowManagerGlobal.RELAYOUT_RES_FIRST_TIME) != 0) {
                                mWindowSession.finishDrawing(mWindow);
                            }
                        } catch (RemoteException e) {
                        }
                    }

                    mSurface.release();
                }
            }

            mAdded = false;
        }
        WindowManagerGlobal.getInstance().doRemoveView(this);
    }

主要做四件事:

1.垃圾回收相关工作，比如清数据，回调等。

2.通过Session的remove方法删除Window,最终调用WindowManagerService的removeWindow

3.调用dispathDetachedFromWindow，在内部会调用onDetachedFromWindow()和onDetachedFromWindowInternal()。当view移除时会调用onDetachedFromWindow，它用于作一些资源回收。

4.通过doRemoveView刷新数据，删除相关数据，如在mRoot，mDyingViews中删除对象等。

void doRemoveView(ViewRootImpl root) {
        synchronized (mLock) {
            final int index = mRoots.indexOf(root);
            if (index >= 0) {
                mRoots.remove(index);
                mParams.remove(index);
                final View view = mViews.remove(index);
                mDyingViews.remove(view);
            }
        }
        if (HardwareRenderer.sTrimForeground && HardwareRenderer.isAvailable()) {
            doTrimForeground();
        }
    }

3.更新window

看下WindowManagerGlobal中的updateViewLayout。

 public void updateViewLayout(View view, ViewGroup.LayoutParams params) {
        if (view == null) {
            throw new IllegalArgumentException("view must not be null");
        }
        if (!(params instanceof WindowManager.LayoutParams)) {
            throw new IllegalArgumentException("Params must be WindowManager.LayoutParams");
        }

        final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams)params;

        view.setLayoutParams(wparams);

        synchronized (mLock) {
            int index = findViewLocked(view, true);
            ViewRootImpl root = mRoots.get(index);
            mParams.remove(index);
            mParams.add(index, wparams);
            root.setLayoutParams(wparams, false);
        }
    }

通过viewRootImpl的setLayoutParams更新viewRootImpl的layoutParams,接着scheduleTraversals对view重新布局，包括测量，布局，重绘，此外它还会通过WindowSession来更新window。这个过程由WindowManagerService实现。这跟上面类似，就不再重复。到此Window底层源码就分析完啦。

时间： 2024-12-15 01:36:03

Android中Window添加View的底层原理的相关文章

Android中动态添加View的两种方法

一.使用xml的方式: 1.LayoutInflater: 这个类可以把xml表述的Layout解析为View,从而可以使addView()方法添加View. 2.LayoutInflater与findViewById的区别: 两者都是实例化某一个对象,不同的是findViewById是通过找xml布局文件下的一个具体的widget控件进行实例化,而LayoutInflater是找res/layout 下的xml布局文件来实例化的. 3.使用方法: LayoutInflater inflater

Android在布局中动态添加view的两种方法

一.说明 添加视图文件的时候有两种方式:1.通过在xml文件定义layout:2.java代码编写 二.前言说明 1.构造xml文件 2.LayoutInflater 提到addview,首先要了解一下LayoutInflater类.这个类最主要的功能就是实现将xml表述的layout转化为View的功能.为了便于理解,我们可以将它与findViewById()作一比较,二者都是实例化某一对象,不同的是findViewById()是找xml布局文件下的具体widget控件实例化,而LayoutI

Android中为APP创建快捷方式的原理（自己的理解）

我们首先来看Android中为APP创建快捷方式的原理: 从图上可以看出,Android大致分7步完成快捷方式的创建: 第一步:Android系统的launcher程序会调用它的pickShortcut()方法去启动系统的pickActivity程序(应用): 第二步:pickActivity程序(应用)启动后会调用它的CheckIntentFilter()方法,去在系统中寻找可以创建快捷方式的应用有哪些,并且列举出来.只要第三方                     App用<Intent-

Android中自定义视图View之---进阶篇(Canvas的使用)

更多技术内容请移步:我的个人博客 一.前言 今天是周日,昨天刚刚写完了一篇关于如何搭建LNMP环境,让自己可以DIY有个性的个人主页: http://blog.csdn.net/jiangwei0910410003/article/details/50929955 那么今天,我们继续来看一篇关于Android中的UI篇,如何自定义视图View的进阶篇,关于前奏篇之前已经写过了,还没有了解的同学可以去看看:http://blog.csdn.net/jiangwei0910410003/articl

WindowManager和Window添加View的区别(转)

WindowManager中有个添加View的函数: public void addView(View view, ViewGroup.LayoutParams params) Window中有个添加View的函数: public void addContentView(View view, ViewGroup.LayoutParams params) 弄清楚这两个类和这两个函数的作用设计到Android整个Surface系统,这里不详述,只作说明,供自己记录. 事实上,这两个函数是Activi

android中正确保存view的状态

英文原文: http://trickyandroid.com/saving-android-view-state-correctly/ 转载此译文须注明出处. 今天我们聊一聊安卓中保存和恢复view状态的问题.我刻意强调View状态是因为我发现这个过程要比保存 Activity 和 Fragment状态稍微复杂,还有一个原因是因为网上有太多“重复造的轮子”(有时还是奇丑无比的轮子). 为什么我们需要保存View的状态? 这个问题问的好!我坚信移动应用应该帮助你解决问题,而不是制造问题. 想象一下

Android中自定义视图View之---前奏篇

前言 好长时间没写blog了,心里感觉有点空荡荡的,今天有时间就来写一个关于自定义视图的的blog吧.关于这篇blog,网上已经有很多案例了,其实没什么难度的.但是我们在开发的过程中有时候会用到一些自定义的View以达到我们所需要的效果.其实网上的很多案例我们看完之后,发现这部分没什么难度的,我总结了两点: 1.准备纸和笔,计算坐标 2.在onDraw方法中开始画图,invalidate方法刷新,onTouchEvent方法监听触摸事件 对于绘图相关的知识,之前在弄JavaSE相关的知识的时候,

Android中自定义视图View之---开发案例

自定义视图View的案例 下面我们就是开始正式的进入自定义视图View了 在讲解正式内容之前,我们先来看一下基本知识 1.我们在自定义视图View的时候正确的步骤和方法 1).必须定义有Context/Attrbuite参数的构造方法,并且调用父类的方法 public LabelView(Context context, AttributeSet attrs) 不然会报错: 2).重写onMeasure方法 @Override protected void onMeasure(int width

Android中如何使用View填充在多个TextView之间使之等间距

(1)我们如果使用多个的TextView的话就会挤在一起如下所示: 相应的代码如下: <LinearLayout android:layout_width="wrap_content" android:layout_height="40dp" > <TextView android:layout_width="40dp" android:layout_height="40dp" android:text=&q