从源码角度看各种context

最新推荐文章于 2024-02-16 09:23:40 发布
最新推荐文章于 2024-02-16 09:23:40 发布
阅读量277 收藏
点赞数
分类专栏： Android 文章标签： Android 源码分析

该博客仅因手机阅读不方便而创建，感兴趣同学可以微信搜索小专栏平台，订阅从源码角度看Android，支持作者原创

简介：

做应用开发的对Context的熟悉度应该是仅次于Activity和Service的。Context,英文名上下文场景，代表着对当前运行场景下的各种信息的一种封装。例如，需要调用四大组件进行工作都要调用到Context，同时，通过Context也可以获取到Resource, Display, Theme, AssetManager, WallPaperManager这些资源对象。因为Context的使用方法实在太普及，实在可以说的上是安卓的第一课，这篇就不给实例了。

 

Context创建方法

 

想要知道都有哪几种不同的Context，从ContextImpl代码中寻找是最好的办法，以下列举了各种不同的Context创建接口及其调用场景：

接口调用场景
createActivityContextstartActivity时和新创建的Activity绑定
createAppContext

startService和bindApplication时和新创建的service和application绑定

createApplicationContext远程widget和notification时会用到
createConfigurationContext用来获取或设置Resources, Theme等资源
createPackageContextinstallProvider时和新创建的ContentProvider绑定
createSystemContextsystem_server启动时被初始化，传入PackageManagerService中
createDisplayContext不常用

上面的表格已经概括出各种类别的Context, 但是我准备按照四大组件的角度去看看不同组件的Context是如何被初始化的以及区别是什么。

 

类图

Activity继承自ContextThemeWrapper; Service、Application继承自ContextWrapper。ContextWrapper的操作是聚合了Context的实例来实现的。真正的功能是在ContextImpl中进行实现。BroadcastReceiver与ContentProvider有些特殊，其实BroadcastReceiver是在调用onReceive方法时传入了Context对象，而ContentProvider聚合了Context对象并没有直接继承ContextWrapper。

 

Activity

 

Activity是最常用也是在四大组件中最复杂的一个

ActivityThread.java

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
…
    // 通过反射创建一个Activity实例
     Activity activity = null;
    try {
        java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
        activity = mInstrumentation.newActivity(
                cl, component.getClassName(), r.intent);
        StrictMode.incrementExpectedActivityCount(activity.getClass());
        r.intent.setExtrasClassLoader(cl);
        r.intent.prepareToEnterProcess();
        if (r.state != null) {
            r.state.setClassLoader(cl);
        }
    } catch (Exception e) {
        …
    }

    try {
        // 获取Aapplication实例
        Application app = r.packageInfo.makeApplication(false, mInstrumentation);

        if (activity != null) {
            // 创建一个ContextImpl实例
            Context appContext = createBaseContextForActivity(r, activity);
            CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
            Configuration config = new Configuration(mCompatConfiguration);

            // 将Activity, Application, ContextImpl三者绑定
            activity.attach(appContext, this, getInstrumentation(), r.token,
                    r.ident, app, r.intent, r.activityInfo, title, r.parent,
                    r.embeddedID, r.lastNonConfigurationInstances, config,
                    r.referrer, r.voiceInteractor);
         }
    }
…

    private Context createBaseContextForActivity(ActivityClientRecord r, final Activity activity) {
        …

        ContextImpl appContext = ContextImpl.createActivityContext(
                this, r.packageInfo, displayId, r.overrideConfig);
        appContext.setOuterContext(activity);
        Context baseContext = appContext;

        …
        return baseContext;
    }
}
ContextImpl.java

static ContextImpl createActivityContext(ActivityThread mainThread,
        LoadedApk packageInfo, int displayId, Configuration overrideConfiguration) {
    if (packageInfo == null) throw new IllegalArgumentException(“packageInfo”);
    return new ContextImpl(null, mainThread, packageInfo, null, null, false,
            null, overrideConfiguration, displayId);
}
Application

ActivityThread.java

