Examples with ShadowLoadedApk._LoadedApk_ org.robolectric.shadows.ShadowLoadedApk._LoadedApk_ used on opensource projects

Example 1 with ShadowLoadedApk._LoadedApk_

use of org.robolectric.shadows.ShadowLoadedApk._LoadedApk_ in project robolectric by robolectric.

the class ShadowActivity method callAttach.

public void callAttach(Intent intent, @Nullable Bundle activityOptions, @Nullable @WithType("android.app.Activity$NonConfigurationInstances") Object lastNonConfigurationInstances) {
    Application application = RuntimeEnvironment.getApplication();
    Context baseContext = application.getBaseContext();
    ComponentName componentName = new ComponentName(application.getPackageName(), realActivity.getClass().getName());
    ActivityInfo activityInfo;
    PackageManager packageManager = application.getPackageManager();
    shadowOf(packageManager).addActivityIfNotPresent(componentName);
    try {
        activityInfo = packageManager.getActivityInfo(componentName, PackageManager.GET_META_DATA);
    } catch (NameNotFoundException e) {
        throw new RuntimeException("Activity is not resolved even if we made sure it exists", e);
    }
    CharSequence activityTitle = activityInfo.loadLabel(baseContext.getPackageManager());
    ActivityThread activityThread = (ActivityThread) RuntimeEnvironment.getActivityThread();
    Instrumentation instrumentation = activityThread.getInstrumentation();
    // on the application, meaning non-static shadow system service state will not be shared.
    if (activityOptions != null && VERSION.SDK_INT >= VERSION_CODES.O) {
        int displayId = ActivityOptions.fromBundle(activityOptions).getLaunchDisplayId();
        if (displayId != Display.DEFAULT_DISPLAY && // INVALID_DISPLAY indicates no display was set in the options bundle
        displayId != Display.INVALID_DISPLAY) {
            LoadedApk loadedApk = activityThread.getPackageInfo(ShadowActivityThread.getApplicationInfo(), null, Context.CONTEXT_INCLUDE_CODE);
            _LoadedApk_ loadedApkReflector = reflector(_LoadedApk_.class, loadedApk);
            loadedApkReflector.setResources(application.getResources());
            loadedApkReflector.setApplication(application);
            baseContext = reflector(_ContextImpl_.class).createActivityContext(activityThread, loadedApk, activityInfo, reflector(_ContextImpl_.class, baseContext).getActivityToken(), displayId, /* overrideConfiguration= */
            application.getResources().getConfiguration());
            reflector(_ContextImpl_.class, baseContext).setOuterContext(realActivity);
        }
    }
    reflector(_Activity_.class, realActivity).callAttach(realActivity, baseContext, activityThread, instrumentation, application, intent, activityInfo, activityTitle, lastNonConfigurationInstances);
    int theme = activityInfo.getThemeResource();
    if (theme != 0) {
        realActivity.setTheme(theme);
    }
}

Example 2 with ShadowLoadedApk._LoadedApk_

use of org.robolectric.shadows.ShadowLoadedApk._LoadedApk_ in project robolectric by robolectric.

the class AndroidTestEnvironment method installAndCreateApplication.

