<manifest xmlns:android="http://schemas.android.com/apk/res/android"

      package="com.ray"

      android:installLocation="auto"

      android:versionCode="1"

      android:versionName="1.0">

1. public class SystemServer
2. {
3. ......
4. native public static void init1(String[] args);
5. ......
6. public static void main(String[] args) {
7. ......
8. init1(args);
9. ......
10. }
11. ......
12. }

1. namespace android {
2. extern "C" int system_init();
3. static void android_server_SystemServer_init1(JNIEnv* env, jobject clazz)
4. {
5. system_init();
6. }
7. /*
8. * JNI registration.
9. */
10. static JNINativeMethod gMethods[] = {
11. /* name, signature, funcPtr */
12. { "init1", "([Ljava/lang/String;)V", (void*) android_server_SystemServer_init1 },
13. };
14. int register_android_server_SystemServer(JNIEnv* env)
15. {
16. return jniRegisterNativeMethods(env, "com/android/server/SystemServer",
17. gMethods, NELEM(gMethods));
18. }
19. }; // namespace android

1. extern "C" status_t system_init()
2. {
3. LOGI("Entered system_init()");
4. sp<ProcessState> proc(ProcessState::self());
5. sp<IServiceManager> sm = defaultServiceManager();
6. LOGI("ServiceManager: %p\n", sm.get());
7. sp<GrimReaper> grim = new GrimReaper();
8. sm->asBinder()->linkToDeath(grim, grim.get(), 0);
9. char propBuf[PROPERTY_VALUE_MAX];
10. property_get("system_init.startsurfaceflinger", propBuf, "1");
11. if (strcmp(propBuf, "1") == 0) {
12. // Start the SurfaceFlinger
13. SurfaceFlinger::instantiate();
14. }
15. // Start the sensor service
16. SensorService::instantiate();
17. // On the simulator, audioflinger et al don't get started the
18. // same way as on the device, and we need to start them here
19. if (!proc->supportsProcesses()) {
20. // Start the AudioFlinger
21. AudioFlinger::instantiate();
22. // Start the media playback service
23. MediaPlayerService::instantiate();
24. // Start the camera service
25. CameraService::instantiate();
26. // Start the audio policy service
27. AudioPolicyService::instantiate();
28. }
29. // And now start the Android runtime.  We have to do this bit
30. // of nastiness because the Android runtime initialization requires
31. // some of the core system services to already be started.
32. // All other servers should just start the Android runtime at
33. // the beginning of their processes's main(), before calling
34. // the init function.
35. LOGI("System server: starting Android runtime.\n");
36. AndroidRuntime* runtime = AndroidRuntime::getRuntime();
37. LOGI("System server: starting Android services.\n");
38. runtime->callStatic("com/android/server/SystemServer", "init2");
39. // If running in our own process, just go into the thread
40. // pool.  Otherwise, call the initialization finished
41. // func to let this process continue its initilization.
42. if (proc->supportsProcesses()) {
43. LOGI("System server: entering thread pool.\n");
44. ProcessState::self()->startThreadPool();
45. IPCThreadState::self()->joinThreadPool();
46. LOGI("System server: exiting thread pool.\n");
47. }
48. return NO_ERROR;
49. }

1. /*
2. * Call a static Java Programming Language function that takes no arguments and returns void.
3. */
4. status_t AndroidRuntime::callStatic(const char* className, const char* methodName)
5. {
6. JNIEnv* env;
7. jclass clazz;
8. jmethodID methodId;
9. env = getJNIEnv();
10. if (env == NULL)
11. return UNKNOWN_ERROR;
12. clazz = findClass(env, className);
13. if (clazz == NULL) {
14. LOGE("ERROR: could not find class '%s'\n", className);
15. return UNKNOWN_ERROR;
16. }
17. methodId = env->GetStaticMethodID(clazz, methodName, "()V");
18. if (methodId == NULL) {
19. LOGE("ERROR: could not find method %s.%s\n", className, methodName);
20. return UNKNOWN_ERROR;
21. }
22. env->CallStaticVoidMethod(clazz, methodId);
23. return NO_ERROR;
24. }

1. public class SystemServer
2. {
3. ......
4. public static final void init2() {
5. Slog.i(TAG, "Entered the Android system server!");
6. Thread thr = new ServerThread();
7. thr.setName("android.server.ServerThread");
8. thr.start();
9. }
10. }

