Android view的显示

最新推荐文章于 2023-06-06 15:53:11 发布
最新推荐文章于 2023-06-06 15:53:11 发布
阅读量596 收藏 1
点赞数 2
分类专栏： Android系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010456460/article/details/107831614
版权

前言

我们通过startActivity方法来启动一个activity，宏观上来看，当我们调用该方法的时候，APP就启动了，整个界面显示，此时可以开始交互，点击或滑动。但系统在其中做了不少动作，创建进程，创建Application，创建Activity，利用AMS对activity进行生命周期管理，当一切准备就绪，调用activity的onCreate方法，将自定义view内容填充到DecorView（具体是填充到ContentParent对象中）中，接着执行resume该activity，调用makeVisible方法将整个窗口显示出来。在这个过程中，AMS扮演的是对activity进行生命周期管理的角色，而将界面显示出来，让用户能看到具体内容的，则需要WMS这位仁兄的协助。

系统版本号说明

此次分析的系统版本为Android9.0版本。

概述

我们接着makeVisible方法进行分析之前，先聊下两个跟窗口相关的类，那就是WindowManager和Window，这两个类是在调用Activity的attach方法时出现的：

//frameworks/base/core/java/android/app/Activity.java
final void attach(Context context, ActivityThread aThread,
        Instrumentation instr, IBinder token, int ident,
        Application application, Intent intent, ActivityInfo info,
        CharSequence title, Activity parent, String id,
        NonConfigurationInstances lastNonConfigurationInstances,
        Configuration config, String referrer, IVoiceInteractor voiceInteractor,
        Window window, ActivityConfigCallback activityConfigCallback) {
        
        ...
    mWindow = new PhoneWindow(this, window, activityConfigCallback);
    mWindow.setWindowControllerCallback(this);
    mWindow.setCallback(this);
    mWindow.setOnWindowDismissedCallback(this);
    
    ...
    mWindow.setWindowManager(
            (WindowManager)context.getSystemService(Context.WINDOW_SERVICE),
            mToken, mComponent.flattenToString(),
            (info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0);
    if (mParent != null) {
        mWindow.setContainer(mParent.getWindow());
    }
    mWindowManager = mWindow.getWindowManager();
    ...
}

其中Window类是个抽象类，需要具体的实现类，这个实现类就是PhoneWindow。而WindowManager对象则是通过Window的getWindowManager方法获取：

/frameworks/base/core/java/android/view/Window.java
public WindowManager getWindowManager() {
    return mWindowManager;
}

方法很简单，直接返回mWindowManager成员，mWindowManager是在调用setWindowManager方法时实现赋值的：

/frameworks/base/core/java/android/view/Window.java
public void setWindowManager(WindowManager wm, IBinder appToken, String appName,
        boolean hardwareAccelerated) {
    mAppToken = appToken;
    mAppName = appName;
    mHardwareAccelerated = hardwareAccelerated
            || SystemProperties.getBoolean(PROPERTY_HARDWARE_UI, false);
    if (wm == null) {
        wm = (WindowManager)mContext.getSystemService(Context.WINDOW_SERVICE);
    }
    mWindowManager = ((WindowManagerImpl)wm).createLocalWindowManager(this);
}

这里通过WindowManagerImpl类的createLocalWindowManager方法创建一个WindowManagerImpl对象：

//frameworks/base/core/java/android/view/WindowManagerImpl.java
public WindowManagerImpl createLocalWindowManager(Window parentWindow) {
    return new WindowManagerImpl(mContext, parentWindow);
}

WindowManager类是个接口类，具体的方法需要WindowManagerImpl来实现。

addView

大概介绍了Activity中mWindowManager的由来，那么接下来就从makeVisible开始：

//frameworks/base/core/java/android/app/Activity.java
void makeVisible() {
    if (!mWindowAdded) {
        ViewManager wm = getWindowManager();
        wm.addView(mDecor, getWindow().getAttributes());
        mWindowAdded = true;
    }
    mDecor.setVisibility(View.VISIBLE);
}

在makeVisible之前，系统有调过一次addView方法，此时再做了一次判断，如果之前没有进行addView，那么就调用一次，将DecorView添加到窗口中。getWindowManager()返回的就是attach方法中获取的WindowManagerImpl对象，所以这里addView实际上调用了WindowManagerImpl中的方法：

//frameworks/base/core/java/android/view/WindowManagerImpl.java
public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
    applyDefaultToken(params);
    mGlobal.addView(view, params, mContext.getDisplay(), mParentWindow);
}