private Application installAndCreateApplication(AndroidManifest appManifest, Config config, android.content.res.Configuration androidConfiguration, DisplayMetrics displayMetrics, ShadowActivityThread shadowActivityThread, _ActivityThread_ activityThreadReflector, Instrumentation androidInstrumentation) {
    ActivityThread activityThread = (ActivityThread) RuntimeEnvironment.getActivityThread();
    Context systemContextImpl = reflector(_ContextImpl_.class).createSystemContext(activityThread);
    RuntimeEnvironment.systemContext = systemContextImpl;
    Application dummyInitialApplication = new Application();
    activityThreadReflector.setInitialApplication(dummyInitialApplication);
    ShadowApplication shadowInitialApplication = Shadow.extract(dummyInitialApplication);
    shadowInitialApplication.callAttach(systemContextImpl);
    Package parsedPackage = loadAppPackage(config, appManifest);
    ApplicationInfo applicationInfo = parsedPackage.applicationInfo;
    ComponentName actualComponentName = new ComponentName(applicationInfo.packageName, androidInstrumentation.getClass().getSimpleName());
    ReflectionHelpers.setField(androidInstrumentation, "mComponent", actualComponentName);
    // unclear why, but prior to P the processName wasn't set
    if (apiLevel < P && applicationInfo.processName == null) {
        applicationInfo.processName = parsedPackage.packageName;
    }
    setUpPackageStorage(applicationInfo, parsedPackage);
    // Bit of a hack... Context.createPackageContext() is called before the application is created.
    // It calls through
    // to ActivityThread for the package which in turn calls the PackageManagerService directly.
    // This works for now
    // but it might be nicer to have ShadowPackageManager implementation move into the service as
    // there is also lots of
    // code in there that can be reusable, e.g: the XxxxIntentResolver code.
    ShadowActivityThread.setApplicationInfo(applicationInfo);
    shadowActivityThread.setCompatConfiguration(androidConfiguration);
    Bootstrap.setUpDisplay();
    activityThread.applyConfigurationToResources(androidConfiguration);
    Application application = createApplication(appManifest, config, applicationInfo);
    RuntimeEnvironment.setConfiguredApplicationClass(application.getClass());
    RuntimeEnvironment.application = application;
    if (application != null) {
        final Class<?> appBindDataClass;
        try {
            appBindDataClass = Class.forName("android.app.ActivityThread$AppBindData");
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
        final Object appBindData = ReflectionHelpers.newInstance(appBindDataClass);
        final _AppBindData_ _appBindData_ = reflector(_AppBindData_.class, appBindData);
        _appBindData_.setProcessName(parsedPackage.packageName);
        _appBindData_.setAppInfo(applicationInfo);
        activityThreadReflector.setBoundApplication(appBindData);
        final LoadedApk loadedApk = activityThread.getPackageInfo(applicationInfo, null, Context.CONTEXT_INCLUDE_CODE);
        final _LoadedApk_ _loadedApk_ = reflector(_LoadedApk_.class, loadedApk);
        Context contextImpl;
        if (apiLevel >= VERSION_CODES.LOLLIPOP) {
            contextImpl = reflector(_ContextImpl_.class).createAppContext(activityThread, loadedApk);
        } else {
            try {
                contextImpl = systemContextImpl.createPackageContext(applicationInfo.packageName, Context.CONTEXT_INCLUDE_CODE);
            } catch (PackageManager.NameNotFoundException e) {
                throw new RuntimeException(e);
            }
        }
        ShadowPackageManager shadowPackageManager = Shadow.extract(contextImpl.getPackageManager());
        shadowPackageManager.addPackageInternal(parsedPackage);
        activityThreadReflector.setInitialApplication(application);
        ShadowApplication shadowApplication = Shadow.extract(application);
        shadowApplication.callAttach(contextImpl);
        reflector(_ContextImpl_.class, contextImpl).setOuterContext(application);
        if (apiLevel >= VERSION_CODES.O) {
            reflector(_ContextImpl_.class, contextImpl).setClassLoader(this.getClass().getClassLoader());
        }
        Resources appResources = application.getResources();
        _loadedApk_.setResources(appResources);
        _loadedApk_.setApplication(application);
        if (RuntimeEnvironment.getApiLevel() >= VERSION_CODES.O) {
            // Preload fonts resources
            FontsContract.setApplicationContextForResources(application);
        }
        registerBroadcastReceivers(application, appManifest);
        appResources.updateConfiguration(androidConfiguration, displayMetrics);
        // propagate any updates to configuration via RuntimeEnvironment.setQualifiers
        Bootstrap.updateConfiguration(appResources);
        if (ShadowAssetManager.useLegacy()) {
            populateAssetPaths(appResources.getAssets(), appManifest);
        }
        PerfStatsCollector.getInstance().measure("application onCreate()", () -> application.onCreate());
    }
    return application;
}