ContextImpl instrContext = ContextImpl.createAppContext(this, pi);

try {
    java.lang.ClassLoader cl = instrContext.getClassLoader();
    mInstrumentation = (Instrumentation)
        cl.loadClass(data.instrumentationName.getClassName()).newInstance();
} catch (Exception e) {
    throw new RuntimeException(
        “Unable to instantiate instrumentation “
        + data.instrumentationName + “: “ + e.toString(), e);
}

// 初始化instrumentation，绑定Context
mInstrumentation.init(this, instrContext, appContext,
       new ComponentName(ii.packageName, ii.name), data.instrumentationWatcher,
       data.instrumentationUiAutomationConnection);

…

Application app = data.info.makeApplication(data.restrictedBackupMode, null);
mInitialApplication = app;

…

try {
    mInstrumentation.onCreate(data.instrumentationArgs);
} catch (Exception e) {
    throw new RuntimeException(
        “Exception thrown in onCreate() of “
        + data.instrumentationName + “: “ + e.toString(), e);
}

try {
    // 创建Application并调用onCreate方法
    mInstrumentation.callApplicationOnCreate(app);
} catch (Exception e) {
    if (!mInstrumentation.onException(app, e)) {
        throw new RuntimeException(
            “Unable to create application “ + app.getClass().getName()
            + “: “ + e.toString(), e);
    }
}
ContextImpl.java

static ContextImpl createAppContext(ActivityThread mainThread, LoadedApk packageInfo) {
    if (packageInfo == null) throw new IllegalArgumentException(“packageInfo”);
    return new ContextImpl(null, mainThread,
            packageInfo, null, null, false, null, null, Display.INVALID_DISPLAY);
}
Service

ActivityThread.java

private void handleCreateService(CreateServiceData data) {
…
    // 通过反射创建Service
    LoadedApk packageInfo = getPackageInfoNoCheck(
            data.info.applicationInfo, data.compatInfo);
    Service service = null;
    try {
        java.lang.ClassLoader cl = packageInfo.getClassLoader();
        service = (Service) cl.loadClass(data.info.name).newInstance();
    } catch (Exception e) {
        if (!mInstrumentation.onException(service, e)) {
            throw new RuntimeException(
                “Unable to instantiate service “ + data.info.name
                + “: “ + e.toString(), e);
        }
    }

    try {
        if (localLOGV) Slog.v(TAG, “Creating service “ + data.info.name);

        ContextImpl context = ContextImpl.createAppContext(this, packageInfo);
        context.setOuterContext(service);

        // 得到Application实例，如果没有被实例化过则会创建一个
        Application app = packageInfo.makeApplication(false, mInstrumentation);
        // 将Context, Application与Service绑定
        service.attach(context, this, data.info.name, data.token, app,
                ActivityManagerNative.getDefault());
        service.onCreate();
        mServices.put(data.token, service);
        try {
            ActivityManagerNative.getDefault().serviceDoneExecuting(
                    data.token, SERVICE_DONE_EXECUTING_ANON, 0, 0);
        } catch (RemoteException e) {
            // nothing to do.
        }
    } catch (Exception e) {
…
    }
}
BroadcastReceiver

static final class ReceiverDispatcher {

    final BroadcastReceiver mReceiver;

    ReceiverDispatcher(BroadcastReceiver receiver, Context context,
            Handler activityThread, Instrumentation instrumentation,
            boolean registered) {
…
        mReceiver = receiver;
…
    }

    final class Args extends BroadcastReceiver.PendingResult implements Runnable {
…

        public void run() {
            final BroadcastReceiver receiver = mReceiver;
    …
            try {
                // 通过反射调用BroadcastReceiver的onReceive并传入Context对象
                ClassLoader cl =  mReceiver.getClass().getClassLoader();
                intent.setExtrasClassLoader(cl);
                setExtrasClassLoader(cl);
                receiver.setPendingResult(this);
                receiver.onReceive(mContext, intent);
            } catch (Exception e) {

    …
            }

    …
        }
    }
}
ContextImpl.java