没想到这货只是个中转站，直接调用mGlobal成员的方法，而mGlobal的初始化如下：

private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();

声明的时候就进行了初始化，getInstance的实现如下：

//frameworks/base/core/java/android/view/WindowManagerGlobal.java
public static WindowManagerGlobal getInstance() {
    synchronized (WindowManagerGlobal.class) {
        if (sDefaultWindowManager == null) {
            sDefaultWindowManager = new WindowManagerGlobal();
        }
        return sDefaultWindowManager;
    }
}

由此可见，WindowManagerGlobal类是个单例类，即一个进程中有且只有一个mGlobal。
既然addView最终由WindowManagerGlobal类实现，我们看看它的关键成员：

private final ArrayList<View> mViews = new ArrayList<View>();
private final ArrayList<ViewRootImpl> mRoots = new ArrayList<ViewRootImpl>();
private final ArrayList<WindowManager.LayoutParams> mParams =
        new ArrayList<WindowManager.LayoutParams>();

一个APP可能有多个窗口，所以使用了ArrayList用来存储。其中mViews用来存放DecorView，所有窗口的view都存放在这里；

mRoots是用来存放view对应的ViewRootImpl对象，提供view和WMS之间通讯的接口，后续对view的处理，需要通过ViewRootImpl来实现；

mParams用来存放各个窗口的布局参数。

介绍了以上三个成员后，我们再来看看具体addView的实现：

//frameworks/base/core/java/android/view/WindowManagerGlobal.java
public void addView(View view, ViewGroup.LayoutParams params,
        Display display, Window parentWindow) {
    ...
    final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams) params;
    ...
    ViewRootImpl root;
    View panelParentView = null;

    synchronized (mLock) {
    
        ...
        //是否该view已经添加过，如果已经添加过，还要判断是否已经正在被销毁，否则
        //抛出IllegalStateException异常，表示该view已经被添加过
        int index = findViewLocked(view, false); 
        if (index >= 0) {
            if (mDyingViews.contains(view)) {
                // Don't wait for MSG_DIE to make it's way through root's queue.
                mRoots.get(index).doDie();
            } else {
                throw new IllegalStateException("View " + view
                        + " has already been added to the window manager.");
            }
            // The previous removeView() had not completed executing. Now it has.
        }
        
        ...
        //获取ViewRootImpl对象，view的显示还得靠它在中间处理
        root = new ViewRootImpl(view.getContext(), display);

        view.setLayoutParams(wparams);

        mViews.add(view); //添加view
        mRoots.add(root); //添加ViewRootImpl对象
        mParams.add(wparams); //添加窗口布局参数
        // do this last because it fires off messages to start doing things
        try {
            //调用ViewRootImpl对象的setView方法
            root.setView(view, wparams, panelParentView);
        } catch (RuntimeException e) {
            // BadTokenException or InvalidDisplayException, clean up.
            if (index >= 0) {
                removeViewLocked(index, true);
            }
            throw e;
        }
    
    }
}

addView中主要做了三件事：

1.所添加的view是否已经添加过，如果添加过，还要判断是否正在被销毁，否则抛出IllegalStateException异常，表示该view已经被添加过；
2.如果该view未添加过，则根据view实例化一个对应的ViewRootImpl对象，并添加到mRoots列表中，同时将view和params也添加到对应的列表中；
3.调用ViewRootImpl对象的setView方法，进行下一步处理；