1. class ServerThread extends Thread {
2. ......
3. @Override
4. public void run() {
5. ......
6. IPackageManager pm = null;
7. ......
8. // Critical services...
9. try {
10. ......
11. Slog.i(TAG, "Package Manager");
12. pm = PackageManagerService.main(context,
13. factoryTest != SystemServer.FACTORY_TEST_OFF);
14. ......
15. } catch (RuntimeException e) {
16. Slog.e("System", "Failure starting core service", e);
17. }
18. ......
19. }
20. ......
21. }

1. class PackageManagerService extends IPackageManager.Stub {
2. ......
3. public static final IPackageManager main(Context context, boolean factoryTest) {
4. PackageManagerService m = new PackageManagerService(context, factoryTest);
5. ServiceManager.addService("package", m);
6. return m;
7. }
8. ......
9. }

1. class PackageManagerService extends IPackageManager.Stub {
2. ......
3. public PackageManagerService(Context context, boolean factoryTest) {
4. ......
5. synchronized (mInstallLock) {
6. synchronized (mPackages) {
7. ......
8. File dataDir = Environment.getDataDirectory();
9. mAppDataDir = new File(dataDir, "data");
10. mSecureAppDataDir = new File(dataDir, "secure/data");
11. mDrmAppPrivateInstallDir = new File(dataDir, "app-private");
12. ......
13. mFrameworkDir = new File(Environment.getRootDirectory(), "framework");
14. mDalvikCacheDir = new File(dataDir, "dalvik-cache");
15. ......
16. // Find base frameworks (resource packages without code).
17. mFrameworkInstallObserver = new AppDirObserver(
18. mFrameworkDir.getPath(), OBSERVER_EVENTS, true);
19. mFrameworkInstallObserver.startWatching();
20. scanDirLI(mFrameworkDir, PackageParser.PARSE_IS_SYSTEM
21. | PackageParser.PARSE_IS_SYSTEM_DIR,
22. scanMode | SCAN_NO_DEX, 0);
23. // Collect all system packages.
24. mSystemAppDir = new File(Environment.getRootDirectory(), "app");
25. mSystemInstallObserver = new AppDirObserver(
26. mSystemAppDir.getPath(), OBSERVER_EVENTS, true);
27. mSystemInstallObserver.startWatching();
28. scanDirLI(mSystemAppDir, PackageParser.PARSE_IS_SYSTEM
29. | PackageParser.PARSE_IS_SYSTEM_DIR, scanMode, 0);
30. // Collect all vendor packages.
31. mVendorAppDir = new File("/vendor/app");
32. mVendorInstallObserver = new AppDirObserver(
33. mVendorAppDir.getPath(), OBSERVER_EVENTS, true);
34. mVendorInstallObserver.startWatching();
35. scanDirLI(mVendorAppDir, PackageParser.PARSE_IS_SYSTEM
36. | PackageParser.PARSE_IS_SYSTEM_DIR, scanMode, 0);
37. mAppInstallObserver = new AppDirObserver(
38. mAppInstallDir.getPath(), OBSERVER_EVENTS, false);
39. mAppInstallObserver.startWatching();
40. scanDirLI(mAppInstallDir, 0, scanMode, 0);
41. mDrmAppInstallObserver = new AppDirObserver(
42. mDrmAppPrivateInstallDir.getPath(), OBSERVER_EVENTS, false);
43. mDrmAppInstallObserver.startWatching();
44. scanDirLI(mDrmAppPrivateInstallDir, PackageParser.PARSE_FORWARD_LOCK,
45. scanMode, 0);
46. ......
47. }
48. }
49. }
50. ......
51. }

1. class PackageManagerService extends IPackageManager.Stub {
2. ......
3. private void scanDirLI(File dir, int flags, int scanMode, long currentTime) {
4. String[] files = dir.list();
5. ......
6. int i;
7. for (i=0; i<files.length; i++) {
8. File file = new File(dir, files[i]);
9. if (!isPackageFilename(files[i])) {
10. // Ignore entries which are not apk's
11. continue;
12. }
13. PackageParser.Package pkg = scanPackageLI(file,
14. flags|PackageParser.PARSE_MUST_BE_APK, scanMode, currentTime);
15. // Don't mess around with apps in system partition.
16. if (pkg == null && (flags & PackageParser.PARSE_IS_SYSTEM) == 0 &&
17. mLastScanError == PackageManager.INSTALL_FAILED_INVALID_APK) {
18. // Delete the apk
19. Slog.w(TAG, "Cleaning up failed install of " + file);
20. file.delete();
21. }
22. }
23. }
24. ......
25. }