private ContextImpl(ContextImpl container, ActivityThread mainThread,
        LoadedApk packageInfo, IBinder activityToken, UserHandle user, boolean restricted,
        Display display, Configuration overrideConfiguration, int createDisplayWithId) {
    mOuterContext = this;
    …
}

public void sendOrderedBroadcastAsUser(Intent intent, UserHandle user,
        String receiverPermission, int appOp, Bundle options, BroadcastReceiver resultReceiver,
        Handler scheduler, int initialCode, String initialData, Bundle initialExtras) {
    IIntentReceiver rd = null;
    if (resultReceiver != null) {
        if (mPackageInfo != null) {
            …
        } else {
            …

            // 初始化ReceiverDispatcher, 通过getOuterContext获取Context实例
            rd = new LoadedApk.ReceiverDispatcher(resultReceiver, getOuterContext(),
                    scheduler, null, false).getIIntentReceiver();
        }
    }
…
}

final Context getOuterContext() {
    return mOuterContext;
}

由代码可知，ReceiverDispatcher的初始化在它的构造器阶段完成，而如果没有调用过setOuterContext, getOutContext返回的是这个ContextImpl实例本身。由此可以判断，BroadcastReceiver的Context是根据调用者的Context来决定的。

ContentProvider

ActivityThread.java

private IActivityManager.ContentProviderHolder installProvider(Context context,
        IActivityManager.ContentProviderHolder holder, ProviderInfo info,
        boolean noisy, boolean noReleaseNeeded, boolean stable) {
    ContentProvider localProvider = null;
    IContentProvider provider;
    if (holder == null || holder.provider == null) {
        if (DEBUG_PROVIDER || noisy) {
            Slog.d(TAG, “Loading provider “ + info.authority + “: “
                    + info.name);
        }
        Context c = null;
        ApplicationInfo ai = info.applicationInfo;
        // 如果传进来的Context和ContentProvider所在进程一致，则不再需要重新创建
        if (context.getPackageName().equals(ai.packageName)) {
            c = context;
        } else if (mInitialApplication != null &&
                mInitialApplication.getPackageName().equals(ai.packageName)) {
            c = mInitialApplication;
        } else {
            try {
                // 创建一个ContextImpl实例
                c = context.createPackageContext(ai.packageName,
                        Context.CONTEXT_INCLUDE_CODE);
            } catch (PackageManager.NameNotFoundException e) {
                // Ignore
            }
        }
        if (c == null) {
            return null;
        }
        try {
            // 反射创建ContentProvider
            final java.lang.ClassLoader cl = c.getClassLoader();
            localProvider = (ContentProvider)cl.
                loadClass(info.name).newInstance();
            provider = localProvider.getIContentProvider();
…
              // Context与ContentProvider绑定
            localProvider.attachInfo(c, info);
        } catch (java.lang.Exception e) {
            return null;
        }
    } 
…
}
几点区别

Activity, Application/Service ContextImpl 成员变量

|Type|Activity|Application/Service|ContentProvider|
|—|—|—|—|—|
|ContextImpl|||√|
|ActivityThread|√|√|√|
|LoadedApk|√|√|√|
|IBinder|||√|
|UserHandle|||√|
|boolean(restricted)|false|false|√|
|Display|||√|
|Configuration|√|||
|int(createDisplayWithId)|√|||

 

一般我们开发期间实际到的Context一般就两类，一类是Application/Service的Context，另一类是Activity的Context

 

两种Context常用功能的区别

 

两种Context的区别主要在于能否显示dialog，因为要进行ui上的操作需要有显示dialog的window，所以application context不能实现。

 

如果尝试去使用getApplicationContext去显示dialog会报出以下错误：

 

Attempted to add window with non-application token WindowToken{4067a268 token=null}.  Aborting.

D/AndroidRuntime( 1923): Shutting down VM

W/dalvikvm( 1923): threadid=1: thread exiting with uncaught exception (group=0x40015560)