到目前为止，还未看到WMS相关的处理。继续往下看。

setView

上文说了，ViewRootImpl类是view和WMS通讯的桥梁，setView方法中就开始跟WMS进行通讯了：

//frameworks/base/core/java/android/view/ViewRootImpl.java
public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
    synchronized (this) {
        ...
        requestLayout();
        if ((mWindowAttributes.inputFeatures
                & WindowManager.LayoutParams.INPUT_FEATURE_NO_INPUT_CHANNEL) == 0) {
            mInputChannel = new InputChannel();
        }
        mForceDecorViewVisibility = (mWindowAttributes.privateFlags
                & PRIVATE_FLAG_FORCE_DECOR_VIEW_VISIBILITY) != 0;
        try {
            mOrigWindowType = mWindowAttributes.type;
            mAttachInfo.mRecomputeGlobalAttributes = true;
            collectViewAttributes();
            res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
                    getHostVisibility(), mDisplay.getDisplayId(), mWinFrame,
                    mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
                    mAttachInfo.mOutsets, mAttachInfo.mDisplayCutout, mInputChannel);
        } catch (RemoteException e) {
           ...
        } finally {
            if (restore) {
                attrs.restore();
            }
        }
        ...
    }
    
}

这里只展现出部分关键代码。requestLayout方法是用来发起绘制的，最终会调用到performTraversals方法，这个方法涉及代码800多行，主要执行了三个方法，分别是performMeasure()、performLayout()、performDraw()方法，分别对应测量、布局以及绘制三个动作。绘制就是将UI数据写到surface中，最终显示到屏幕上。

addToDisplay

虽然requestLayout方法在前面，但由于通过消息的方法来执行performTraversals方法，所以最终执行却是在addToDisplay后面的。在看addToDisplay的实现之前，我们得先清楚mWindowSession是什么类：

//frameworks/base/core/java/android/view/ViewRootImpl.java
mWindowSession = WindowManagerGlobal.getWindowSession();
public static IWindowSession getWindowSession() {
    synchronized (WindowManagerGlobal.class) {
        if (sWindowSession == null) {
            try {
                InputMethodManager imm = InputMethodManager.getInstance();
                //由WMS打开一个session，并返回
                IWindowManager windowManager = getWindowManagerService();
                sWindowSession = windowManager.openSession(
                        new IWindowSessionCallback.Stub() {
                            @Override
                            public void onAnimatorScaleChanged(float scale) {
                                ValueAnimator.setDurationScale(scale);
                            }
                        },
                        imm.getClient(), imm.getInputContext());
            } catch (RemoteException e) {
                throw e.rethrowFromSystemServer();
            }
        }
        return sWindowSession;
    }
}

mWindowSession最终是由WMS创建并返回，是一个单例，即一个进程只有这么一个mWindowSession对象。APP进程就是通过mWindowSession跟WMS通讯的。具体实现如下：

//frameworks/base/services/core/java/com/android/server/wm/WindowManagerService.java
public IWindowSession openSession(IWindowSessionCallback callback, IInputMethodClient client,
        IInputContext inputContext) {
    if (client == null) throw new IllegalArgumentException("null client");
    if (inputContext == null) throw new IllegalArgumentException("null inputContext");
    Session session = new Session(this, callback, client, inputContext);
    return session;
}

知道了mWindowSession的由来后，我们再回到addToDisplay的实现上：

//frameworks/base/services/core/java/com/android/server/wm/Session.java
public int addToDisplay(IWindow window, int seq, WindowManager.LayoutParams attrs,
        int viewVisibility, int displayId, Rect outFrame, Rect outContentInsets,
        Rect outStableInsets, Rect outOutsets,
        DisplayCutout.ParcelableWrapper outDisplayCutout, InputChannel outInputChannel) {
    return mService.addWindow(this, window, seq, attrs, viewVisibility, displayId, outFrame,
            outContentInsets, outStableInsets, outOutsets, outDisplayCutout, outInputChannel);
}

