Java AndroidManifest类代码示例

import org.robolectric.AndroidManifest; //导入依赖的package包/类
@Override
protected AndroidManifest getAppManifest(Config config) {

  String appRoot = "../app/src/main/";
  String manifestPath = appRoot + "AndroidManifest.xml";
  String resDir = appRoot + "res";
  String assetsDir = appRoot + "assets";
  AndroidManifest manifest = createAppManifest(Fs.fileFromPath(manifestPath),
                                               Fs.fileFromPath(resDir),
                                               Fs.fileFromPath(assetsDir));

  // If you change the package - don't forget to change the build.gradle and the AndroidManifest.xml
  manifest.setPackageName("com.soagrowers.android");

  // Robolectric is already going to look in the  'app' dir ...
  // so no need to add to package name
  return manifest;
}
 

import org.robolectric.AndroidManifest; //导入依赖的package包/类
@Override
public AndroidManifest getAppManifest(Config config) {
    return new AndroidManifest(
        Fs.fileFromPath(MANIFEST_PROPERTY),
        Fs.fileFromPath(RES_PROPERTY)
    ) {
        @Override
        public int getTargetSdkVersion() {
            return MAX_SDK_SUPPORTED_BY_ROBOLECTRIC;
        }

        @Override
        public String getThemeRef(Class<? extends Activity> activityClass) {
            return "@style/AppTheme"; // Needs to define default theme
        }

    };
}
 

import org.robolectric.AndroidManifest; //导入依赖的package包/类
@Override
protected AndroidManifest getAppManifest(Config config) {
  String path = "src/main";
  if (!new File(path).exists()) {
    path = "app/" + path;
  }
  final String manifestProperty = path + "/AndroidManifest.xml";
  final String resProperty = path + "/res";
  return new AndroidManifest(Fs.fileFromPath(manifestProperty), Fs.fileFromPath(resProperty)) {
    @Override
    public int getTargetSdkVersion() {
      return ROBOLECTRIC_SDK_VERSION;
    }

    @Override
    public String getThemeRef(Class<? extends Activity> activityClass) {
      return ROBOLECTRIC_THEME;
    }
  };
}
 

import org.robolectric.AndroidManifest; //导入依赖的package包/类
@Override
 protected AndroidManifest getAppManifest(Config config) {
   //String appRoot = "D:\\TmpCodingProjects\\TripComputer\\app\\src\\main\\";
   String appRoot = "../app/src/main/";
   String manifestPath = appRoot + "AndroidManifest.xml";
   String resDir = appRoot + "res";
   String assetsDir = appRoot + "assets";
   AndroidManifest manifest = createAppManifest(Fs.fileFromPath(manifestPath),
     Fs.fileFromPath(resDir),
     Fs.fileFromPath(assetsDir));

// If you change the package - don't forget to change the build.gradle and the AndroidManifest.xml
   manifest.setPackageName("com.soagrowers.android");
   // Robolectric is already going to look in the  'app' dir ...
   // so no need to add to package name
   return manifest;
 }
 

import org.robolectric.AndroidManifest; //导入依赖的package包/类
public boolean setThemeFromManifest() {
  ShadowApplication shadowApplication = shadowOf(realActivity.getApplication());
  AndroidManifest appManifest = shadowApplication.getAppManifest();
  if (appManifest == null) return false;

  String themeRef = appManifest.getThemeRef(realActivity.getClass());

  if (themeRef != null) {
    ResName style = ResName.qualifyResName(themeRef.replace("@", ""), appManifest.getPackageName(), "style");
    Integer themeRes = shadowApplication.getResourceLoader().getResourceIndex().getResourceId(style);
    if (themeRes == null)
      throw new Resources.NotFoundException("no such theme " + style.getFullyQualifiedName());
    realActivity.setTheme(themeRes);
    return true;
  }
  return false;
}
 

import org.robolectric.AndroidManifest; //导入依赖的package包/类
@Override public ActivityInfo getActivityInfo(ComponentName className, int flags) throws NameNotFoundException {
  String packageName = className.getPackageName();
  AndroidManifest androidManifest = androidManifests.get(packageName);
  String activityName = className.getClassName();
  ActivityData activityData = androidManifest.getActivityData(activityName);
  ActivityInfo activityInfo = new ActivityInfo();
  activityInfo.packageName = packageName;
  activityInfo.name = activityName;
  if (activityData != null) {
    ResourceIndex resourceIndex = Robolectric.getShadowApplication().getResourceLoader().getResourceIndex();
    String themeRef;

    // Based on ShadowActivity
    if (activityData.getThemeRef() != null) {
      themeRef = activityData.getThemeRef();
    } else {
      themeRef = androidManifest.getThemeRef();
    }
    if (themeRef != null) {
      ResName style = ResName.qualifyResName(themeRef.replace("@", ""), packageName, "style");
      activityInfo.theme = resourceIndex.getResourceId(style);
    }
  }
  activityInfo.applicationInfo = getApplicationInfo(packageName, flags);
  return activityInfo;
}
 