1. class PackageManagerService extends IPackageManager.Stub {
2. ......
3. private PackageParser.Package scanPackageLI(File scanFile,
4. int parseFlags, int scanMode, long currentTime) {
5. ......
6. String scanPath = scanFile.getPath();
7. parseFlags |= mDefParseFlags;
8. PackageParser pp = new PackageParser(scanPath);
9. ......
10. final PackageParser.Package pkg = pp.parsePackage(scanFile,
11. scanPath, mMetrics, parseFlags);
12. ......
13. return scanPackageLI(pkg, parseFlags, scanMode | SCAN_UPDATE_SIGNATURE, currentTime);
14. }
15. ......
16. }

1. public class PackageParser {
2. ......
3. public Package parsePackage(File sourceFile, String destCodePath,
4. DisplayMetrics metrics, int flags) {
5. ......
6. mArchiveSourcePath = sourceFile.getPath();
7. ......
8. XmlResourceParser parser = null;
9. AssetManager assmgr = null;
10. boolean assetError = true;
11. try {
12. assmgr = new AssetManager();
13. int cookie = assmgr.addAssetPath(mArchiveSourcePath);
14. if(cookie != 0) {
15. parser = assmgr.openXmlResourceParser(cookie, "AndroidManifest.xml");
16. assetError = false;
17. } else {
18. ......
19. }
20. } catch (Exception e) {
21. ......
22. }
23. ......
24. String[] errorText = new String[1];
25. Package pkg = null;
26. Exception errorException = null;
27. try {
28. // XXXX todo: need to figure out correct configuration.
29. Resources res = new Resources(assmgr, metrics, null);
30. pkg = parsePackage(res, parser, flags, errorText);
31. } catch (Exception e) {
32. ......
33. }
34. ......
35. parser.close();
36. assmgr.close();
37. // Set code and resource paths
38. pkg.mPath = destCodePath;
39. pkg.mScanPath = mArchiveSourcePath;
40. //pkg.applicationInfo.sourceDir = destCodePath;
41. //pkg.applicationInfo.publicSourceDir = destRes;
42. pkg.mSignatures = null;
43. return pkg;
44. }
45. ......
46. }

1. public class PackageParser {
2. ......
3. private Package parsePackage(
4. Resources res, XmlResourceParser parser, int flags, String[] outError)
5. throws XmlPullParserException, IOException {
6. ......
7. String pkgName = parsePackageName(parser, attrs, flags, outError);
8. ......
9. final Package pkg = new Package(pkgName);
10. ......
11. int type;
12. ......
13. TypedArray sa = res.obtainAttributes(attrs,
14. com.android.internal.R.styleable.AndroidManifest);
15. ......
16. while ((type=parser.next()) != parser.END_DOCUMENT
17. && (type != parser.END_TAG || parser.getDepth() > outerDepth)) {
18. if (type == parser.END_TAG || type == parser.TEXT) {
19. continue;
20. }
21. String tagName = parser.getName();
22. if (tagName.equals("application")) {
23. ......
24. if (!parseApplication(pkg, res, parser, attrs, flags, outError)) {
25. return null;
26. }
27. } else if (tagName.equals("permission-group")) {
28. ......
29. } else if (tagName.equals("permission")) {
30. ......
31. } else if (tagName.equals("permission-tree")) {
32. ......
33. } else if (tagName.equals("uses-permission")) {
34. ......
35. } else if (tagName.equals("uses-configuration")) {
36. ......
37. } else if (tagName.equals("uses-feature")) {
38. ......
39. } else if (tagName.equals("uses-sdk")) {
40. ......
41. } else if (tagName.equals("supports-screens")) {
42. ......
43. } else if (tagName.equals("protected-broadcast")) {
44. ......
45. } else if (tagName.equals("instrumentation")) {
46. ......
47. } else if (tagName.equals("original-package")) {
48. ......
49. } else if (tagName.equals("adopt-permissions")) {
50. ......
51. } else if (tagName.equals("uses-gl-texture")) {
52. ......
53. } else if (tagName.equals("compatible-screens")) {
54. ......
55. } else if (tagName.equals("eat-comment")) {
56. ......
57. } else if (RIGID_PARSER) {
58. ......
59. } else {
60. ......
61. }
62. }
63. ......
64. return pkg;
65. }
66. ......
67. }