看到没，这里转身就调用了WMS的addWindow方法，session本身不做什么操作。mWindowSession相当WMS的一个代理接口，响应APP进程的请求，具体处理的事情还是要回到WMS中。

//frameworks/base/services/core/java/com/android/server/wm/WindowManagerService.java
public int addWindow(Session session, IWindow client, int seq,
        LayoutParams attrs, int viewVisibility, int displayId, Rect outFrame,
        Rect outContentInsets, Rect outStableInsets, Rect outOutsets,
        DisplayCutout.ParcelableWrapper outDisplayCutout, InputChannel outInputChannel) {
    ...
    synchronized(mWindowMap) {
        if (!mDisplayReady) {
            throw new IllegalStateException("Display has not been initialialized");
        }
        ...
        
        WindowToken token = displayContent.getWindowToken(
                hasParent ? parentWindow.mAttrs.token : attrs.token);
                
        ...
        if (token == null) {
            ...
            token = new WindowToken(this, binder, type, false, displayContent,
                    session.mCanAddInternalSystemWindow, isRoundedCornerOverlay);
        } else if {
            ...
        }
        ...
        final WindowState win = new WindowState(this, session, client, token, parentWindow,
                appOp[0], seq, attrs, viewVisibility, session.mUid,
                session.mCanAddInternalSystemWindow);
                
        ...
        final boolean openInputChannels = (outInputChannel != null
                && (attrs.inputFeatures & INPUT_FEATURE_NO_INPUT_CHANNEL) == 0);
        if  (openInputChannels) {
            win.openInputChannel(outInputChannel);
        }
        ...
        win.attach();
        mWindowMap.put(client.asBinder(), win);
        ...
    
    }

addWindow中做了如下几件事情：

1.通过type和token对Window进行验证和分类，确保其有效性；
2.创建WindowState对象，与Window一一对应；
3.注册inputChanel；
4.调用WindowState的attach方法，创建与surfaceflinger的连接；

WMS中addWindow创建了WindowState用于管理窗口，并注册inputChanel用于触摸事件的传递，这样才能进行交互。接着创建了与surfacefliner的连接，为后面创建真正的surface做准备。这里先用一个图大概描述下我们上文的内容：

在这里插入图片描述

APP进程通过IwindowSession完成窗口的添加，而WMS则通过IWindow向应用进程上报输入事件，比如触摸。IWindow是在添加窗口时，addToDisplay方法中传入的第一个参数。

surface

窗口添加后，则需要进行绘制，上文说过，绘制的动作放在performTraversals方法中。我们再来看看该方法的实现（涉及测量和布局的先不看，只看绘制相关）：

private void performTraversals() {

    final View host = mView;
    ...
    //该方法中，真正获取了可以用来绘制的surface
    relayoutResult = relayoutWindow(params, viewVisibility, insetsPending);
    ...
    //开始绘制
    performDraw();
}

relayoutWindow方法得到一块真正的surface，为什么这么说呢？还记得在将view添加窗口的过程中所创建的ViewRootImpl对象么？在创建该对象时，也会去new 一个surface对象：

public final Surface mSurface = new Surface();

但该surface是空的，当调用了relayoutWindow方法后才被填充。才能让应用层在上面进行绘制。我们看看relyoutWindow的实现：

//frameworks/base/core/java/android/view/ViewRootImpl.java
private int relayoutWindow(WindowManager.LayoutParams params, int viewVisibility,
        boolean insetsPending) throws RemoteException {
    ...
    int relayoutResult = mWindowSession.relayout(mWindow, mSeq, params,
            (int) (mView.getMeasuredWidth() * appScale + 0.5f),
            (int) (mView.getMeasuredHeight() * appScale + 0.5f), viewVisibility,
            insetsPending ? WindowManagerGlobal.RELAYOUT_INSETS_PENDING : 0, frameNumber,
            mWinFrame, mPendingOverscanInsets, mPendingContentInsets, mPendingVisibleInsets,
            mPendingStableInsets, mPendingOutsets, mPendingBackDropFrame, mPendingDisplayCutout,
            mPendingMergedConfiguration, mSurface);
    ...
}

通过IWindowSession调用到了relayout方法，注意这里传入的mSurface参数，其实就是个空壳。既然是空壳，又有什么用？如果去看通过AIDL工具生成的Java文件，会发现这个参数这里会有一个out属性，表明该参数是输出参数，在接下来的方法中，就会往这个出参拷贝真正的surface。继续跟踪，Session是IWindowSession的服务端实现，在Session的relayout方法中最终调用到了WMS的relayoutWindow：

//frameworks/base/services/core/java/com/android/server/wm/WindowManagerService.java
public int relayoutWindow(Session session, IWindow client, int seq, LayoutParams attrs,
        int requestedWidth, int requestedHeight, int viewVisibility, int flags,
        long frameNumber, Rect outFrame, Rect outOverscanInsets, Rect outContentInsets,
        Rect outVisibleInsets, Rect outStableInsets, Rect outOutsets, Rect outBackdropFrame,
        DisplayCutout.ParcelableWrapper outCutout, MergedConfiguration mergedConfiguration,
        Surface outSurface) {
    ...
    try {
        result = createSurfaceControl(outSurface, result, win, winAnimator);
    } catch (Exception e) {
        mInputMonitor.updateInputWindowsLw(true /*force*/);

        Slog.w(TAG_WM, "Exception thrown when creating surface for client "
                 + client + " (" + win.mAttrs.getTitle() + ")",
                 e);
        Binder.restoreCallingIdentity(origId);
        return 0;
    }
    ...
}

createSurfaceControl方法会创建一块surface，并填充到outSurface中。后续view的绘制就会在这块surface上进行。

draw

surface有了，接下来就是绘制了。在performDraw方法中开始绘制：

private void performDraw() {
  
    ...
    try {
        boolean canUseAsync = draw(fullRedrawNeeded);
        if (usingAsyncReport && !canUseAsync) {
            mAttachInfo.mThreadedRenderer.setFrameCompleteCallback(null);
            usingAsyncReport = false;
        }
    } finally {
        mIsDrawing = false;
        Trace.traceEnd(Trace.TRACE_TAG_VIEW);
    }
    ...
  
}


private boolean draw(boolean fullRedrawNeeded) {

    ...
    if (!drawSoftware(surface, mAttachInfo, xOffset, yOffset,
                    scalingRequired, dirty, surfaceInsets)) {
        return false;
    }
    ...
}

private boolean drawSoftware(Surface surface, AttachInfo attachInfo, int xoff, int yoff,
        boolean scalingRequired, Rect dirty, Rect surfaceInsets) {

    ...
    canvas = mSurface.lockCanvas(dirty);
    ...
    mView.draw(canvas);
    ...
    surface.unlockCanvasAndPost(canvas); //此surface其实也是mSurface

}

从performDraw方法最终会调用到drawSoftware方法，接着通过Surface类的lockCanvas方法获取到Canvas对象，view的绘制就在此画布上进行的。这里的mView其实就是我们之前所说的DecorView，在它的draw方法中，会调用onDraw方法绘制自己，接着调用dispatchDraw方法绘制子view，如此递归，直至把窗口中所有的view绘制完毕。绘制完毕后，就会调用Surface类的unlockCanvasAndPost方法把所绘制的view post到窗口解析显示。用户就能看到view了。

结语

view的显示流程大概就是这些了。功力不够，有些流程都是一笔带过，并没有深入。很想深入去了解，恨不得把整个Android源码解剖。但发现这样一来就很容易【找不到头】，导致一直在代码细节中徘徊。

先一步一步来，理清流程。找到了大概的脉络，再深入去了解一些模块。

代码流程的梳理确实是有用的，至少在处理问题时，会有思路，不至于一脸懵逼。

这件事会坚持去做。

微信公众号

我在微信公众号也有写文章，更新比较及时，有兴趣者可以扫描如下二维码，或者微信搜索【Android系统实战开发】，关注有惊喜哦！

在这里插入图片描述

迷你球
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
android监听View加载完成的示例讲解
08-27
今天小编就为大家分享一篇android监听View加载完成的示例讲解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Windows 程序启动在指定屏幕
hello_1995的博客
01-04 3715
Windows 多屏情况下，EnumDisplayMonitors() 枚举所有显示器，通过 GetMonitorInfo() 可以取得指定显示器的相关信息，如物理显示区大小等。MonitorInfo 结构中保存着相应显示器的相关信息，如坐标、是否为主显示器等。该结构体中有个 dwFlags 变量表示该显示器是否为主显示器，当值为 MONITORINFOF_PRIMARY 时就说明是主显示器，根据这个值就可以区分主显示器和副显示器。......
Android动态创建View
源于未知
09-07 2954
代码 View view = new View(context); LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, Util.dpToPx(5));//宽度、高度 view.setLayoutP
认识Android中的ViewRootImpl和DecorView
qq_37837621的博客
10-16 620
PS：本文系转载文章，阅读原文可读性会更好些，原文链接： https://mp.weixin.qq.com/s/EGFHW7URuIv0HqwZWt09sg ps：源码是基于 android api 27 来分析的 ViewRootImpl 是用来测量、布局和绘制 View 用的，View 的测量、布局和绘制是从 Activity 的 makeVisible方法开始的，但是本篇文章重点不是具体讲这个（View 的测量、布局和绘制代码细节），而是讲对 ViewRootImpl和DecorView 认知。 1、
Android学习之旅(4)----自定义View
孔晨瑞的博客
12-03 151
自定义View 文章目录自定义View示例程序:简单的涂鸦小程序MainActivity.javaCustonView.javalinearlayout_layout.xmlarrays.xml 当Android提供的View不能满足我们的开发需求时，我们可以通过继承View来实现自定义组件。一般情况下可以重写以下方法： 构造函数 需要通过构造函数告诉编译器，组件依赖在那个父窗体上。 onFin...
Android之创建新的View
人生百年几今日，今日不为真可惜。
12-06 5784
创建新的View方法与希望达到的目标有关： 1、如果现有的控件已经可以满足希望实现的基本功能，只需要对现在的控件外观或动作进行修改或扩展即可。通过重写事件处理程序和onDraw方法。但是仍然需要回调超类的方法，可以对控件进行控制，而不必重新实现它的功能。如可以定制一个TextView来显示10进制小数的集合。 2、可以通过组合多个控件来创建不可分割的、可重用的Widget,从而使它可以综合使用
android 异步显示View
07-26
NULL 博文链接：https://hulefei29.iteye.com/blog/625597
Android自定义View 雷达扫描效果
01-25
可以根据自己的需求配置View的主题颜色、扫描颜色、扫描速度、圆圈数量、是否显示水滴等。 效果图： 这个View的代码只有一个类，非常的简单。没有提供直接引用的链接，需要使用的朋友可以自行下载源码放到自己的...
android自制虚线view
07-31
android中使用shape做虚线，在xml预览中可以显示，但是在模拟器或真机上就变成了实线，于是自己写了一个虚线view，觉得很好用，分享出来
android demo,自定义view，该view显示正在加载的文字，动态转圈的图标
01-23
android demo,自定义view，该view显示正在加载的文字，动态转圈的图标
基于 Android Q 10.0 系统 makeVisible源码解析
梁超杰
06-08 715
这篇文章需要搭配这篇博客看更有味道基于 Android Q 10.0 系统 Activity启动流程探索，读了本篇你可以明白为什么onCreate方法中的view宽高是0. 文章目录1 ResumeActivityItem.java2 ActivityThread.java3 Activity.java3.1 Activity.java3.2 Window.java4 WindowManagerImpl.java5 WindowManagerGlobal.java6 ViewRootImpl.java .
android R版本应用程序窗口流程源码分析
Talk is cheap, show me the code.
01-12 3331
应用启动时，Activity组件在启动之后，在执行完onResume生命周期之后会执行添加窗口到系统、计算窗口大小和位置、应用执行measure-layout-draw、系统窗口状态刷新这几个动作。 1、 addWindow阶段 Activity的启动本质实际最终也是使用WindowManager去addView(add一个DecorView对象)进而使得wms调用addWindow增加一个WindowState对象，而Activity的addView动作发生在Act......
android new view参数,Android ViewModel附加参数
weixin_39736934的博客
05-27 484
有没有办法将其他parameter passing给我的自定义AndroidViewModel构造函数，除了Application上下文。 例：public class MyViewModel extends AndroidViewModel { private final LiveData myObjectList; private AppDatabase appDatabase; public...
在Delphi中开发使用多显示器的应用程序
于剑秋的部落格
05-19 2616
Windows可以将多个显示器映射为虚拟桌面，使我们可以利用这一点设计出方便工作的应用程序。例如PowerPoint就充分发挥了双显示器的优势（大多数的笔记本电脑都支持），它可以在一个显示器上播放幻灯片，而在另一个显示器上显示备注，可以控制播放的进程，使使用者做商务演说的时候非常等心应手。那么我们怎么开发这种应用程序呢？这篇文章将向你展示如果用Delphi实现使用多显示器的应用程序。 Wi
深入理解Android之自定义View
Fighting_初心的博客
01-24 5778
自定义View、多线程、网络，被认为是Android开发者必须牢固掌握的最基础的三大基本功。而自定义View又是Android开发中特别重要的一环，很多地方都需要用到自定义View。这篇文章我就梳理一下自定义View的相关知识。 目录 （一）什么是自定义View （二）自定义组合View （三）自定义View的绘制 1. Canvas.drawXXX() Pa...
Android Framework window & display (1)-显示
老皮的博客
06-06 912
最近接到一个小需求，实现录像，截屏，分享指定的屏幕而不是主屏，因为安卓原生的实现逻辑全是拿的主屏的数据所以对framework的流程进行了分析，以便实现需求。window对应用层来说来，是view跟display解耦，对framework来说，是用来display跟layer（即surfaceflinger）解耦，简单的理解：display ->layer/view
android view开发
最新发布
12-30
Android View是Android开发中的一个重要部分，它是用户界面中的基本构建块。在Android开发中，我们可以通过View来创建各种 UI 控件，比如按钮、文本框、图片等，通过构建不同的View组合来构建完整的用户界面。 在进行Android View的开发时，我们需要先了解View的基本属性和方法，比如布局参数、颜色、大小等。然后可以通过XML或者Java代码来创建和配置View，让它们显示在用户界面上。此外，我们也可以通过自定义View来实现特定的功能或者样式，比如自定义布局、自定义绘制等。 在开发Android View时，我们也需要考虑到用户交互和UI的动态变化。比如用户点击按钮时的响应、界面的更新等。为了更好地实现用户交互，我们可以通过监听器和动画来实现。 当然，为了提高开发效率和代码的复用性，我们也可以使用各种开源的第三方库和框架，比如ButterKnife、Dagger、RxJava等，来简化View的开发和管理。 总的来说，Android View的开发是Android开发中非常重要的一部分，通过不断学习和实践，我们可以不断提升自己的View开发技能，为用户提供更好的用户体验。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值