E/AndroidRuntime( 1923): FATAL EXCEPTION: main

E/AndroidRuntime( 1923): java.lang.RuntimeException: Unable to create application 

com.test.shrenik.ControlApplication: android.view.WindowManager$BadTokenException: 

Unable to add window — token null is not for an application

深入代码层去解析：


Dialog.java

Dialog(@NonNull Context context, @StyleRes int themeResId, boolean createContextThemeWrapper) {
…
    final Window w = new PhoneWindow(mContext);
    mWindow = w;
…
}

public void show() {
    // 获取window的params
    WindowManager.LayoutParams l = mWindow.getAttributes();
    if ((l.softInputMode
            & WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) == 0) {
        WindowManager.LayoutParams nl = new WindowManager.LayoutParams();
        // copyFrom
        nl.copyFrom(l);
        nl.softInputMode |=
                WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION;
        l = nl;
    }

    try {
        // 加入到mDecorView中
        mWindowManager.addView(mDecor, l);
        mShowing = true;

        sendShowMessage();
    } finally {
    }
}
WindowManager.java

public final int copyFrom(LayoutParams o) {
    if (token == null) {
        // NOTE: token only copied if the recipient doesn’t
        // already have one.
        token = o.token;
    }
}
WindowManagerImpl.java

@Override
public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
    applyDefaultToken(params);
    mGlobal.addView(view, params, mDisplay, mParentWindow);
}
WindowManagerGlobal.java

public void addView(View view, ViewGroup.LayoutParams params,
        Display display, Window parentWindow) {
…
    final WindowManager.LayoutParams wparams = (WindowManager.LayoutParams) params;
    if (parentWindow != null) {
        parentWindow.adjustLayoutParamsForSubWindow(wparams);
    } else {
        final Context context = view.getContext();
        if (context != null
                && (context.getApplicationInfo().flags
                        & ApplicationInfo.FLAG_HARDWARE_ACCELERATED) != 0) {
            wparams.flags |= WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED;
        }
    }

    ViewRootImpl root;
    View panelParentView = null;

…
    try {
        root.setView(view, wparams, panelParentView);
    } catch (RuntimeException e) {
        // BadTokenException or InvalidDisplayException, clean up.
        synchronized (mLock) {
            final int index = findViewLocked(view, false);
            if (index >= 0) {
                removeViewLocked(index, true);
            }
        }
        throw e;
    }
}
    public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
        synchronized (this) {
             int res; /* = WindowManagerImpl.ADD_OKAY; */
…
            try {
…
                   // 将LayoutParams加入到window session中
                res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,
                        getHostVisibility(), mDisplay.getDisplayId(),
                        mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,
                        mAttachInfo.mOutsets, mInputChannel);
            } catch (RemoteException e) {
…
            } finally {
                if (restore) {
                    attrs.restore();
                }
            }

            if (res < WindowManagerGlobal.ADD_OKAY) {
…
                switch (res) {
…
                        throw new WindowManager.BadTokenException(
                                “Unable to add window — token “ + attrs.token
                                + “ is not for an application”);
…
                }
            }
        }
Session.java

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

    public int addWindow(Session session, IWindow client, int seq,
            WindowManager.LayoutParams attrs, int viewVisibility, int displayId,
            Rect outContentInsets, Rect outStableInsets, Rect outOutsets,
            InputChannel outInputChannel) {
            WindowToken token = mTokenMap.get(attrs.token);
            if (token == null) {
                if (type >= FIRST_APPLICATION_WINDOW && type <= LAST_APPLICATION_WINDOW) {
                    Slog.w(TAG, “Attempted to add application window with unknown token “
                          + attrs.token + “.  Aborting.”);
                    return WindowManagerGlobal.ADD_BAD_APP_TOKEN;
                }
            }
            …
            token = new WindowToken(this, attrs.token, -1, false);
            addToken = true;

            if (addToken) {
                mTokenMap.put(attrs.token, token);
            }
     }
}

 

 