1. public class PackageParser {
2. ......
3. private boolean parseApplication(Package owner, Resources res,
4. XmlPullParser parser, AttributeSet attrs, int flags, String[] outError)
5. throws XmlPullParserException, IOException {
6. final ApplicationInfo ai = owner.applicationInfo;
7. final String pkgName = owner.applicationInfo.packageName;
8. TypedArray sa = res.obtainAttributes(attrs,
9. com.android.internal.R.styleable.AndroidManifestApplication);
10. ......
11. int type;
12. while ((type=parser.next()) != parser.END_DOCUMENT
13. && (type != parser.END_TAG || parser.getDepth() > innerDepth)) {
14. if (type == parser.END_TAG || type == parser.TEXT) {
15. continue;
16. }
17. String tagName = parser.getName();
18. if (tagName.equals("activity")) {
19. Activity a = parseActivity(owner, res, parser, attrs, flags, outError, false);
20. ......
21. owner.activities.add(a);
22. } else if (tagName.equals("receiver")) {
23. Activity a = parseActivity(owner, res, parser, attrs, flags, outError, true);
24. ......
25. owner.receivers.add(a);
26. } else if (tagName.equals("service")) {
27. Service s = parseService(owner, res, parser, attrs, flags, outError);
28. ......
29. owner.services.add(s);
30. } else if (tagName.equals("provider")) {
31. Provider p = parseProvider(owner, res, parser, attrs, flags, outError);
32. ......
33. owner.providers.add(p);
34. } else if (tagName.equals("activity-alias")) {
35. Activity a = parseActivityAlias(owner, res, parser, attrs, flags, outError);
36. ......
37. owner.activities.add(a);
38. } else if (parser.getName().equals("meta-data")) {
39. ......
40. } else if (tagName.equals("uses-library")) {
41. ......
42. } else if (tagName.equals("uses-package")) {
43. ......
44. } else {
45. ......
46. }
47. }
48. return true;
49. }
50. ......
51. }

1. class PackageManagerService extends IPackageManager.Stub {
2. ......
3. // Keys are String (package name), values are Package.  This also serves
4. // as the lock for the global state.  Methods that must be called with
5. // this lock held have the prefix "LP".
6. final HashMap<String, PackageParser.Package> mPackages =
7. new HashMap<String, PackageParser.Package>();
8. ......
9. // All available activities, for your resolving pleasure.
10. final ActivityIntentResolver mActivities =
11. new ActivityIntentResolver();
12. // All available receivers, for your resolving pleasure.
13. final ActivityIntentResolver mReceivers =
14. new ActivityIntentResolver();
15. // All available services, for your resolving pleasure.
16. final ServiceIntentResolver mServices = new ServiceIntentResolver();
17. // Keys are String (provider class name), values are Provider.
18. final HashMap<ComponentName, PackageParser.Provider> mProvidersByComponent =
19. new HashMap<ComponentName, PackageParser.Provider>();
20. ......
21. private PackageParser.Package scanPackageLI(PackageParser.Package pkg,
22. int parseFlags, int scanMode, long currentTime) {
23. ......
24. synchronized (mPackages) {
25. ......
26. // Add the new setting to mPackages
27. mPackages.put(pkg.applicationInfo.packageName, pkg);
28. ......
29. int N = pkg.providers.size();
30. int i;
31. for (i=0; i<N; i++) {
32. PackageParser.Provider p = pkg.providers.get(i);
33. p.info.processName = fixProcessName(pkg.applicationInfo.processName,
34. p.info.processName, pkg.applicationInfo.uid);
35. mProvidersByComponent.put(new ComponentName(p.info.packageName,
36. p.info.name), p);
37. ......
38. }
39. N = pkg.services.size();
40. for (i=0; i<N; i++) {
41. PackageParser.Service s = pkg.services.get(i);
42. s.info.processName = fixProcessName(pkg.applicationInfo.processName,
43. s.info.processName, pkg.applicationInfo.uid);
44. mServices.addService(s);
45. ......
46. }
47. N = pkg.receivers.size();
48. r = null;
49. for (i=0; i<N; i++) {
50. PackageParser.Activity a = pkg.receivers.get(i);
51. a.info.processName = fixProcessName(pkg.applicationInfo.processName,
52. a.info.processName, pkg.applicationInfo.uid);
53. mReceivers.addActivity(a, "receiver");
54. ......
55. }
56. N = pkg.activities.size();
57. for (i=0; i<N; i++) {
58. PackageParser.Activity a = pkg.activities.get(i);
59. a.info.processName = fixProcessName(pkg.applicationInfo.processName,
60. a.info.processName, pkg.applicationInfo.uid);
61. mActivities.addActivity(a, "activity");
62. ......
63. }
64. ......
65. }
66. ......
67. return pkg;
68. }
69. ......
70. }