import org.robolectric.AndroidManifest; //导入依赖的package包/类
@Override
public ActivityInfo getReceiverInfo(ComponentName className, int flags) throws NameNotFoundException {
  String packageName = className.getPackageName();
  AndroidManifest androidManifest = androidManifests.get(packageName);
  String classString = className.getClassName();
  int index = classString.indexOf('.');
  if (index == -1) {
    classString = packageName + "." + classString;
  } else if (index == 0) {
    classString = packageName + classString;
  }

  ActivityInfo activityInfo = new ActivityInfo();
  activityInfo.packageName = packageName;
  activityInfo.name = classString;
  if ((flags & GET_META_DATA) != 0) {
    for (int i = 0; i < androidManifest.getReceiverCount(); ++i) {
      if (androidManifest.getReceiverClassName(i).equals(classString)) {
        activityInfo.metaData = metaDataToBundle(androidManifest.getReceiverMetaData(i));
        break;
      }
    }
  }
  return activityInfo;
}
 

import org.robolectric.AndroidManifest; //导入依赖的package包/类
private List<ResolveInfo> queryImplicitIntent(Intent intent, int flags) {
  List<ResolveInfo> resolveInfoList = new ArrayList<ResolveInfo>();

  for (Map.Entry<String, AndroidManifest> androidManifest : androidManifests.entrySet()) {
    String packageName = androidManifest.getKey();
    AndroidManifest appManifest = androidManifest.getValue();

    for (Map.Entry<String, ActivityData> activity : appManifest.getActivityDatas().entrySet()) {
      String activityName = activity.getKey();
      ActivityData activityData = activity.getValue();

      if (matchIntentFilter(activityData, intent)) {
        ResolveInfo resolveInfo = new ResolveInfo();
        resolveInfo.resolvePackageName = packageName;
        resolveInfo.activityInfo = new ActivityInfo();
        resolveInfo.activityInfo.targetActivity = activityName;

        resolveInfoList.add(resolveInfo);
      }
    }
  }

  return resolveInfoList;
}
 

import org.robolectric.AndroidManifest; //导入依赖的package包/类
@Override
protected AndroidManifest getAppManifest(Config config) {
  String manifestProperty = "../rosie/src/test/AndroidManifest.xml";
  String resProperty = "../rosie/src/main/res";
  return new AndroidManifest(Fs.fileFromPath(manifestProperty), Fs.fileFromPath(resProperty)) {
    @Override
    public int getTargetSdkVersion() {
      return MAX_SDK_SUPPORTED_BY_ROBOLECTRIC;
    }

  };
}
 

import org.robolectric.AndroidManifest; //导入依赖的package包/类
@Override
protected AndroidManifest createAppManifest(final FsFile manifestFile, final FsFile resDir,
        final FsFile assetsDir) {
    FsFile moduleManifestFile = fixModuleDirectoryPathIfNeeded(manifestFile);
    FsFile moduleResDir = fixModuleDirectoryPathIfNeeded(resDir);
    FsFile moduleAssetsDir = fixModuleDirectoryPathIfNeeded(assetsDir);

    return super.createAppManifest(moduleManifestFile, moduleResDir, moduleAssetsDir);
}
 

import org.robolectric.AndroidManifest; //导入依赖的package包/类
public Runner(final Class<?> testClass) throws InitializationError {
    super(RobolectricContext.bootstrap(Runner.class, testClass, new RobolectricContext.Factory() {
        @Override
        public RobolectricContext create() {
            return new RobolectricContext() {
                @Override
                protected AndroidManifest createAppManifest() {
                    return new AndroidManifest(new File("build/tmp/android"));
                }
            };
        }
    }));
}
 

import org.robolectric.AndroidManifest; //导入依赖的package包/类
@Override
protected AndroidManifest getAppManifest(Config config) {
    String path = "src/main/AndroidManifest.xml";

    // android studio has a different execution root for tests than pure gradle
    // so we avoid here manual effort to get them running inside android studio
    if (!new File(path).exists()) {
        path = "app/" + path;
    }

    config = overwriteConfig(config, "manifest", path);
    return super.getAppManifest(config);
}
 

import org.robolectric.AndroidManifest; //导入依赖的package包/类
@Override
protected SdkConfig pickSdkVersion(
        AndroidManifest appManifest, Config config) {
    // current Robolectric supports not the latest android SDK version
    // so we must downgrade to simulate the latest supported version.
    config = overwriteConfig(config, "emulateSdk", "18");
    return super.pickSdkVersion(appManifest, config);
}
 

import org.robolectric.AndroidManifest; //导入依赖的package包/类
private static AndroidManifest getAndroidManifest() {
    return new AndroidManifest(Fs.fileFromPath(MANIFEST),
            Fs.fileFromPath(RESOURCES),
            Fs.fileFromPath(ASSETS)) {
        @Override
        public int getTargetSdkVersion() {
            return TARGET_SDK_VERSION;
        }
    };
}
 

import org.robolectric.AndroidManifest; //导入依赖的package包/类
@Override protected AndroidManifest getAppManifest(Config config) {
    String myAppPath = ClientApp.class.getProtectionDomain().getCodeSource().getLocation().getPath();
    String manifestPath = myAppPath + "../../../../src/main/AndroidManifest.xml";
    String resPath = myAppPath + "../../../../src/main/res";
    String assetPath = myAppPath + "../../../../src/main/assets";
    return createAppManifest(Fs.fileFromPath(manifestPath), Fs.fileFromPath(resPath), Fs.fileFromPath(assetPath));
}