柠檬橙子柚
关注
专栏目录
从C++软件调试实战的角度去看多线程编程中的若干细节问题
dvlinker的技术专栏
11-12 1万+
本文从C++软件调试实战的角度去讲述多线程编程中的若干细节问题，并给出了具体的问题分析实例。
Context源码，再度重相逢
qq_42766267的博客
11-02 181
各位读者朋友们大家好，我是随波逐流的薯条。深秋了，前几天气温骤降，北京的人和狗都不愿意出门，趴在窝里冻的打寒颤。我的书房里没装空调，暖气要十一月中旬才来，每次想学习都得下很大的决心，所以这篇文章发出来时比预期又晚了几天~ 最近我的心也是冰冰的，我目前做在线数据开发，如果大家干过这活肯定知道，数据开发最重要的是数据口径，开发前一定得对清楚... 本人作为在这上面踩了很多坑的人这几天接需求时又掉进去了，一个需求在已经上线的情况下，不同来源的数据做diff总是对不上，一查就是口径不对，来来回回改了根据口径改了一
Context：源码解读
qq_36059306的博客
06-30 259
Context 针对场景 传递上下文 控制子goroutine的执行 超时控制的方法调用 可以取消的方法调用 基本用法 type Context interface { Deadline() (deadline time.Time, ok bool) Done() <-chan struct{} Err() error Value(key interface{}) interface{} } Deadline：返回Context被取消的截止日期，如果没有截止日期那么ok返回false Do
从源码角度看Handler原理
FlowLeaf
09-17 1157
在Android中，有一个规定就是除了主线程，其他线程不能操作UI视图，因为不这样做的话会出现线程不安全问题。但还有一个规定UI线程在执行一个操作如果5秒内没有响应就会包ANR错误。所以UI线程中不允许访问网络这样的耗时操作，那么问题来了，子线程执行耗时操作，比如从网络获取图片，但子线程不能更新UI，而主线程能更新UI，但不能去下载图片。这样handler消息处理机制就出现了。 1. Handler
Context源码分析
weixin_30322405的博客
06-13 103
Context源码分析 我们做安卓开发，时时都在和Context打交道，那么Context到底是什么？有什么作用？如何与Application，Activity，Service等实例发生联系的？等等 Context是什么？ Context的字面意思是“上下文”，那么...
Go语言Context（设计及分析）
weixin_30693683的博客
10-26 192
context简单概述:Go服务器的每个请求都有自己的goroutine,而有的请求为了提高性能，会经常启动额外的goroutine处理请求,当该请求被取消或超时，该请求上的所有goroutines应该退出，防止资源泄露。那么context来了，它对该请求上的所有goroutines进行约束，然后进行取消信号，超时等操作。而context优点就是简洁的管理goroutines的生命周期。conte...
context源码学习
leekerian的博客
09-12 791
context源码学习
Android图片加载框架最新解析：从源码的角度理解Glide的执行流程
01-20
本文将从源码角度解析Glide的执行流程，帮助开发者深入理解其内部工作原理。首先，我们需要获取Glide的源码，可以通过在Android Studio中直接查看已引入项目的Glide库，或者从GitHub...
从源码角度解析Android中APK安装过程
张许平的博客
11-28 2750
从源码角度解析Android中APK的安装过程 1. Android中APK简介 Android应用Apk的安装有如下四种方式： 1.1 系统应用安装 没有安装界面，在开机时自动完成 1.2 网络下载应用安装 没有安装界面，在应用市场完成 1.3 ADB命令安装 没有安装界面，通过命令直接安装 1.4 外部设备安装 有安装界面，通过SD卡等外部设备安装，由packageInstaller处理...
从源码角度看 Spark 任务提交流程（上）
an_vana的博客
11-27 203
前言  最近阅读一下 Spark 的部分源码，在这一过程中通过源码结合之前所了解的相关内容，能够对之前知识进行完整的梳理也能更一进步了解 Spark 运行的底层逻辑，由于阅读源码是一个较为艰深的过程遂将其记录下来方便日后回顾，本篇我们来讲一下我们的 Spark on Yarn 在提交一个任务后俩个框架为我们做了些什么。 Spark 向 Yarn 提交任务的流程  在 Linux 上安装完 Spark 后都会用一个官方提供的 example 来测一测我们的 Spark 安装成功了，比如下面这段命令: bin/
context 源码解析
星星点灯的博客
12-09 335
package context import ( "errors" "internal/reflectlite" "sync" "sync/atomic" "time" ) //每个context 都要实现的接口 type Context interface { Deadline() (deadline time.Time, ok bool) Done() <-chan struct{} Err() error Value(key interface{}) interface{.
Android中Context源码分析（一）
Flying snow
08-24 1808
Context源码解析
深入 GO Context「源码分析+详细案例」
最新发布
pengyachuan的博客
02-16 1841
为什么会写 Context 呢？我在网上搜了一圈非常多文章在写，但没有讲具体的案例。我把这些年使用的场景和技巧总结下来，结合源码分析+项目实践学习会更高效。
Android Context 源码的理解
programming_path的博客
11-03 1231
Context 是什么 类的剖析 Context ContextImpl ContextWrapper ContextThemeWrapper Context 创建的时机 Application 的创建 Activity 的启动 Service Context 的数量 不同 Context 的分析 Application 中的 Context Activity 中的Context Serv
Go语言之 Context 实战与源码分析
dz45693的专栏
11-27 2600
本文主要简单介绍了Go语言(golang)中的context包。给出了context 的基本用法和使用建议，并从源码层面对其底层结构和具体实现原理进行分析。 1. 概述 以下分析基于 Go 1.17.1 1.1 什么是 Context 上下文 context.Context在Go 语言中用来设置截止日期、同步信号，传递请求相关值的结构体。上下文与 Goroutine 有比较密切的关系，是 Go 语言中独特的设计，在其他编程语言中我们很少见到类似的概念。 主要用于超时控制和多Goroutine间
Spark源码分析-1.集群架构介绍和SparkContext源码分析
Bloddy的博客
02-09 370
Spark源码分析-1.集群架构介绍和SparkContext源码分析 在分析Spark源码之前，有必要把Spark的集群架构和SparkContext复习下，有助于后面对源码的理解。 Spark集群架构 本文的集群架构是建立在Standalone模式的，Yarn和Mesos类似 Spark架构： 名词解释： Client：客户端进程，负责提交作业到Master。Client进...
通过createPackageContext 实现皮肤打包成apk的demo
zhanhao2027的博客
09-14 173
 通过Context     friendContext = this.createPackageContext(skinList.get(i).packageName,                            Context.CONTEXT_IGNORE_SECURITY);将皮肤打包成apk文件 具体内容看代码，有注释！ 先得安装skin1和skin2再安装MainAppli...
利用createPackageContext()方法实现囊中探物
热门推荐
darlk的专栏
07-13 1万+
Context有个createPackageContext方法，可以创建另外一个包的上下文，这个实例不同于它本身的Context实例，但是功能是一样的。       这个方法有两个参数： 1.packageName  包名，要得到Context的包名 2.flags  标志位，有CONTEXT_INCLUDE_CODE和CONTEXT_IGNORE_SECURITY两个选项。
从应用角度看Android源码 - 是谁调用的ActivityThread的main方法
小北的博客
08-08 3325
这次研究一下ActivityThread这个类的main方法是谁调用的，先看一下main方法里都实现了那些东西。顺便提一句ActivityThread的存在是为了管理应用所在进程的主线程的，也就是UI线程的管理者。他的main方法是应用程序的入口，没有这个方法，应用是无法创建的。 public static void main(String[] args) {
深入解析Volley源码：理解其工作流程与机制
"AndroidVolley完全解析(四)，带你从源码的角度理解Volley" Volley是Google推出的一个网络请求库，特别适用于Android应用中的快速、高效的数据加载。本篇文章主要聚焦于通过源码分析，深入理解Volley的工作原理。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值