PackageParser.java revision 7d19e0242faac8017033dabb872cdf1542fa184c 
1/*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package android.content.pm;
18
19import android.content.ComponentName;
20import android.content.Intent;
21import android.content.IntentFilter;
22import android.content.res.AssetManager;
23import android.content.res.Configuration;
24import android.content.res.Resources;
25import android.content.res.TypedArray;
26import android.content.res.XmlResourceParser;
27import android.os.Binder;
28import android.os.Build;
29import android.os.Bundle;
30import android.os.PatternMatcher;
31import android.os.UserId;
32import android.util.AttributeSet;
33import android.util.Base64;
34import android.util.DisplayMetrics;
35import android.util.Log;
36import android.util.Slog;
37import android.util.TypedValue;
38
39import java.io.BufferedInputStream;
40import java.io.File;
41import java.io.IOException;
42import java.io.InputStream;
43import java.lang.ref.WeakReference;
44import java.security.KeyFactory;
45import java.security.NoSuchAlgorithmException;
46import java.security.PublicKey;
47import java.security.cert.Certificate;
48import java.security.cert.CertificateEncodingException;
49import java.security.spec.EncodedKeySpec;
50import java.security.spec.InvalidKeySpecException;
51import java.security.spec.X509EncodedKeySpec;
52import java.util.ArrayList;
53import java.util.Enumeration;
54import java.util.HashSet;
55import java.util.Iterator;
56import java.util.List;
57import java.util.jar.Attributes;
58import java.util.jar.JarEntry;
59import java.util.jar.JarFile;
60import java.util.jar.Manifest;
61
62import com.android.internal.util.XmlUtils;
63
64import org.xmlpull.v1.XmlPullParser;
65import org.xmlpull.v1.XmlPullParserException;
66
67/**
68 * Package archive parsing
69 *
70 * {@hide}
71 */
72public class PackageParser {
73    private static final boolean DEBUG_JAR = false;
74    private static final boolean DEBUG_PARSER = false;
75    private static final boolean DEBUG_BACKUP = false;
76
77    /** File name in an APK for the Android manifest. */
78    private static final String ANDROID_MANIFEST_FILENAME = "AndroidManifest.xml";
79
80    /** @hide */
81    public static class NewPermissionInfo {
82        public final String name;
83        public final int sdkVersion;
84        public final int fileVersion;
85
86        public NewPermissionInfo(String name, int sdkVersion, int fileVersion) {
87            this.name = name;
88            this.sdkVersion = sdkVersion;
89            this.fileVersion = fileVersion;
90        }
91    }
92
93    /** @hide */
94    public static class SplitPermissionInfo {
95        public final String rootPerm;
96        public final String[] newPerms;
97        public final int targetSdk;
98
99        public SplitPermissionInfo(String rootPerm, String[] newPerms, int targetSdk) {
100            this.rootPerm = rootPerm;
101            this.newPerms = newPerms;
102            this.targetSdk = targetSdk;
103        }
104    }
105
106    /**
107     * List of new permissions that have been added since 1.0.
108     * NOTE: These must be declared in SDK version order, with permissions
109     * added to older SDKs appearing before those added to newer SDKs.
110     * If sdkVersion is 0, then this is not a permission that we want to
111     * automatically add to older apps, but we do want to allow it to be
112     * granted during a platform update.
113     * @hide
114     */
115    public static final PackageParser.NewPermissionInfo NEW_PERMISSIONS[] =
116        new PackageParser.NewPermissionInfo[] {
117            new PackageParser.NewPermissionInfo(android.Manifest.permission.WRITE_EXTERNAL_STORAGE,
118                    android.os.Build.VERSION_CODES.DONUT, 0),
119            new PackageParser.NewPermissionInfo(android.Manifest.permission.READ_PHONE_STATE,
120                    android.os.Build.VERSION_CODES.DONUT, 0)
121    };
122
123    /**
124     * List of permissions that have been split into more granular or dependent
125     * permissions.
126     * @hide
127     */
128    public static final PackageParser.SplitPermissionInfo SPLIT_PERMISSIONS[] =
129        new PackageParser.SplitPermissionInfo[] {
130            // READ_EXTERNAL_STORAGE is always required when an app requests
131            // WRITE_EXTERNAL_STORAGE, because we can't have an app that has
132            // write access without read access.  The hack here with the target
133            // target SDK version ensures that this grant is always done.
134            new PackageParser.SplitPermissionInfo(android.Manifest.permission.WRITE_EXTERNAL_STORAGE,
135                    new String[] { android.Manifest.permission.READ_EXTERNAL_STORAGE },
136                    android.os.Build.VERSION_CODES.CUR_DEVELOPMENT+1),
137            new PackageParser.SplitPermissionInfo(android.Manifest.permission.READ_CONTACTS,
138                    new String[] { android.Manifest.permission.READ_CALL_LOG },
139                    android.os.Build.VERSION_CODES.JELLY_BEAN),
140            new PackageParser.SplitPermissionInfo(android.Manifest.permission.WRITE_CONTACTS,
141                    new String[] { android.Manifest.permission.WRITE_CALL_LOG },
142                    android.os.Build.VERSION_CODES.JELLY_BEAN)
143    };
144
145    private String mArchiveSourcePath;
146    private String[] mSeparateProcesses;
147    private boolean mOnlyCoreApps;
148    private static final int SDK_VERSION = Build.VERSION.SDK_INT;
149    private static final String SDK_CODENAME = "REL".equals(Build.VERSION.CODENAME)
150            ? null : Build.VERSION.CODENAME;
151
152    private int mParseError = PackageManager.INSTALL_SUCCEEDED;
153
154    private static final Object mSync = new Object();
155    private static WeakReference<byte[]> mReadBuffer;
156
157    private static boolean sCompatibilityModeEnabled = true;
158    private static final int PARSE_DEFAULT_INSTALL_LOCATION = PackageInfo.INSTALL_LOCATION_UNSPECIFIED;
159
160    static class ParsePackageItemArgs {
161        final Package owner;
162        final String[] outError;
163        final int nameRes;
164        final int labelRes;
165        final int iconRes;
166        final int logoRes;
167
168        String tag;
169        TypedArray sa;
170
171        ParsePackageItemArgs(Package _owner, String[] _outError,
172                int _nameRes, int _labelRes, int _iconRes, int _logoRes) {
173            owner = _owner;
174            outError = _outError;
175            nameRes = _nameRes;
176            labelRes = _labelRes;
177            iconRes = _iconRes;
178            logoRes = _logoRes;
179        }
180    }
181
182    static class ParseComponentArgs extends ParsePackageItemArgs {
183        final String[] sepProcesses;
184        final int processRes;
185        final int descriptionRes;
186        final int enabledRes;
187        int flags;
188
189        ParseComponentArgs(Package _owner, String[] _outError,
190                int _nameRes, int _labelRes, int _iconRes, int _logoRes,
191                String[] _sepProcesses, int _processRes,
192                int _descriptionRes, int _enabledRes) {
193            super(_owner, _outError, _nameRes, _labelRes, _iconRes, _logoRes);
194            sepProcesses = _sepProcesses;
195            processRes = _processRes;
196            descriptionRes = _descriptionRes;
197            enabledRes = _enabledRes;
198        }
199    }
200
201    /* Light weight package info.
202     * @hide
203     */
204    public static class PackageLite {
205        public final String packageName;
206        public final int installLocation;
207        public final VerifierInfo[] verifiers;
208
209        public PackageLite(String packageName, int installLocation, List<VerifierInfo> verifiers) {
210            this.packageName = packageName;
211            this.installLocation = installLocation;
212            this.verifiers = verifiers.toArray(new VerifierInfo[verifiers.size()]);
213        }
214    }
215
216    private ParsePackageItemArgs mParseInstrumentationArgs;
217    private ParseComponentArgs mParseActivityArgs;
218    private ParseComponentArgs mParseActivityAliasArgs;
219    private ParseComponentArgs mParseServiceArgs;
220    private ParseComponentArgs mParseProviderArgs;
221
222    /** If set to true, we will only allow package files that exactly match
223     *  the DTD.  Otherwise, we try to get as much from the package as we
224     *  can without failing.  This should normally be set to false, to
225     *  support extensions to the DTD in future versions. */
226    private static final boolean RIGID_PARSER = false;
227
228    private static final String TAG = "PackageParser";
229
230    public PackageParser(String archiveSourcePath) {
231        mArchiveSourcePath = archiveSourcePath;
232    }
233
234    public void setSeparateProcesses(String[] procs) {
235        mSeparateProcesses = procs;
236    }
237
238    public void setOnlyCoreApps(boolean onlyCoreApps) {
239        mOnlyCoreApps = onlyCoreApps;
240    }
241
242    private static final boolean isPackageFilename(String name) {
243        return name.endsWith(".apk");
244    }
245
246    public static PackageInfo generatePackageInfo(PackageParser.Package p,
247            int gids[], int flags, long firstInstallTime, long lastUpdateTime,
248            HashSet<String> grantedPermissions) {
249
250        return generatePackageInfo(p, gids, flags, firstInstallTime, lastUpdateTime,
251                grantedPermissions, false, PackageManager.COMPONENT_ENABLED_STATE_DEFAULT,
252                UserId.getCallingUserId());
253    }
254
255    /**
256     * Generate and return the {@link PackageInfo} for a parsed package.
257     *
258     * @param p the parsed package.
259     * @param flags indicating which optional information is included.
260     */
261    public static PackageInfo generatePackageInfo(PackageParser.Package p,
262            int gids[], int flags, long firstInstallTime, long lastUpdateTime,
263            HashSet<String> grantedPermissions, boolean stopped, int enabledState) {
264
265        return generatePackageInfo(p, gids, flags, firstInstallTime, lastUpdateTime,
266                grantedPermissions, stopped, enabledState, UserId.getCallingUserId());
267    }
268
269    public static PackageInfo generatePackageInfo(PackageParser.Package p,
270            int gids[], int flags, long firstInstallTime, long lastUpdateTime,
271            HashSet<String> grantedPermissions, boolean stopped, int enabledState, int userId) {
272
273        PackageInfo pi = new PackageInfo();
274        pi.packageName = p.packageName;
275        pi.versionCode = p.mVersionCode;
276        pi.versionName = p.mVersionName;
277        pi.sharedUserId = p.mSharedUserId;
278        pi.sharedUserLabel = p.mSharedUserLabel;
279        pi.applicationInfo = generateApplicationInfo(p, flags, stopped, enabledState, userId);
280        pi.installLocation = p.installLocation;
281        pi.firstInstallTime = firstInstallTime;
282        pi.lastUpdateTime = lastUpdateTime;
283        if ((flags&PackageManager.GET_GIDS) != 0) {
284            pi.gids = gids;
285        }
286        if ((flags&PackageManager.GET_CONFIGURATIONS) != 0) {
287            int N = p.configPreferences.size();
288            if (N > 0) {
289                pi.configPreferences = new ConfigurationInfo[N];
290                p.configPreferences.toArray(pi.configPreferences);
291            }
292            N = p.reqFeatures != null ? p.reqFeatures.size() : 0;
293            if (N > 0) {
294                pi.reqFeatures = new FeatureInfo[N];
295                p.reqFeatures.toArray(pi.reqFeatures);
296            }
297        }
298        if ((flags&PackageManager.GET_ACTIVITIES) != 0) {
299            int N = p.activities.size();
300            if (N > 0) {
301                if ((flags&PackageManager.GET_DISABLED_COMPONENTS) != 0) {
302                    pi.activities = new ActivityInfo[N];
303                } else {
304                    int num = 0;
305                    for (int i=0; i<N; i++) {
306                        if (p.activities.get(i).info.enabled) num++;
307                    }
308                    pi.activities = new ActivityInfo[num];
309                }
310                for (int i=0, j=0; i<N; i++) {
311                    final Activity activity = p.activities.get(i);
312                    if (activity.info.enabled
313                        || (flags&PackageManager.GET_DISABLED_COMPONENTS) != 0) {
314                        pi.activities[j++] = generateActivityInfo(p.activities.get(i), flags,
315                                stopped, enabledState, userId);
316                    }
317                }
318            }
319        }
320        if ((flags&PackageManager.GET_RECEIVERS) != 0) {
321            int N = p.receivers.size();
322            if (N > 0) {
323                if ((flags&PackageManager.GET_DISABLED_COMPONENTS) != 0) {
324                    pi.receivers = new ActivityInfo[N];
325                } else {
326                    int num = 0;
327                    for (int i=0; i<N; i++) {
328                        if (p.receivers.get(i).info.enabled) num++;
329                    }
330                    pi.receivers = new ActivityInfo[num];
331                }
332                for (int i=0, j=0; i<N; i++) {
333                    final Activity activity = p.receivers.get(i);
334                    if (activity.info.enabled
335                        || (flags&PackageManager.GET_DISABLED_COMPONENTS) != 0) {
336                        pi.receivers[j++] = generateActivityInfo(p.receivers.get(i), flags,
337                                stopped, enabledState, userId);
338                    }
339                }
340            }
341        }
342        if ((flags&PackageManager.GET_SERVICES) != 0) {
343            int N = p.services.size();
344            if (N > 0) {
345                if ((flags&PackageManager.GET_DISABLED_COMPONENTS) != 0) {
346                    pi.services = new ServiceInfo[N];
347                } else {
348                    int num = 0;
349                    for (int i=0; i<N; i++) {
350                        if (p.services.get(i).info.enabled) num++;
351                    }
352                    pi.services = new ServiceInfo[num];
353                }
354                for (int i=0, j=0; i<N; i++) {
355                    final Service service = p.services.get(i);
356                    if (service.info.enabled
357                        || (flags&PackageManager.GET_DISABLED_COMPONENTS) != 0) {
358                        pi.services[j++] = generateServiceInfo(p.services.get(i), flags, stopped,
359                                enabledState, userId);
360                    }
361                }
362            }
363        }
364        if ((flags&PackageManager.GET_PROVIDERS) != 0) {
365            int N = p.providers.size();
366            if (N > 0) {
367                if ((flags&PackageManager.GET_DISABLED_COMPONENTS) != 0) {
368                    pi.providers = new ProviderInfo[N];
369                } else {
370                    int num = 0;
371                    for (int i=0; i<N; i++) {
372                        if (p.providers.get(i).info.enabled) num++;
373                    }
374                    pi.providers = new ProviderInfo[num];
375                }
376                for (int i=0, j=0; i<N; i++) {
377                    final Provider provider = p.providers.get(i);
378                    if (provider.info.enabled
379                        || (flags&PackageManager.GET_DISABLED_COMPONENTS) != 0) {
380                        pi.providers[j++] = generateProviderInfo(p.providers.get(i), flags, stopped,
381                                enabledState, userId);
382                    }
383                }
384            }
385        }
386        if ((flags&PackageManager.GET_INSTRUMENTATION) != 0) {
387            int N = p.instrumentation.size();
388            if (N > 0) {
389                pi.instrumentation = new InstrumentationInfo[N];
390                for (int i=0; i<N; i++) {
391                    pi.instrumentation[i] = generateInstrumentationInfo(
392                            p.instrumentation.get(i), flags);
393                }
394            }
395        }
396        if ((flags&PackageManager.GET_PERMISSIONS) != 0) {
397            int N = p.permissions.size();
398            if (N > 0) {
399                pi.permissions = new PermissionInfo[N];
400                for (int i=0; i<N; i++) {
401                    pi.permissions[i] = generatePermissionInfo(p.permissions.get(i), flags);
402                }
403            }
404            N = p.requestedPermissions.size();
405            if (N > 0) {
406                pi.requestedPermissions = new String[N];
407                pi.requestedPermissionsFlags = new int[N];
408                for (int i=0; i<N; i++) {
409                    final String perm = p.requestedPermissions.get(i);
410                    pi.requestedPermissions[i] = perm;
411                    if (p.requestedPermissionsRequired.get(i)) {
412                        pi.requestedPermissionsFlags[i] |= PackageInfo.REQUESTED_PERMISSION_REQUIRED;
413                    }
414                    if (grantedPermissions != null && grantedPermissions.contains(perm)) {
415                        pi.requestedPermissionsFlags[i] |= PackageInfo.REQUESTED_PERMISSION_GRANTED;
416                    }
417                }
418            }
419        }
420        if ((flags&PackageManager.GET_SIGNATURES) != 0) {
421           int N = (p.mSignatures != null) ? p.mSignatures.length : 0;
422           if (N > 0) {
423                pi.signatures = new Signature[N];
424                System.arraycopy(p.mSignatures, 0, pi.signatures, 0, N);
425            }
426        }
427        return pi;
428    }
429
430    private Certificate[] loadCertificates(JarFile jarFile, JarEntry je,
431            byte[] readBuffer) {
432        try {
433            // We must read the stream for the JarEntry to retrieve
434            // its certificates.
435            InputStream is = new BufferedInputStream(jarFile.getInputStream(je));
436            while (is.read(readBuffer, 0, readBuffer.length) != -1) {
437                // not using
438            }
439            is.close();
440            return je != null ? je.getCertificates() : null;
441        } catch (IOException e) {
442            Slog.w(TAG, "Exception reading " + je.getName() + " in "
443                    + jarFile.getName(), e);
444        } catch (RuntimeException e) {
445            Slog.w(TAG, "Exception reading " + je.getName() + " in "
446                    + jarFile.getName(), e);
447        }
448        return null;
449    }
450
451    public final static int PARSE_IS_SYSTEM = 1<<0;
452    public final static int PARSE_CHATTY = 1<<1;
453    public final static int PARSE_MUST_BE_APK = 1<<2;
454    public final static int PARSE_IGNORE_PROCESSES = 1<<3;
455    public final static int PARSE_FORWARD_LOCK = 1<<4;
456    public final static int PARSE_ON_SDCARD = 1<<5;
457    public final static int PARSE_IS_SYSTEM_DIR = 1<<6;
458
459    public int getParseError() {
460        return mParseError;
461    }
462
463    public Package parsePackage(File sourceFile, String destCodePath,
464            DisplayMetrics metrics, int flags) {
465        mParseError = PackageManager.INSTALL_SUCCEEDED;
466
467        mArchiveSourcePath = sourceFile.getPath();
468        if (!sourceFile.isFile()) {
469            Slog.w(TAG, "Skipping dir: " + mArchiveSourcePath);
470            mParseError = PackageManager.INSTALL_PARSE_FAILED_NOT_APK;
471            return null;
472        }
473        if (!isPackageFilename(sourceFile.getName())
474                && (flags&PARSE_MUST_BE_APK) != 0) {
475            if ((flags&PARSE_IS_SYSTEM) == 0) {
476                // We expect to have non-.apk files in the system dir,
477                // so don't warn about them.
478                Slog.w(TAG, "Skipping non-package file: " + mArchiveSourcePath);
479            }
480            mParseError = PackageManager.INSTALL_PARSE_FAILED_NOT_APK;
481            return null;
482        }
483
484        if (DEBUG_JAR)
485            Slog.d(TAG, "Scanning package: " + mArchiveSourcePath);
486
487        XmlResourceParser parser = null;
488        AssetManager assmgr = null;
489        Resources res = null;
490        boolean assetError = true;
491        try {
492            assmgr = new AssetManager();
493            int cookie = assmgr.addAssetPath(mArchiveSourcePath);
494            if (cookie != 0) {
495                res = new Resources(assmgr, metrics, null);
496                assmgr.setConfiguration(0, 0, null, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
497                        Build.VERSION.RESOURCES_SDK_INT);
498                parser = assmgr.openXmlResourceParser(cookie, ANDROID_MANIFEST_FILENAME);
499                assetError = false;
500            } else {
501                Slog.w(TAG, "Failed adding asset path:"+mArchiveSourcePath);
502            }
503        } catch (Exception e) {
504            Slog.w(TAG, "Unable to read AndroidManifest.xml of "
505                    + mArchiveSourcePath, e);
506        }
507        if (assetError) {
508            if (assmgr != null) assmgr.close();
509            mParseError = PackageManager.INSTALL_PARSE_FAILED_BAD_MANIFEST;
510            return null;
511        }
512        String[] errorText = new String[1];
513        Package pkg = null;
514        Exception errorException = null;
515        try {
516            // XXXX todo: need to figure out correct configuration.
517            pkg = parsePackage(res, parser, flags, errorText);
518        } catch (Exception e) {
519            errorException = e;
520            mParseError = PackageManager.INSTALL_PARSE_FAILED_UNEXPECTED_EXCEPTION;
521        }
522
523
524        if (pkg == null) {
525            // If we are only parsing core apps, then a null with INSTALL_SUCCEEDED
526            // just means to skip this app so don't make a fuss about it.
527            if (!mOnlyCoreApps || mParseError != PackageManager.INSTALL_SUCCEEDED) {
528                if (errorException != null) {
529                    Slog.w(TAG, mArchiveSourcePath, errorException);
530                } else {
531                    Slog.w(TAG, mArchiveSourcePath + " (at "
532                            + parser.getPositionDescription()
533                            + "): " + errorText[0]);
534                }
535                if (mParseError == PackageManager.INSTALL_SUCCEEDED) {
536                    mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
537                }
538            }
539            parser.close();
540            assmgr.close();
541            return null;
542        }
543
544        parser.close();
545        assmgr.close();
546
547        // Set code and resource paths
548        pkg.mPath = destCodePath;
549        pkg.mScanPath = mArchiveSourcePath;
550        //pkg.applicationInfo.sourceDir = destCodePath;
551        //pkg.applicationInfo.publicSourceDir = destRes;
552        pkg.mSignatures = null;
553
554        return pkg;
555    }
556
557    public boolean collectCertificates(Package pkg, int flags) {
558        pkg.mSignatures = null;
559
560        WeakReference<byte[]> readBufferRef;
561        byte[] readBuffer = null;
562        synchronized (mSync) {
563            readBufferRef = mReadBuffer;
564            if (readBufferRef != null) {
565                mReadBuffer = null;
566                readBuffer = readBufferRef.get();
567            }
568            if (readBuffer == null) {
569                readBuffer = new byte[8192];
570                readBufferRef = new WeakReference<byte[]>(readBuffer);
571            }
572        }
573
574        try {
575            JarFile jarFile = new JarFile(mArchiveSourcePath);
576
577            Certificate[] certs = null;
578
579            if ((flags&PARSE_IS_SYSTEM) != 0) {
580                // If this package comes from the system image, then we
581                // can trust it...  we'll just use the AndroidManifest.xml
582                // to retrieve its signatures, not validating all of the
583                // files.
584                JarEntry jarEntry = jarFile.getJarEntry(ANDROID_MANIFEST_FILENAME);
585                certs = loadCertificates(jarFile, jarEntry, readBuffer);
586                if (certs == null) {
587                    Slog.e(TAG, "Package " + pkg.packageName
588                            + " has no certificates at entry "
589                            + jarEntry.getName() + "; ignoring!");
590                    jarFile.close();
591                    mParseError = PackageManager.INSTALL_PARSE_FAILED_NO_CERTIFICATES;
592                    return false;
593                }
594                if (DEBUG_JAR) {
595                    Slog.i(TAG, "File " + mArchiveSourcePath + ": entry=" + jarEntry
596                            + " certs=" + (certs != null ? certs.length : 0));
597                    if (certs != null) {
598                        final int N = certs.length;
599                        for (int i=0; i<N; i++) {
600                            Slog.i(TAG, "  Public key: "
601                                    + certs[i].getPublicKey().getEncoded()
602                                    + " " + certs[i].getPublicKey());
603                        }
604                    }
605                }
606            } else {
607                Enumeration<JarEntry> entries = jarFile.entries();
608                final Manifest manifest = jarFile.getManifest();
609                while (entries.hasMoreElements()) {
610                    final JarEntry je = entries.nextElement();
611                    if (je.isDirectory()) continue;
612
613                    final String name = je.getName();
614
615                    if (name.startsWith("META-INF/"))
616                        continue;
617
618                    if (ANDROID_MANIFEST_FILENAME.equals(name)) {
619                        final Attributes attributes = manifest.getAttributes(name);
620                        pkg.manifestDigest = ManifestDigest.fromAttributes(attributes);
621                    }
622
623                    final Certificate[] localCerts = loadCertificates(jarFile, je, readBuffer);
624                    if (DEBUG_JAR) {
625                        Slog.i(TAG, "File " + mArchiveSourcePath + " entry " + je.getName()
626                                + ": certs=" + certs + " ("
627                                + (certs != null ? certs.length : 0) + ")");
628                    }
629
630                    if (localCerts == null) {
631                        Slog.e(TAG, "Package " + pkg.packageName
632                                + " has no certificates at entry "
633                                + je.getName() + "; ignoring!");
634                        jarFile.close();
635                        mParseError = PackageManager.INSTALL_PARSE_FAILED_NO_CERTIFICATES;
636                        return false;
637                    } else if (certs == null) {
638                        certs = localCerts;
639                    } else {
640                        // Ensure all certificates match.
641                        for (int i=0; i<certs.length; i++) {
642                            boolean found = false;
643                            for (int j=0; j<localCerts.length; j++) {
644                                if (certs[i] != null &&
645                                        certs[i].equals(localCerts[j])) {
646                                    found = true;
647                                    break;
648                                }
649                            }
650                            if (!found || certs.length != localCerts.length) {
651                                Slog.e(TAG, "Package " + pkg.packageName
652                                        + " has mismatched certificates at entry "
653                                        + je.getName() + "; ignoring!");
654                                jarFile.close();
655                                mParseError = PackageManager.INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES;
656                                return false;
657                            }
658                        }
659                    }
660                }
661            }
662            jarFile.close();
663
664            synchronized (mSync) {
665                mReadBuffer = readBufferRef;
666            }
667
668            if (certs != null && certs.length > 0) {
669                final int N = certs.length;
670                pkg.mSignatures = new Signature[certs.length];
671                for (int i=0; i<N; i++) {
672                    pkg.mSignatures[i] = new Signature(
673                            certs[i].getEncoded());
674                }
675            } else {
676                Slog.e(TAG, "Package " + pkg.packageName
677                        + " has no certificates; ignoring!");
678                mParseError = PackageManager.INSTALL_PARSE_FAILED_NO_CERTIFICATES;
679                return false;
680            }
681        } catch (CertificateEncodingException e) {
682            Slog.w(TAG, "Exception reading " + mArchiveSourcePath, e);
683            mParseError = PackageManager.INSTALL_PARSE_FAILED_CERTIFICATE_ENCODING;
684            return false;
685        } catch (IOException e) {
686            Slog.w(TAG, "Exception reading " + mArchiveSourcePath, e);
687            mParseError = PackageManager.INSTALL_PARSE_FAILED_CERTIFICATE_ENCODING;
688            return false;
689        } catch (RuntimeException e) {
690            Slog.w(TAG, "Exception reading " + mArchiveSourcePath, e);
691            mParseError = PackageManager.INSTALL_PARSE_FAILED_UNEXPECTED_EXCEPTION;
692            return false;
693        }
694
695        return true;
696    }
697
698    /*
699     * Utility method that retrieves just the package name and install
700     * location from the apk location at the given file path.
701     * @param packageFilePath file location of the apk
702     * @param flags Special parse flags
703     * @return PackageLite object with package information or null on failure.
704     */
705    public static PackageLite parsePackageLite(String packageFilePath, int flags) {
706        AssetManager assmgr = null;
707        final XmlResourceParser parser;
708        final Resources res;
709        try {
710            assmgr = new AssetManager();
711            assmgr.setConfiguration(0, 0, null, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
712                    Build.VERSION.RESOURCES_SDK_INT);
713
714            int cookie = assmgr.addAssetPath(packageFilePath);
715            if (cookie == 0) {
716                return null;
717            }
718
719            final DisplayMetrics metrics = new DisplayMetrics();
720            metrics.setToDefaults();
721            res = new Resources(assmgr, metrics, null);
722            parser = assmgr.openXmlResourceParser(cookie, ANDROID_MANIFEST_FILENAME);
723        } catch (Exception e) {
724            if (assmgr != null) assmgr.close();
725            Slog.w(TAG, "Unable to read AndroidManifest.xml of "
726                    + packageFilePath, e);
727            return null;
728        }
729
730        final AttributeSet attrs = parser;
731        final String errors[] = new String[1];
732        PackageLite packageLite = null;
733        try {
734            packageLite = parsePackageLite(res, parser, attrs, flags, errors);
735        } catch (IOException e) {
736            Slog.w(TAG, packageFilePath, e);
737        } catch (XmlPullParserException e) {
738            Slog.w(TAG, packageFilePath, e);
739        } finally {
740            if (parser != null) parser.close();
741            if (assmgr != null) assmgr.close();
742        }
743        if (packageLite == null) {
744            Slog.e(TAG, "parsePackageLite error: " + errors[0]);
745            return null;
746        }
747        return packageLite;
748    }
749
750    private static String validateName(String name, boolean requiresSeparator) {
751        final int N = name.length();
752        boolean hasSep = false;
753        boolean front = true;
754        for (int i=0; i<N; i++) {
755            final char c = name.charAt(i);
756            if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
757                front = false;
758                continue;
759            }
760            if (!front) {
761                if ((c >= '0' && c <= '9') || c == '_') {
762                    continue;
763                }
764            }
765            if (c == '.') {
766                hasSep = true;
767                front = true;
768                continue;
769            }
770            return "bad character '" + c + "'";
771        }
772        return hasSep || !requiresSeparator
773                ? null : "must have at least one '.' separator";
774    }
775
776    private static String parsePackageName(XmlPullParser parser,
777            AttributeSet attrs, int flags, String[] outError)
778            throws IOException, XmlPullParserException {
779
780        int type;
781        while ((type = parser.next()) != XmlPullParser.START_TAG
782                && type != XmlPullParser.END_DOCUMENT) {
783            ;
784        }
785
786        if (type != XmlPullParser.START_TAG) {
787            outError[0] = "No start tag found";
788            return null;
789        }
790        if (DEBUG_PARSER)
791            Slog.v(TAG, "Root element name: '" + parser.getName() + "'");
792        if (!parser.getName().equals("manifest")) {
793            outError[0] = "No <manifest> tag";
794            return null;
795        }
796        String pkgName = attrs.getAttributeValue(null, "package");
797        if (pkgName == null || pkgName.length() == 0) {
798            outError[0] = "<manifest> does not specify package";
799            return null;
800        }
801        String nameError = validateName(pkgName, true);
802        if (nameError != null && !"android".equals(pkgName)) {
803            outError[0] = "<manifest> specifies bad package name \""
804                + pkgName + "\": " + nameError;
805            return null;
806        }
807
808        return pkgName.intern();
809    }
810
811    private static PackageLite parsePackageLite(Resources res, XmlPullParser parser,
812            AttributeSet attrs, int flags, String[] outError) throws IOException,
813            XmlPullParserException {
814
815        int type;
816        while ((type = parser.next()) != XmlPullParser.START_TAG
817                && type != XmlPullParser.END_DOCUMENT) {
818            ;
819        }
820
821        if (type != XmlPullParser.START_TAG) {
822            outError[0] = "No start tag found";
823            return null;
824        }
825        if (DEBUG_PARSER)
826            Slog.v(TAG, "Root element name: '" + parser.getName() + "'");
827        if (!parser.getName().equals("manifest")) {
828            outError[0] = "No <manifest> tag";
829            return null;
830        }
831        String pkgName = attrs.getAttributeValue(null, "package");
832        if (pkgName == null || pkgName.length() == 0) {
833            outError[0] = "<manifest> does not specify package";
834            return null;
835        }
836        String nameError = validateName(pkgName, true);
837        if (nameError != null && !"android".equals(pkgName)) {
838            outError[0] = "<manifest> specifies bad package name \""
839                + pkgName + "\": " + nameError;
840            return null;
841        }
842        int installLocation = PARSE_DEFAULT_INSTALL_LOCATION;
843        for (int i = 0; i < attrs.getAttributeCount(); i++) {
844            String attr = attrs.getAttributeName(i);
845            if (attr.equals("installLocation")) {
846                installLocation = attrs.getAttributeIntValue(i,
847                        PARSE_DEFAULT_INSTALL_LOCATION);
848                break;
849            }
850        }
851
852        // Only search the tree when the tag is directly below <manifest>
853        final int searchDepth = parser.getDepth() + 1;
854
855        final List<VerifierInfo> verifiers = new ArrayList<VerifierInfo>();
856        while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
857                && (type != XmlPullParser.END_TAG || parser.getDepth() >= searchDepth)) {
858            if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
859                continue;
860            }
861
862            if (parser.getDepth() == searchDepth && "package-verifier".equals(parser.getName())) {
863                final VerifierInfo verifier = parseVerifier(res, parser, attrs, flags, outError);
864                if (verifier != null) {
865                    verifiers.add(verifier);
866                }
867            }
868        }
869
870        return new PackageLite(pkgName.intern(), installLocation, verifiers);
871    }
872
873    /**
874     * Temporary.
875     */
876    static public Signature stringToSignature(String str) {
877        final int N = str.length();
878        byte[] sig = new byte[N];
879        for (int i=0; i<N; i++) {
880            sig[i] = (byte)str.charAt(i);
881        }
882        return new Signature(sig);
883    }
884
885    private Package parsePackage(
886        Resources res, XmlResourceParser parser, int flags, String[] outError)
887        throws XmlPullParserException, IOException {
888        AttributeSet attrs = parser;
889
890        mParseInstrumentationArgs = null;
891        mParseActivityArgs = null;
892        mParseServiceArgs = null;
893        mParseProviderArgs = null;
894
895        String pkgName = parsePackageName(parser, attrs, flags, outError);
896        if (pkgName == null) {
897            mParseError = PackageManager.INSTALL_PARSE_FAILED_BAD_PACKAGE_NAME;
898            return null;
899        }
900        int type;
901
902        if (mOnlyCoreApps) {
903            boolean core = attrs.getAttributeBooleanValue(null, "coreApp", false);
904            if (!core) {
905                mParseError = PackageManager.INSTALL_SUCCEEDED;
906                return null;
907            }
908        }
909
910        final Package pkg = new Package(pkgName);
911        boolean foundApp = false;
912
913        TypedArray sa = res.obtainAttributes(attrs,
914                com.android.internal.R.styleable.AndroidManifest);
915        pkg.mVersionCode = sa.getInteger(
916                com.android.internal.R.styleable.AndroidManifest_versionCode, 0);
917        pkg.mVersionName = sa.getNonConfigurationString(
918                com.android.internal.R.styleable.AndroidManifest_versionName, 0);
919        if (pkg.mVersionName != null) {
920            pkg.mVersionName = pkg.mVersionName.intern();
921        }
922        String str = sa.getNonConfigurationString(
923                com.android.internal.R.styleable.AndroidManifest_sharedUserId, 0);
924        if (str != null && str.length() > 0) {
925            String nameError = validateName(str, true);
926            if (nameError != null && !"android".equals(pkgName)) {
927                outError[0] = "<manifest> specifies bad sharedUserId name \""
928                    + str + "\": " + nameError;
929                mParseError = PackageManager.INSTALL_PARSE_FAILED_BAD_SHARED_USER_ID;
930                return null;
931            }
932            pkg.mSharedUserId = str.intern();
933            pkg.mSharedUserLabel = sa.getResourceId(
934                    com.android.internal.R.styleable.AndroidManifest_sharedUserLabel, 0);
935        }
936        sa.recycle();
937
938        pkg.installLocation = sa.getInteger(
939                com.android.internal.R.styleable.AndroidManifest_installLocation,
940                PARSE_DEFAULT_INSTALL_LOCATION);
941        pkg.applicationInfo.installLocation = pkg.installLocation;
942
943        /* Set the global "forward lock" flag */
944        if ((flags & PARSE_FORWARD_LOCK) != 0) {
945            pkg.applicationInfo.flags |= ApplicationInfo.FLAG_FORWARD_LOCK;
946        }
947
948        /* Set the global "on SD card" flag */
949        if ((flags & PARSE_ON_SDCARD) != 0) {
950            pkg.applicationInfo.flags |= ApplicationInfo.FLAG_EXTERNAL_STORAGE;
951        }
952
953        // Resource boolean are -1, so 1 means we don't know the value.
954        int supportsSmallScreens = 1;
955        int supportsNormalScreens = 1;
956        int supportsLargeScreens = 1;
957        int supportsXLargeScreens = 1;
958        int resizeable = 1;
959        int anyDensity = 1;
960
961        int outerDepth = parser.getDepth();
962        while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
963                && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) {
964            if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
965                continue;
966            }
967
968            String tagName = parser.getName();
969            if (tagName.equals("application")) {
970                if (foundApp) {
971                    if (RIGID_PARSER) {
972                        outError[0] = "<manifest> has more than one <application>";
973                        mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
974                        return null;
975                    } else {
976                        Slog.w(TAG, "<manifest> has more than one <application>");
977                        XmlUtils.skipCurrentTag(parser);
978                        continue;
979                    }
980                }
981
982                foundApp = true;
983                if (!parseApplication(pkg, res, parser, attrs, flags, outError)) {
984                    return null;
985                }
986            } else if (tagName.equals("permission-group")) {
987                if (parsePermissionGroup(pkg, flags, res, parser, attrs, outError) == null) {
988                    return null;
989                }
990            } else if (tagName.equals("permission")) {
991                if (parsePermission(pkg, res, parser, attrs, outError) == null) {
992                    return null;
993                }
994            } else if (tagName.equals("permission-tree")) {
995                if (parsePermissionTree(pkg, res, parser, attrs, outError) == null) {
996                    return null;
997                }
998            } else if (tagName.equals("uses-permission")) {
999                sa = res.obtainAttributes(attrs,
1000                        com.android.internal.R.styleable.AndroidManifestUsesPermission);
1001
1002                // Note: don't allow this value to be a reference to a resource
1003                // that may change.
1004                String name = sa.getNonResourceString(
1005                        com.android.internal.R.styleable.AndroidManifestUsesPermission_name);
1006                /* Not supporting optional permissions yet.
1007                boolean required = sa.getBoolean(
1008                        com.android.internal.R.styleable.AndroidManifestUsesPermission_required, true);
1009                */
1010
1011                sa.recycle();
1012
1013                if (name != null && !pkg.requestedPermissions.contains(name)) {
1014                    pkg.requestedPermissions.add(name.intern());
1015                    pkg.requestedPermissionsRequired.add(Boolean.TRUE);
1016                }
1017
1018                XmlUtils.skipCurrentTag(parser);
1019
1020            } else if (tagName.equals("uses-configuration")) {
1021                ConfigurationInfo cPref = new ConfigurationInfo();
1022                sa = res.obtainAttributes(attrs,
1023                        com.android.internal.R.styleable.AndroidManifestUsesConfiguration);
1024                cPref.reqTouchScreen = sa.getInt(
1025                        com.android.internal.R.styleable.AndroidManifestUsesConfiguration_reqTouchScreen,
1026                        Configuration.TOUCHSCREEN_UNDEFINED);
1027                cPref.reqKeyboardType = sa.getInt(
1028                        com.android.internal.R.styleable.AndroidManifestUsesConfiguration_reqKeyboardType,
1029                        Configuration.KEYBOARD_UNDEFINED);
1030                if (sa.getBoolean(
1031                        com.android.internal.R.styleable.AndroidManifestUsesConfiguration_reqHardKeyboard,
1032                        false)) {
1033                    cPref.reqInputFeatures |= ConfigurationInfo.INPUT_FEATURE_HARD_KEYBOARD;
1034                }
1035                cPref.reqNavigation = sa.getInt(
1036                        com.android.internal.R.styleable.AndroidManifestUsesConfiguration_reqNavigation,
1037                        Configuration.NAVIGATION_UNDEFINED);
1038                if (sa.getBoolean(
1039                        com.android.internal.R.styleable.AndroidManifestUsesConfiguration_reqFiveWayNav,
1040                        false)) {
1041                    cPref.reqInputFeatures |= ConfigurationInfo.INPUT_FEATURE_FIVE_WAY_NAV;
1042                }
1043                sa.recycle();
1044                pkg.configPreferences.add(cPref);
1045
1046                XmlUtils.skipCurrentTag(parser);
1047
1048            } else if (tagName.equals("uses-feature")) {
1049                FeatureInfo fi = new FeatureInfo();
1050                sa = res.obtainAttributes(attrs,
1051                        com.android.internal.R.styleable.AndroidManifestUsesFeature);
1052                // Note: don't allow this value to be a reference to a resource
1053                // that may change.
1054                fi.name = sa.getNonResourceString(
1055                        com.android.internal.R.styleable.AndroidManifestUsesFeature_name);
1056                if (fi.name == null) {
1057                    fi.reqGlEsVersion = sa.getInt(
1058                            com.android.internal.R.styleable.AndroidManifestUsesFeature_glEsVersion,
1059                            FeatureInfo.GL_ES_VERSION_UNDEFINED);
1060                }
1061                if (sa.getBoolean(
1062                        com.android.internal.R.styleable.AndroidManifestUsesFeature_required,
1063                        true)) {
1064                    fi.flags |= FeatureInfo.FLAG_REQUIRED;
1065                }
1066                sa.recycle();
1067                if (pkg.reqFeatures == null) {
1068                    pkg.reqFeatures = new ArrayList<FeatureInfo>();
1069                }
1070                pkg.reqFeatures.add(fi);
1071
1072                if (fi.name == null) {
1073                    ConfigurationInfo cPref = new ConfigurationInfo();
1074                    cPref.reqGlEsVersion = fi.reqGlEsVersion;
1075                    pkg.configPreferences.add(cPref);
1076                }
1077
1078                XmlUtils.skipCurrentTag(parser);
1079
1080            } else if (tagName.equals("uses-sdk")) {
1081                if (SDK_VERSION > 0) {
1082                    sa = res.obtainAttributes(attrs,
1083                            com.android.internal.R.styleable.AndroidManifestUsesSdk);
1084
1085                    int minVers = 0;
1086                    String minCode = null;
1087                    int targetVers = 0;
1088                    String targetCode = null;
1089
1090                    TypedValue val = sa.peekValue(
1091                            com.android.internal.R.styleable.AndroidManifestUsesSdk_minSdkVersion);
1092                    if (val != null) {
1093                        if (val.type == TypedValue.TYPE_STRING && val.string != null) {
1094                            targetCode = minCode = val.string.toString();
1095                        } else {
1096                            // If it's not a string, it's an integer.
1097                            targetVers = minVers = val.data;
1098                        }
1099                    }
1100
1101                    val = sa.peekValue(
1102                            com.android.internal.R.styleable.AndroidManifestUsesSdk_targetSdkVersion);
1103                    if (val != null) {
1104                        if (val.type == TypedValue.TYPE_STRING && val.string != null) {
1105                            targetCode = minCode = val.string.toString();
1106                        } else {
1107                            // If it's not a string, it's an integer.
1108                            targetVers = val.data;
1109                        }
1110                    }
1111
1112                    sa.recycle();
1113
1114                    if (minCode != null) {
1115                        if (!minCode.equals(SDK_CODENAME)) {
1116                            if (SDK_CODENAME != null) {
1117                                outError[0] = "Requires development platform " + minCode
1118                                        + " (current platform is " + SDK_CODENAME + ")";
1119                            } else {
1120                                outError[0] = "Requires development platform " + minCode
1121                                        + " but this is a release platform.";
1122                            }
1123                            mParseError = PackageManager.INSTALL_FAILED_OLDER_SDK;
1124                            return null;
1125                        }
1126                    } else if (minVers > SDK_VERSION) {
1127                        outError[0] = "Requires newer sdk version #" + minVers
1128                                + " (current version is #" + SDK_VERSION + ")";
1129                        mParseError = PackageManager.INSTALL_FAILED_OLDER_SDK;
1130                        return null;
1131                    }
1132
1133                    if (targetCode != null) {
1134                        if (!targetCode.equals(SDK_CODENAME)) {
1135                            if (SDK_CODENAME != null) {
1136                                outError[0] = "Requires development platform " + targetCode
1137                                        + " (current platform is " + SDK_CODENAME + ")";
1138                            } else {
1139                                outError[0] = "Requires development platform " + targetCode
1140                                        + " but this is a release platform.";
1141                            }
1142                            mParseError = PackageManager.INSTALL_FAILED_OLDER_SDK;
1143                            return null;
1144                        }
1145                        // If the code matches, it definitely targets this SDK.
1146                        pkg.applicationInfo.targetSdkVersion
1147                                = android.os.Build.VERSION_CODES.CUR_DEVELOPMENT;
1148                    } else {
1149                        pkg.applicationInfo.targetSdkVersion = targetVers;
1150                    }
1151                }
1152
1153                XmlUtils.skipCurrentTag(parser);
1154
1155            } else if (tagName.equals("supports-screens")) {
1156                sa = res.obtainAttributes(attrs,
1157                        com.android.internal.R.styleable.AndroidManifestSupportsScreens);
1158
1159                pkg.applicationInfo.requiresSmallestWidthDp = sa.getInteger(
1160                        com.android.internal.R.styleable.AndroidManifestSupportsScreens_requiresSmallestWidthDp,
1161                        0);
1162                pkg.applicationInfo.compatibleWidthLimitDp = sa.getInteger(
1163                        com.android.internal.R.styleable.AndroidManifestSupportsScreens_compatibleWidthLimitDp,
1164                        0);
1165                pkg.applicationInfo.largestWidthLimitDp = sa.getInteger(
1166                        com.android.internal.R.styleable.AndroidManifestSupportsScreens_largestWidthLimitDp,
1167                        0);
1168
1169                // This is a trick to get a boolean and still able to detect
1170                // if a value was actually set.
1171                supportsSmallScreens = sa.getInteger(
1172                        com.android.internal.R.styleable.AndroidManifestSupportsScreens_smallScreens,
1173                        supportsSmallScreens);
1174                supportsNormalScreens = sa.getInteger(
1175                        com.android.internal.R.styleable.AndroidManifestSupportsScreens_normalScreens,
1176                        supportsNormalScreens);
1177                supportsLargeScreens = sa.getInteger(
1178                        com.android.internal.R.styleable.AndroidManifestSupportsScreens_largeScreens,
1179                        supportsLargeScreens);
1180                supportsXLargeScreens = sa.getInteger(
1181                        com.android.internal.R.styleable.AndroidManifestSupportsScreens_xlargeScreens,
1182                        supportsXLargeScreens);
1183                resizeable = sa.getInteger(
1184                        com.android.internal.R.styleable.AndroidManifestSupportsScreens_resizeable,
1185                        resizeable);
1186                anyDensity = sa.getInteger(
1187                        com.android.internal.R.styleable.AndroidManifestSupportsScreens_anyDensity,
1188                        anyDensity);
1189
1190                sa.recycle();
1191
1192                XmlUtils.skipCurrentTag(parser);
1193
1194            } else if (tagName.equals("protected-broadcast")) {
1195                sa = res.obtainAttributes(attrs,
1196                        com.android.internal.R.styleable.AndroidManifestProtectedBroadcast);
1197
1198                // Note: don't allow this value to be a reference to a resource
1199                // that may change.
1200                String name = sa.getNonResourceString(
1201                        com.android.internal.R.styleable.AndroidManifestProtectedBroadcast_name);
1202
1203                sa.recycle();
1204
1205                if (name != null && (flags&PARSE_IS_SYSTEM) != 0) {
1206                    if (pkg.protectedBroadcasts == null) {
1207                        pkg.protectedBroadcasts = new ArrayList<String>();
1208                    }
1209                    if (!pkg.protectedBroadcasts.contains(name)) {
1210                        pkg.protectedBroadcasts.add(name.intern());
1211                    }
1212                }
1213
1214                XmlUtils.skipCurrentTag(parser);
1215
1216            } else if (tagName.equals("instrumentation")) {
1217                if (parseInstrumentation(pkg, res, parser, attrs, outError) == null) {
1218                    return null;
1219                }
1220
1221            } else if (tagName.equals("original-package")) {
1222                sa = res.obtainAttributes(attrs,
1223                        com.android.internal.R.styleable.AndroidManifestOriginalPackage);
1224
1225                String orig =sa.getNonConfigurationString(
1226                        com.android.internal.R.styleable.AndroidManifestOriginalPackage_name, 0);
1227                if (!pkg.packageName.equals(orig)) {
1228                    if (pkg.mOriginalPackages == null) {
1229                        pkg.mOriginalPackages = new ArrayList<String>();
1230                        pkg.mRealPackage = pkg.packageName;
1231                    }
1232                    pkg.mOriginalPackages.add(orig);
1233                }
1234
1235                sa.recycle();
1236
1237                XmlUtils.skipCurrentTag(parser);
1238
1239            } else if (tagName.equals("adopt-permissions")) {
1240                sa = res.obtainAttributes(attrs,
1241                        com.android.internal.R.styleable.AndroidManifestOriginalPackage);
1242
1243                String name = sa.getNonConfigurationString(
1244                        com.android.internal.R.styleable.AndroidManifestOriginalPackage_name, 0);
1245
1246                sa.recycle();
1247
1248                if (name != null) {
1249                    if (pkg.mAdoptPermissions == null) {
1250                        pkg.mAdoptPermissions = new ArrayList<String>();
1251                    }
1252                    pkg.mAdoptPermissions.add(name);
1253                }
1254
1255                XmlUtils.skipCurrentTag(parser);
1256
1257            } else if (tagName.equals("uses-gl-texture")) {
1258                // Just skip this tag
1259                XmlUtils.skipCurrentTag(parser);
1260                continue;
1261
1262            } else if (tagName.equals("compatible-screens")) {
1263                // Just skip this tag
1264                XmlUtils.skipCurrentTag(parser);
1265                continue;
1266
1267            } else if (tagName.equals("eat-comment")) {
1268                // Just skip this tag
1269                XmlUtils.skipCurrentTag(parser);
1270                continue;
1271
1272            } else if (RIGID_PARSER) {
1273                outError[0] = "Bad element under <manifest>: "
1274                    + parser.getName();
1275                mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
1276                return null;
1277
1278            } else {
1279                Slog.w(TAG, "Unknown element under <manifest>: " + parser.getName()
1280                        + " at " + mArchiveSourcePath + " "
1281                        + parser.getPositionDescription());
1282                XmlUtils.skipCurrentTag(parser);
1283                continue;
1284            }
1285        }
1286
1287        if (!foundApp && pkg.instrumentation.size() == 0) {
1288            outError[0] = "<manifest> does not contain an <application> or <instrumentation>";
1289            mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_EMPTY;
1290        }
1291
1292        final int NP = PackageParser.NEW_PERMISSIONS.length;
1293        StringBuilder implicitPerms = null;
1294        for (int ip=0; ip<NP; ip++) {
1295            final PackageParser.NewPermissionInfo npi
1296                    = PackageParser.NEW_PERMISSIONS[ip];
1297            if (pkg.applicationInfo.targetSdkVersion >= npi.sdkVersion) {
1298                break;
1299            }
1300            if (!pkg.requestedPermissions.contains(npi.name)) {
1301                if (implicitPerms == null) {
1302                    implicitPerms = new StringBuilder(128);
1303                    implicitPerms.append(pkg.packageName);
1304                    implicitPerms.append(": compat added ");
1305                } else {
1306                    implicitPerms.append(' ');
1307                }
1308                implicitPerms.append(npi.name);
1309                pkg.requestedPermissions.add(npi.name);
1310                pkg.requestedPermissionsRequired.add(Boolean.TRUE);
1311            }
1312        }
1313        if (implicitPerms != null) {
1314            Slog.i(TAG, implicitPerms.toString());
1315        }
1316
1317        final int NS = PackageParser.SPLIT_PERMISSIONS.length;
1318        for (int is=0; is<NS; is++) {
1319            final PackageParser.SplitPermissionInfo spi
1320                    = PackageParser.SPLIT_PERMISSIONS[is];
1321            if (pkg.applicationInfo.targetSdkVersion >= spi.targetSdk
1322                    || !pkg.requestedPermissions.contains(spi.rootPerm)) {
1323                continue;
1324            }
1325            for (int in=0; in<spi.newPerms.length; in++) {
1326                final String perm = spi.newPerms[in];
1327                if (!pkg.requestedPermissions.contains(perm)) {
1328                    pkg.requestedPermissions.add(perm);
1329                    pkg.requestedPermissionsRequired.add(Boolean.TRUE);
1330                }
1331            }
1332        }
1333
1334        if (supportsSmallScreens < 0 || (supportsSmallScreens > 0
1335                && pkg.applicationInfo.targetSdkVersion
1336                        >= android.os.Build.VERSION_CODES.DONUT)) {
1337            pkg.applicationInfo.flags |= ApplicationInfo.FLAG_SUPPORTS_SMALL_SCREENS;
1338        }
1339        if (supportsNormalScreens != 0) {
1340            pkg.applicationInfo.flags |= ApplicationInfo.FLAG_SUPPORTS_NORMAL_SCREENS;
1341        }
1342        if (supportsLargeScreens < 0 || (supportsLargeScreens > 0
1343                && pkg.applicationInfo.targetSdkVersion
1344                        >= android.os.Build.VERSION_CODES.DONUT)) {
1345            pkg.applicationInfo.flags |= ApplicationInfo.FLAG_SUPPORTS_LARGE_SCREENS;
1346        }
1347        if (supportsXLargeScreens < 0 || (supportsXLargeScreens > 0
1348                && pkg.applicationInfo.targetSdkVersion
1349                        >= android.os.Build.VERSION_CODES.GINGERBREAD)) {
1350            pkg.applicationInfo.flags |= ApplicationInfo.FLAG_SUPPORTS_XLARGE_SCREENS;
1351        }
1352        if (resizeable < 0 || (resizeable > 0
1353                && pkg.applicationInfo.targetSdkVersion
1354                        >= android.os.Build.VERSION_CODES.DONUT)) {
1355            pkg.applicationInfo.flags |= ApplicationInfo.FLAG_RESIZEABLE_FOR_SCREENS;
1356        }
1357        if (anyDensity < 0 || (anyDensity > 0
1358                && pkg.applicationInfo.targetSdkVersion
1359                        >= android.os.Build.VERSION_CODES.DONUT)) {
1360            pkg.applicationInfo.flags |= ApplicationInfo.FLAG_SUPPORTS_SCREEN_DENSITIES;
1361        }
1362
1363        return pkg;
1364    }
1365
1366    private static String buildClassName(String pkg, CharSequence clsSeq,
1367            String[] outError) {
1368        if (clsSeq == null || clsSeq.length() <= 0) {
1369            outError[0] = "Empty class name in package " + pkg;
1370            return null;
1371        }
1372        String cls = clsSeq.toString();
1373        char c = cls.charAt(0);
1374        if (c == '.') {
1375            return (pkg + cls).intern();
1376        }
1377        if (cls.indexOf('.') < 0) {
1378            StringBuilder b = new StringBuilder(pkg);
1379            b.append('.');
1380            b.append(cls);
1381            return b.toString().intern();
1382        }
1383        if (c >= 'a' && c <= 'z') {
1384            return cls.intern();
1385        }
1386        outError[0] = "Bad class name " + cls + " in package " + pkg;
1387        return null;
1388    }
1389
1390    private static String buildCompoundName(String pkg,
1391            CharSequence procSeq, String type, String[] outError) {
1392        String proc = procSeq.toString();
1393        char c = proc.charAt(0);
1394        if (pkg != null && c == ':') {
1395            if (proc.length() < 2) {
1396                outError[0] = "Bad " + type + " name " + proc + " in package " + pkg
1397                        + ": must be at least two characters";
1398                return null;
1399            }
1400            String subName = proc.substring(1);
1401            String nameError = validateName(subName, false);
1402            if (nameError != null) {
1403                outError[0] = "Invalid " + type + " name " + proc + " in package "
1404                        + pkg + ": " + nameError;
1405                return null;
1406            }
1407            return (pkg + proc).intern();
1408        }
1409        String nameError = validateName(proc, true);
1410        if (nameError != null && !"system".equals(proc)) {
1411            outError[0] = "Invalid " + type + " name " + proc + " in package "
1412                    + pkg + ": " + nameError;
1413            return null;
1414        }
1415        return proc.intern();
1416    }
1417
1418    private static String buildProcessName(String pkg, String defProc,
1419            CharSequence procSeq, int flags, String[] separateProcesses,
1420            String[] outError) {
1421        if ((flags&PARSE_IGNORE_PROCESSES) != 0 && !"system".equals(procSeq)) {
1422            return defProc != null ? defProc : pkg;
1423        }
1424        if (separateProcesses != null) {
1425            for (int i=separateProcesses.length-1; i>=0; i--) {
1426                String sp = separateProcesses[i];
1427                if (sp.equals(pkg) || sp.equals(defProc) || sp.equals(procSeq)) {
1428                    return pkg;
1429                }
1430            }
1431        }
1432        if (procSeq == null || procSeq.length() <= 0) {
1433            return defProc;
1434        }
1435        return buildCompoundName(pkg, procSeq, "process", outError);
1436    }
1437
1438    private static String buildTaskAffinityName(String pkg, String defProc,
1439            CharSequence procSeq, String[] outError) {
1440        if (procSeq == null) {
1441            return defProc;
1442        }
1443        if (procSeq.length() <= 0) {
1444            return null;
1445        }
1446        return buildCompoundName(pkg, procSeq, "taskAffinity", outError);
1447    }
1448
1449    private PermissionGroup parsePermissionGroup(Package owner, int flags, Resources res,
1450            XmlPullParser parser, AttributeSet attrs, String[] outError)
1451        throws XmlPullParserException, IOException {
1452        PermissionGroup perm = new PermissionGroup(owner);
1453
1454        TypedArray sa = res.obtainAttributes(attrs,
1455                com.android.internal.R.styleable.AndroidManifestPermissionGroup);
1456
1457        if (!parsePackageItemInfo(owner, perm.info, outError,
1458                "<permission-group>", sa,
1459                com.android.internal.R.styleable.AndroidManifestPermissionGroup_name,
1460                com.android.internal.R.styleable.AndroidManifestPermissionGroup_label,
1461                com.android.internal.R.styleable.AndroidManifestPermissionGroup_icon,
1462                com.android.internal.R.styleable.AndroidManifestPermissionGroup_logo)) {
1463            sa.recycle();
1464            mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
1465            return null;
1466        }
1467
1468        perm.info.descriptionRes = sa.getResourceId(
1469                com.android.internal.R.styleable.AndroidManifestPermissionGroup_description,
1470                0);
1471        perm.info.flags = 0;
1472        perm.info.priority = sa.getInt(
1473                com.android.internal.R.styleable.AndroidManifestPermissionGroup_priority, 0);
1474        if (perm.info.priority > 0 && (flags&PARSE_IS_SYSTEM) == 0) {
1475            perm.info.priority = 0;
1476        }
1477
1478        sa.recycle();
1479
1480        if (!parseAllMetaData(res, parser, attrs, "<permission-group>", perm,
1481                outError)) {
1482            mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
1483            return null;
1484        }
1485
1486        owner.permissionGroups.add(perm);
1487
1488        return perm;
1489    }
1490
1491    private Permission parsePermission(Package owner, Resources res,
1492            XmlPullParser parser, AttributeSet attrs, String[] outError)
1493        throws XmlPullParserException, IOException {
1494        Permission perm = new Permission(owner);
1495
1496        TypedArray sa = res.obtainAttributes(attrs,
1497                com.android.internal.R.styleable.AndroidManifestPermission);
1498
1499        if (!parsePackageItemInfo(owner, perm.info, outError,
1500                "<permission>", sa,
1501                com.android.internal.R.styleable.AndroidManifestPermission_name,
1502                com.android.internal.R.styleable.AndroidManifestPermission_label,
1503                com.android.internal.R.styleable.AndroidManifestPermission_icon,
1504                com.android.internal.R.styleable.AndroidManifestPermission_logo)) {
1505            sa.recycle();
1506            mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
1507            return null;
1508        }
1509
1510        // Note: don't allow this value to be a reference to a resource
1511        // that may change.
1512        perm.info.group = sa.getNonResourceString(
1513                com.android.internal.R.styleable.AndroidManifestPermission_permissionGroup);
1514        if (perm.info.group != null) {
1515            perm.info.group = perm.info.group.intern();
1516        }
1517
1518        perm.info.descriptionRes = sa.getResourceId(
1519                com.android.internal.R.styleable.AndroidManifestPermission_description,
1520                0);
1521
1522        perm.info.protectionLevel = sa.getInt(
1523                com.android.internal.R.styleable.AndroidManifestPermission_protectionLevel,
1524                PermissionInfo.PROTECTION_NORMAL);
1525
1526        sa.recycle();
1527
1528        if (perm.info.protectionLevel == -1) {
1529            outError[0] = "<permission> does not specify protectionLevel";
1530            mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
1531            return null;
1532        }
1533
1534        perm.info.protectionLevel = PermissionInfo.fixProtectionLevel(perm.info.protectionLevel);
1535
1536        if ((perm.info.protectionLevel&PermissionInfo.PROTECTION_MASK_FLAGS) != 0) {
1537            if ((perm.info.protectionLevel&PermissionInfo.PROTECTION_MASK_BASE) !=
1538                    PermissionInfo.PROTECTION_SIGNATURE) {
1539                outError[0] = "<permission>  protectionLevel specifies a flag but is "
1540                        + "not based on signature type";
1541                mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
1542                return null;
1543            }
1544        }
1545
1546        if (!parseAllMetaData(res, parser, attrs, "<permission>", perm,
1547                outError)) {
1548            mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
1549            return null;
1550        }
1551
1552        owner.permissions.add(perm);
1553
1554        return perm;
1555    }
1556
1557    private Permission parsePermissionTree(Package owner, Resources res,
1558            XmlPullParser parser, AttributeSet attrs, String[] outError)
1559        throws XmlPullParserException, IOException {
1560        Permission perm = new Permission(owner);
1561
1562        TypedArray sa = res.obtainAttributes(attrs,
1563                com.android.internal.R.styleable.AndroidManifestPermissionTree);
1564
1565        if (!parsePackageItemInfo(owner, perm.info, outError,
1566                "<permission-tree>", sa,
1567                com.android.internal.R.styleable.AndroidManifestPermissionTree_name,
1568                com.android.internal.R.styleable.AndroidManifestPermissionTree_label,
1569                com.android.internal.R.styleable.AndroidManifestPermissionTree_icon,
1570                com.android.internal.R.styleable.AndroidManifestPermissionTree_logo)) {
1571            sa.recycle();
1572            mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
1573            return null;
1574        }
1575
1576        sa.recycle();
1577
1578        int index = perm.info.name.indexOf('.');
1579        if (index > 0) {
1580            index = perm.info.name.indexOf('.', index+1);
1581        }
1582        if (index < 0) {
1583            outError[0] = "<permission-tree> name has less than three segments: "
1584                + perm.info.name;
1585            mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
1586            return null;
1587        }
1588
1589        perm.info.descriptionRes = 0;
1590        perm.info.protectionLevel = PermissionInfo.PROTECTION_NORMAL;
1591        perm.tree = true;
1592
1593        if (!parseAllMetaData(res, parser, attrs, "<permission-tree>", perm,
1594                outError)) {
1595            mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
1596            return null;
1597        }
1598
1599        owner.permissions.add(perm);
1600
1601        return perm;
1602    }
1603
1604    private Instrumentation parseInstrumentation(Package owner, Resources res,
1605            XmlPullParser parser, AttributeSet attrs, String[] outError)
1606        throws XmlPullParserException, IOException {
1607        TypedArray sa = res.obtainAttributes(attrs,
1608                com.android.internal.R.styleable.AndroidManifestInstrumentation);
1609
1610        if (mParseInstrumentationArgs == null) {
1611            mParseInstrumentationArgs = new ParsePackageItemArgs(owner, outError,
1612                    com.android.internal.R.styleable.AndroidManifestInstrumentation_name,
1613                    com.android.internal.R.styleable.AndroidManifestInstrumentation_label,
1614                    com.android.internal.R.styleable.AndroidManifestInstrumentation_icon,
1615                    com.android.internal.R.styleable.AndroidManifestInstrumentation_logo);
1616            mParseInstrumentationArgs.tag = "<instrumentation>";
1617        }
1618
1619        mParseInstrumentationArgs.sa = sa;
1620
1621        Instrumentation a = new Instrumentation(mParseInstrumentationArgs,
1622                new InstrumentationInfo());
1623        if (outError[0] != null) {
1624            sa.recycle();
1625            mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
1626            return null;
1627        }
1628
1629        String str;
1630        // Note: don't allow this value to be a reference to a resource
1631        // that may change.
1632        str = sa.getNonResourceString(
1633                com.android.internal.R.styleable.AndroidManifestInstrumentation_targetPackage);
1634        a.info.targetPackage = str != null ? str.intern() : null;
1635
1636        a.info.handleProfiling = sa.getBoolean(
1637                com.android.internal.R.styleable.AndroidManifestInstrumentation_handleProfiling,
1638                false);
1639
1640        a.info.functionalTest = sa.getBoolean(
1641                com.android.internal.R.styleable.AndroidManifestInstrumentation_functionalTest,
1642                false);
1643
1644        sa.recycle();
1645
1646        if (a.info.targetPackage == null) {
1647            outError[0] = "<instrumentation> does not specify targetPackage";
1648            mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
1649            return null;
1650        }
1651
1652        if (!parseAllMetaData(res, parser, attrs, "<instrumentation>", a,
1653                outError)) {
1654            mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
1655            return null;
1656        }
1657
1658        owner.instrumentation.add(a);
1659
1660        return a;
1661    }
1662
1663    private boolean parseApplication(Package owner, Resources res,
1664            XmlPullParser parser, AttributeSet attrs, int flags, String[] outError)
1665        throws XmlPullParserException, IOException {
1666        final ApplicationInfo ai = owner.applicationInfo;
1667        final String pkgName = owner.applicationInfo.packageName;
1668
1669        TypedArray sa = res.obtainAttributes(attrs,
1670                com.android.internal.R.styleable.AndroidManifestApplication);
1671
1672        String name = sa.getNonConfigurationString(
1673                com.android.internal.R.styleable.AndroidManifestApplication_name, 0);
1674        if (name != null) {
1675            ai.className = buildClassName(pkgName, name, outError);
1676            if (ai.className == null) {
1677                sa.recycle();
1678                mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
1679                return false;
1680            }
1681        }
1682
1683        String manageSpaceActivity = sa.getNonConfigurationString(
1684                com.android.internal.R.styleable.AndroidManifestApplication_manageSpaceActivity, 0);
1685        if (manageSpaceActivity != null) {
1686            ai.manageSpaceActivityName = buildClassName(pkgName, manageSpaceActivity,
1687                    outError);
1688        }
1689
1690        boolean allowBackup = sa.getBoolean(
1691                com.android.internal.R.styleable.AndroidManifestApplication_allowBackup, true);
1692        if (allowBackup) {
1693            ai.flags |= ApplicationInfo.FLAG_ALLOW_BACKUP;
1694
1695            // backupAgent, killAfterRestore, and restoreAnyVersion are only relevant
1696            // if backup is possible for the given application.
1697            String backupAgent = sa.getNonConfigurationString(
1698                    com.android.internal.R.styleable.AndroidManifestApplication_backupAgent, 0);
1699            if (backupAgent != null) {
1700                ai.backupAgentName = buildClassName(pkgName, backupAgent, outError);
1701                if (DEBUG_BACKUP) {
1702                    Slog.v(TAG, "android:backupAgent = " + ai.backupAgentName
1703                            + " from " + pkgName + "+" + backupAgent);
1704                }
1705
1706                if (sa.getBoolean(
1707                        com.android.internal.R.styleable.AndroidManifestApplication_killAfterRestore,
1708                        true)) {
1709                    ai.flags |= ApplicationInfo.FLAG_KILL_AFTER_RESTORE;
1710                }
1711                if (sa.getBoolean(
1712                        com.android.internal.R.styleable.AndroidManifestApplication_restoreAnyVersion,
1713                        false)) {
1714                    ai.flags |= ApplicationInfo.FLAG_RESTORE_ANY_VERSION;
1715                }
1716            }
1717        }
1718
1719        TypedValue v = sa.peekValue(
1720                com.android.internal.R.styleable.AndroidManifestApplication_label);
1721        if (v != null && (ai.labelRes=v.resourceId) == 0) {
1722            ai.nonLocalizedLabel = v.coerceToString();
1723        }
1724
1725        ai.icon = sa.getResourceId(
1726                com.android.internal.R.styleable.AndroidManifestApplication_icon, 0);
1727        ai.logo = sa.getResourceId(
1728                com.android.internal.R.styleable.AndroidManifestApplication_logo, 0);
1729        ai.theme = sa.getResourceId(
1730                com.android.internal.R.styleable.AndroidManifestApplication_theme, 0);
1731        ai.descriptionRes = sa.getResourceId(
1732                com.android.internal.R.styleable.AndroidManifestApplication_description, 0);
1733
1734        if ((flags&PARSE_IS_SYSTEM) != 0) {
1735            if (sa.getBoolean(
1736                    com.android.internal.R.styleable.AndroidManifestApplication_persistent,
1737                    false)) {
1738                ai.flags |= ApplicationInfo.FLAG_PERSISTENT;
1739            }
1740        }
1741
1742        if (sa.getBoolean(
1743                com.android.internal.R.styleable.AndroidManifestApplication_debuggable,
1744                false)) {
1745            ai.flags |= ApplicationInfo.FLAG_DEBUGGABLE;
1746        }
1747
1748        if (sa.getBoolean(
1749                com.android.internal.R.styleable.AndroidManifestApplication_vmSafeMode,
1750                false)) {
1751            ai.flags |= ApplicationInfo.FLAG_VM_SAFE_MODE;
1752        }
1753
1754        boolean hardwareAccelerated = sa.getBoolean(
1755                com.android.internal.R.styleable.AndroidManifestApplication_hardwareAccelerated,
1756                owner.applicationInfo.targetSdkVersion >= Build.VERSION_CODES.ICE_CREAM_SANDWICH);
1757
1758        if (sa.getBoolean(
1759                com.android.internal.R.styleable.AndroidManifestApplication_hasCode,
1760                true)) {
1761            ai.flags |= ApplicationInfo.FLAG_HAS_CODE;
1762        }
1763
1764        if (sa.getBoolean(
1765                com.android.internal.R.styleable.AndroidManifestApplication_allowTaskReparenting,
1766                false)) {
1767            ai.flags |= ApplicationInfo.FLAG_ALLOW_TASK_REPARENTING;
1768        }
1769
1770        if (sa.getBoolean(
1771                com.android.internal.R.styleable.AndroidManifestApplication_allowClearUserData,
1772                true)) {
1773            ai.flags |= ApplicationInfo.FLAG_ALLOW_CLEAR_USER_DATA;
1774        }
1775
1776        if (sa.getBoolean(
1777                com.android.internal.R.styleable.AndroidManifestApplication_testOnly,
1778                false)) {
1779            ai.flags |= ApplicationInfo.FLAG_TEST_ONLY;
1780        }
1781
1782        if (sa.getBoolean(
1783                com.android.internal.R.styleable.AndroidManifestApplication_largeHeap,
1784                false)) {
1785            ai.flags |= ApplicationInfo.FLAG_LARGE_HEAP;
1786        }
1787
1788        if (sa.getBoolean(
1789                com.android.internal.R.styleable.AndroidManifestApplication_supportsRtl,
1790                false /* default is no RTL support*/)) {
1791            ai.flags |= ApplicationInfo.FLAG_SUPPORTS_RTL;
1792        }
1793
1794        String str;
1795        str = sa.getNonConfigurationString(
1796                com.android.internal.R.styleable.AndroidManifestApplication_permission, 0);
1797        ai.permission = (str != null && str.length() > 0) ? str.intern() : null;
1798
1799        if (owner.applicationInfo.targetSdkVersion >= Build.VERSION_CODES.FROYO) {
1800            str = sa.getNonConfigurationString(
1801                    com.android.internal.R.styleable.AndroidManifestApplication_taskAffinity, 0);
1802        } else {
1803            // Some older apps have been seen to use a resource reference
1804            // here that on older builds was ignored (with a warning).  We
1805            // need to continue to do this for them so they don't break.
1806            str = sa.getNonResourceString(
1807                    com.android.internal.R.styleable.AndroidManifestApplication_taskAffinity);
1808        }
1809        ai.taskAffinity = buildTaskAffinityName(ai.packageName, ai.packageName,
1810                str, outError);
1811
1812        if (outError[0] == null) {
1813            CharSequence pname;
1814            if (owner.applicationInfo.targetSdkVersion >= Build.VERSION_CODES.FROYO) {
1815                pname = sa.getNonConfigurationString(
1816                        com.android.internal.R.styleable.AndroidManifestApplication_process, 0);
1817            } else {
1818                // Some older apps have been seen to use a resource reference
1819                // here that on older builds was ignored (with a warning).  We
1820                // need to continue to do this for them so they don't break.
1821                pname = sa.getNonResourceString(
1822                        com.android.internal.R.styleable.AndroidManifestApplication_process);
1823            }
1824            ai.processName = buildProcessName(ai.packageName, null, pname,
1825                    flags, mSeparateProcesses, outError);
1826
1827            ai.enabled = sa.getBoolean(
1828                    com.android.internal.R.styleable.AndroidManifestApplication_enabled, true);
1829
1830            if (false) {
1831                if (sa.getBoolean(
1832                        com.android.internal.R.styleable.AndroidManifestApplication_cantSaveState,
1833                        false)) {
1834                    ai.flags |= ApplicationInfo.FLAG_CANT_SAVE_STATE;
1835
1836                    // A heavy-weight application can not be in a custom process.
1837                    // We can do direct compare because we intern all strings.
1838                    if (ai.processName != null && ai.processName != ai.packageName) {
1839                        outError[0] = "cantSaveState applications can not use custom processes";
1840                    }
1841                }
1842            }
1843        }
1844
1845        ai.uiOptions = sa.getInt(
1846                com.android.internal.R.styleable.AndroidManifestApplication_uiOptions, 0);
1847
1848        sa.recycle();
1849
1850        if (outError[0] != null) {
1851            mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
1852            return false;
1853        }
1854
1855        final int innerDepth = parser.getDepth();
1856
1857        int type;
1858        while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
1859                && (type != XmlPullParser.END_TAG || parser.getDepth() > innerDepth)) {
1860            if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
1861                continue;
1862            }
1863
1864            String tagName = parser.getName();
1865            if (tagName.equals("activity")) {
1866                Activity a = parseActivity(owner, res, parser, attrs, flags, outError, false,
1867                        hardwareAccelerated);
1868                if (a == null) {
1869                    mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
1870                    return false;
1871                }
1872
1873                owner.activities.add(a);
1874
1875            } else if (tagName.equals("receiver")) {
1876                Activity a = parseActivity(owner, res, parser, attrs, flags, outError, true, false);
1877                if (a == null) {
1878                    mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
1879                    return false;
1880                }
1881
1882                owner.receivers.add(a);
1883
1884            } else if (tagName.equals("service")) {
1885                Service s = parseService(owner, res, parser, attrs, flags, outError);
1886                if (s == null) {
1887                    mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
1888                    return false;
1889                }
1890
1891                owner.services.add(s);
1892
1893            } else if (tagName.equals("provider")) {
1894                Provider p = parseProvider(owner, res, parser, attrs, flags, outError);
1895                if (p == null) {
1896                    mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
1897                    return false;
1898                }
1899
1900                owner.providers.add(p);
1901
1902            } else if (tagName.equals("activity-alias")) {
1903                Activity a = parseActivityAlias(owner, res, parser, attrs, flags, outError);
1904                if (a == null) {
1905                    mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
1906                    return false;
1907                }
1908
1909                owner.activities.add(a);
1910
1911            } else if (parser.getName().equals("meta-data")) {
1912                // note: application meta-data is stored off to the side, so it can
1913                // remain null in the primary copy (we like to avoid extra copies because
1914                // it can be large)
1915                if ((owner.mAppMetaData = parseMetaData(res, parser, attrs, owner.mAppMetaData,
1916                        outError)) == null) {
1917                    mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
1918                    return false;
1919                }
1920
1921            } else if (tagName.equals("uses-library")) {
1922                sa = res.obtainAttributes(attrs,
1923                        com.android.internal.R.styleable.AndroidManifestUsesLibrary);
1924
1925                // Note: don't allow this value to be a reference to a resource
1926                // that may change.
1927                String lname = sa.getNonResourceString(
1928                        com.android.internal.R.styleable.AndroidManifestUsesLibrary_name);
1929                boolean req = sa.getBoolean(
1930                        com.android.internal.R.styleable.AndroidManifestUsesLibrary_required,
1931                        true);
1932
1933                sa.recycle();
1934
1935                if (lname != null) {
1936                    if (req) {
1937                        if (owner.usesLibraries == null) {
1938                            owner.usesLibraries = new ArrayList<String>();
1939                        }
1940                        if (!owner.usesLibraries.contains(lname)) {
1941                            owner.usesLibraries.add(lname.intern());
1942                        }
1943                    } else {
1944                        if (owner.usesOptionalLibraries == null) {
1945                            owner.usesOptionalLibraries = new ArrayList<String>();
1946                        }
1947                        if (!owner.usesOptionalLibraries.contains(lname)) {
1948                            owner.usesOptionalLibraries.add(lname.intern());
1949                        }
1950                    }
1951                }
1952
1953                XmlUtils.skipCurrentTag(parser);
1954
1955            } else if (tagName.equals("uses-package")) {
1956                // Dependencies for app installers; we don't currently try to
1957                // enforce this.
1958                XmlUtils.skipCurrentTag(parser);
1959
1960            } else {
1961                if (!RIGID_PARSER) {
1962                    Slog.w(TAG, "Unknown element under <application>: " + tagName
1963                            + " at " + mArchiveSourcePath + " "
1964                            + parser.getPositionDescription());
1965                    XmlUtils.skipCurrentTag(parser);
1966                    continue;
1967                } else {
1968                    outError[0] = "Bad element under <application>: " + tagName;
1969                    mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
1970                    return false;
1971                }
1972            }
1973        }
1974
1975        return true;
1976    }
1977
1978    private boolean parsePackageItemInfo(Package owner, PackageItemInfo outInfo,
1979            String[] outError, String tag, TypedArray sa,
1980            int nameRes, int labelRes, int iconRes, int logoRes) {
1981        String name = sa.getNonConfigurationString(nameRes, 0);
1982        if (name == null) {
1983            outError[0] = tag + " does not specify android:name";
1984            return false;
1985        }
1986
1987        outInfo.name
1988            = buildClassName(owner.applicationInfo.packageName, name, outError);
1989        if (outInfo.name == null) {
1990            return false;
1991        }
1992
1993        int iconVal = sa.getResourceId(iconRes, 0);
1994        if (iconVal != 0) {
1995            outInfo.icon = iconVal;
1996            outInfo.nonLocalizedLabel = null;
1997        }
1998
1999        int logoVal = sa.getResourceId(logoRes, 0);
2000        if (logoVal != 0) {
2001            outInfo.logo = logoVal;
2002        }
2003
2004        TypedValue v = sa.peekValue(labelRes);
2005        if (v != null && (outInfo.labelRes=v.resourceId) == 0) {
2006            outInfo.nonLocalizedLabel = v.coerceToString();
2007        }
2008
2009        outInfo.packageName = owner.packageName;
2010
2011        return true;
2012    }
2013
2014    private Activity parseActivity(Package owner, Resources res,
2015            XmlPullParser parser, AttributeSet attrs, int flags, String[] outError,
2016            boolean receiver, boolean hardwareAccelerated)
2017            throws XmlPullParserException, IOException {
2018        TypedArray sa = res.obtainAttributes(attrs,
2019                com.android.internal.R.styleable.AndroidManifestActivity);
2020
2021        if (mParseActivityArgs == null) {
2022            mParseActivityArgs = new ParseComponentArgs(owner, outError,
2023                    com.android.internal.R.styleable.AndroidManifestActivity_name,
2024                    com.android.internal.R.styleable.AndroidManifestActivity_label,
2025                    com.android.internal.R.styleable.AndroidManifestActivity_icon,
2026                    com.android.internal.R.styleable.AndroidManifestActivity_logo,
2027                    mSeparateProcesses,
2028                    com.android.internal.R.styleable.AndroidManifestActivity_process,
2029                    com.android.internal.R.styleable.AndroidManifestActivity_description,
2030                    com.android.internal.R.styleable.AndroidManifestActivity_enabled);
2031        }
2032
2033        mParseActivityArgs.tag = receiver ? "<receiver>" : "<activity>";
2034        mParseActivityArgs.sa = sa;
2035        mParseActivityArgs.flags = flags;
2036
2037        Activity a = new Activity(mParseActivityArgs, new ActivityInfo());
2038        if (outError[0] != null) {
2039            sa.recycle();
2040            return null;
2041        }
2042
2043        boolean setExported = sa.hasValue(
2044                com.android.internal.R.styleable.AndroidManifestActivity_exported);
2045        if (setExported) {
2046            a.info.exported = sa.getBoolean(
2047                    com.android.internal.R.styleable.AndroidManifestActivity_exported, false);
2048        }
2049
2050        a.info.theme = sa.getResourceId(
2051                com.android.internal.R.styleable.AndroidManifestActivity_theme, 0);
2052
2053        a.info.uiOptions = sa.getInt(
2054                com.android.internal.R.styleable.AndroidManifestActivity_uiOptions,
2055                a.info.applicationInfo.uiOptions);
2056
2057        String parentName = sa.getNonConfigurationString(
2058                com.android.internal.R.styleable.AndroidManifestActivity_parentActivityName, 0);
2059        if (parentName != null) {
2060            String parentClassName = buildClassName(a.info.packageName, parentName, outError);
2061            if (outError[0] == null) {
2062                a.info.parentActivityName = parentClassName;
2063            } else {
2064                Log.e(TAG, "Activity " + a.info.name + " specified invalid parentActivityName " +
2065                        parentName);
2066                outError[0] = null;
2067            }
2068        }
2069
2070        String str;
2071        str = sa.getNonConfigurationString(
2072                com.android.internal.R.styleable.AndroidManifestActivity_permission, 0);
2073        if (str == null) {
2074            a.info.permission = owner.applicationInfo.permission;
2075        } else {
2076            a.info.permission = str.length() > 0 ? str.toString().intern() : null;
2077        }
2078
2079        str = sa.getNonConfigurationString(
2080                com.android.internal.R.styleable.AndroidManifestActivity_taskAffinity, 0);
2081        a.info.taskAffinity = buildTaskAffinityName(owner.applicationInfo.packageName,
2082                owner.applicationInfo.taskAffinity, str, outError);
2083
2084        a.info.flags = 0;
2085        if (sa.getBoolean(
2086                com.android.internal.R.styleable.AndroidManifestActivity_multiprocess,
2087                false)) {
2088            a.info.flags |= ActivityInfo.FLAG_MULTIPROCESS;
2089        }
2090
2091        if (sa.getBoolean(
2092                com.android.internal.R.styleable.AndroidManifestActivity_finishOnTaskLaunch,
2093                false)) {
2094            a.info.flags |= ActivityInfo.FLAG_FINISH_ON_TASK_LAUNCH;
2095        }
2096
2097        if (sa.getBoolean(
2098                com.android.internal.R.styleable.AndroidManifestActivity_clearTaskOnLaunch,
2099                false)) {
2100            a.info.flags |= ActivityInfo.FLAG_CLEAR_TASK_ON_LAUNCH;
2101        }
2102
2103        if (sa.getBoolean(
2104                com.android.internal.R.styleable.AndroidManifestActivity_noHistory,
2105                false)) {
2106            a.info.flags |= ActivityInfo.FLAG_NO_HISTORY;
2107        }
2108
2109        if (sa.getBoolean(
2110                com.android.internal.R.styleable.AndroidManifestActivity_alwaysRetainTaskState,
2111                false)) {
2112            a.info.flags |= ActivityInfo.FLAG_ALWAYS_RETAIN_TASK_STATE;
2113        }
2114
2115        if (sa.getBoolean(
2116                com.android.internal.R.styleable.AndroidManifestActivity_stateNotNeeded,
2117                false)) {
2118            a.info.flags |= ActivityInfo.FLAG_STATE_NOT_NEEDED;
2119        }
2120
2121        if (sa.getBoolean(
2122                com.android.internal.R.styleable.AndroidManifestActivity_excludeFromRecents,
2123                false)) {
2124            a.info.flags |= ActivityInfo.FLAG_EXCLUDE_FROM_RECENTS;
2125        }
2126
2127        if (sa.getBoolean(
2128                com.android.internal.R.styleable.AndroidManifestActivity_allowTaskReparenting,
2129                (owner.applicationInfo.flags&ApplicationInfo.FLAG_ALLOW_TASK_REPARENTING) != 0)) {
2130            a.info.flags |= ActivityInfo.FLAG_ALLOW_TASK_REPARENTING;
2131        }
2132
2133        if (sa.getBoolean(
2134                com.android.internal.R.styleable.AndroidManifestActivity_finishOnCloseSystemDialogs,
2135                false)) {
2136            a.info.flags |= ActivityInfo.FLAG_FINISH_ON_CLOSE_SYSTEM_DIALOGS;
2137        }
2138
2139        if (sa.getBoolean(
2140                com.android.internal.R.styleable.AndroidManifestActivity_immersive,
2141                false)) {
2142            a.info.flags |= ActivityInfo.FLAG_IMMERSIVE;
2143        }
2144
2145        if (!receiver) {
2146            if (sa.getBoolean(
2147                    com.android.internal.R.styleable.AndroidManifestActivity_hardwareAccelerated,
2148                    hardwareAccelerated)) {
2149                a.info.flags |= ActivityInfo.FLAG_HARDWARE_ACCELERATED;
2150            }
2151
2152            a.info.launchMode = sa.getInt(
2153                    com.android.internal.R.styleable.AndroidManifestActivity_launchMode,
2154                    ActivityInfo.LAUNCH_MULTIPLE);
2155            a.info.screenOrientation = sa.getInt(
2156                    com.android.internal.R.styleable.AndroidManifestActivity_screenOrientation,
2157                    ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
2158            a.info.configChanges = sa.getInt(
2159                    com.android.internal.R.styleable.AndroidManifestActivity_configChanges,
2160                    0);
2161            a.info.softInputMode = sa.getInt(
2162                    com.android.internal.R.styleable.AndroidManifestActivity_windowSoftInputMode,
2163                    0);
2164        } else {
2165            a.info.launchMode = ActivityInfo.LAUNCH_MULTIPLE;
2166            a.info.configChanges = 0;
2167        }
2168
2169        if (receiver) {
2170            if (sa.getBoolean(
2171                    com.android.internal.R.styleable.AndroidManifestActivity_singleUser,
2172                    false)) {
2173                a.info.flags |= ServiceInfo.FLAG_SINGLE_USER;
2174                if (a.info.exported) {
2175                    Slog.w(TAG, "Activity exported request ignored due to singleUser: "
2176                            + a.className + " at " + mArchiveSourcePath + " "
2177                            + parser.getPositionDescription());
2178                    a.info.exported = false;
2179                }
2180                setExported = true;
2181            }
2182        }
2183
2184        sa.recycle();
2185
2186        if (receiver && (owner.applicationInfo.flags&ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0) {
2187            // A heavy-weight application can not have receives in its main process
2188            // We can do direct compare because we intern all strings.
2189            if (a.info.processName == owner.packageName) {
2190                outError[0] = "Heavy-weight applications can not have receivers in main process";
2191            }
2192        }
2193
2194        if (outError[0] != null) {
2195            return null;
2196        }
2197
2198        int outerDepth = parser.getDepth();
2199        int type;
2200        while ((type=parser.next()) != XmlPullParser.END_DOCUMENT
2201               && (type != XmlPullParser.END_TAG
2202                       || parser.getDepth() > outerDepth)) {
2203            if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
2204                continue;
2205            }
2206
2207            if (parser.getName().equals("intent-filter")) {
2208                ActivityIntentInfo intent = new ActivityIntentInfo(a);
2209                if (!parseIntent(res, parser, attrs, flags, intent, outError, !receiver)) {
2210                    return null;
2211                }
2212                if (intent.countActions() == 0) {
2213                    Slog.w(TAG, "No actions in intent filter at "
2214                            + mArchiveSourcePath + " "
2215                            + parser.getPositionDescription());
2216                } else {
2217                    a.intents.add(intent);
2218                }
2219            } else if (parser.getName().equals("meta-data")) {
2220                if ((a.metaData=parseMetaData(res, parser, attrs, a.metaData,
2221                        outError)) == null) {
2222                    return null;
2223                }
2224            } else {
2225                if (!RIGID_PARSER) {
2226                    Slog.w(TAG, "Problem in package " + mArchiveSourcePath + ":");
2227                    if (receiver) {
2228                        Slog.w(TAG, "Unknown element under <receiver>: " + parser.getName()
2229                                + " at " + mArchiveSourcePath + " "
2230                                + parser.getPositionDescription());
2231                    } else {
2232                        Slog.w(TAG, "Unknown element under <activity>: " + parser.getName()
2233                                + " at " + mArchiveSourcePath + " "
2234                                + parser.getPositionDescription());
2235                    }
2236                    XmlUtils.skipCurrentTag(parser);
2237                    continue;
2238                } else {
2239                    if (receiver) {
2240                        outError[0] = "Bad element under <receiver>: " + parser.getName();
2241                    } else {
2242                        outError[0] = "Bad element under <activity>: " + parser.getName();
2243                    }
2244                    return null;
2245                }
2246            }
2247        }
2248
2249        if (!setExported) {
2250            a.info.exported = a.intents.size() > 0;
2251        }
2252
2253        return a;
2254    }
2255
2256    private Activity parseActivityAlias(Package owner, Resources res,
2257            XmlPullParser parser, AttributeSet attrs, int flags, String[] outError)
2258            throws XmlPullParserException, IOException {
2259        TypedArray sa = res.obtainAttributes(attrs,
2260                com.android.internal.R.styleable.AndroidManifestActivityAlias);
2261
2262        String targetActivity = sa.getNonConfigurationString(
2263                com.android.internal.R.styleable.AndroidManifestActivityAlias_targetActivity, 0);
2264        if (targetActivity == null) {
2265            outError[0] = "<activity-alias> does not specify android:targetActivity";
2266            sa.recycle();
2267            return null;
2268        }
2269
2270        targetActivity = buildClassName(owner.applicationInfo.packageName,
2271                targetActivity, outError);
2272        if (targetActivity == null) {
2273            sa.recycle();
2274            return null;
2275        }
2276
2277        if (mParseActivityAliasArgs == null) {
2278            mParseActivityAliasArgs = new ParseComponentArgs(owner, outError,
2279                    com.android.internal.R.styleable.AndroidManifestActivityAlias_name,
2280                    com.android.internal.R.styleable.AndroidManifestActivityAlias_label,
2281                    com.android.internal.R.styleable.AndroidManifestActivityAlias_icon,
2282                    com.android.internal.R.styleable.AndroidManifestActivityAlias_logo,
2283                    mSeparateProcesses,
2284                    0,
2285                    com.android.internal.R.styleable.AndroidManifestActivityAlias_description,
2286                    com.android.internal.R.styleable.AndroidManifestActivityAlias_enabled);
2287            mParseActivityAliasArgs.tag = "<activity-alias>";
2288        }
2289
2290        mParseActivityAliasArgs.sa = sa;
2291        mParseActivityAliasArgs.flags = flags;
2292
2293        Activity target = null;
2294
2295        final int NA = owner.activities.size();
2296        for (int i=0; i<NA; i++) {
2297            Activity t = owner.activities.get(i);
2298            if (targetActivity.equals(t.info.name)) {
2299                target = t;
2300                break;
2301            }
2302        }
2303
2304        if (target == null) {
2305            outError[0] = "<activity-alias> target activity " + targetActivity
2306                    + " not found in manifest";
2307            sa.recycle();
2308            return null;
2309        }
2310
2311        ActivityInfo info = new ActivityInfo();
2312        info.targetActivity = targetActivity;
2313        info.configChanges = target.info.configChanges;
2314        info.flags = target.info.flags;
2315        info.icon = target.info.icon;
2316        info.logo = target.info.logo;
2317        info.labelRes = target.info.labelRes;
2318        info.nonLocalizedLabel = target.info.nonLocalizedLabel;
2319        info.launchMode = target.info.launchMode;
2320        info.processName = target.info.processName;
2321        if (info.descriptionRes == 0) {
2322            info.descriptionRes = target.info.descriptionRes;
2323        }
2324        info.screenOrientation = target.info.screenOrientation;
2325        info.taskAffinity = target.info.taskAffinity;
2326        info.theme = target.info.theme;
2327        info.softInputMode = target.info.softInputMode;
2328        info.uiOptions = target.info.uiOptions;
2329        info.parentActivityName = target.info.parentActivityName;
2330
2331        Activity a = new Activity(mParseActivityAliasArgs, info);
2332        if (outError[0] != null) {
2333            sa.recycle();
2334            return null;
2335        }
2336
2337        final boolean setExported = sa.hasValue(
2338                com.android.internal.R.styleable.AndroidManifestActivityAlias_exported);
2339        if (setExported) {
2340            a.info.exported = sa.getBoolean(
2341                    com.android.internal.R.styleable.AndroidManifestActivityAlias_exported, false);
2342        }
2343
2344        String str;
2345        str = sa.getNonConfigurationString(
2346                com.android.internal.R.styleable.AndroidManifestActivityAlias_permission, 0);
2347        if (str != null) {
2348            a.info.permission = str.length() > 0 ? str.toString().intern() : null;
2349        }
2350
2351        String parentName = sa.getNonConfigurationString(
2352                com.android.internal.R.styleable.AndroidManifestActivityAlias_parentActivityName,
2353                0);
2354        if (parentName != null) {
2355            String parentClassName = buildClassName(a.info.packageName, parentName, outError);
2356            if (outError[0] == null) {
2357                a.info.parentActivityName = parentClassName;
2358            } else {
2359                Log.e(TAG, "Activity alias " + a.info.name +
2360                        " specified invalid parentActivityName " + parentName);
2361                outError[0] = null;
2362            }
2363        }
2364
2365        sa.recycle();
2366
2367        if (outError[0] != null) {
2368            return null;
2369        }
2370
2371        int outerDepth = parser.getDepth();
2372        int type;
2373        while ((type=parser.next()) != XmlPullParser.END_DOCUMENT
2374               && (type != XmlPullParser.END_TAG
2375                       || parser.getDepth() > outerDepth)) {
2376            if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
2377                continue;
2378            }
2379
2380            if (parser.getName().equals("intent-filter")) {
2381                ActivityIntentInfo intent = new ActivityIntentInfo(a);
2382                if (!parseIntent(res, parser, attrs, flags, intent, outError, true)) {
2383                    return null;
2384                }
2385                if (intent.countActions() == 0) {
2386                    Slog.w(TAG, "No actions in intent filter at "
2387                            + mArchiveSourcePath + " "
2388                            + parser.getPositionDescription());
2389                } else {
2390                    a.intents.add(intent);
2391                }
2392            } else if (parser.getName().equals("meta-data")) {
2393                if ((a.metaData=parseMetaData(res, parser, attrs, a.metaData,
2394                        outError)) == null) {
2395                    return null;
2396                }
2397            } else {
2398                if (!RIGID_PARSER) {
2399                    Slog.w(TAG, "Unknown element under <activity-alias>: " + parser.getName()
2400                            + " at " + mArchiveSourcePath + " "
2401                            + parser.getPositionDescription());
2402                    XmlUtils.skipCurrentTag(parser);
2403                    continue;
2404                } else {
2405                    outError[0] = "Bad element under <activity-alias>: " + parser.getName();
2406                    return null;
2407                }
2408            }
2409        }
2410
2411        if (!setExported) {
2412            a.info.exported = a.intents.size() > 0;
2413        }
2414
2415        return a;
2416    }
2417
2418    private Provider parseProvider(Package owner, Resources res,
2419            XmlPullParser parser, AttributeSet attrs, int flags, String[] outError)
2420            throws XmlPullParserException, IOException {
2421        TypedArray sa = res.obtainAttributes(attrs,
2422                com.android.internal.R.styleable.AndroidManifestProvider);
2423
2424        if (mParseProviderArgs == null) {
2425            mParseProviderArgs = new ParseComponentArgs(owner, outError,
2426                    com.android.internal.R.styleable.AndroidManifestProvider_name,
2427                    com.android.internal.R.styleable.AndroidManifestProvider_label,
2428                    com.android.internal.R.styleable.AndroidManifestProvider_icon,
2429                    com.android.internal.R.styleable.AndroidManifestProvider_logo,
2430                    mSeparateProcesses,
2431                    com.android.internal.R.styleable.AndroidManifestProvider_process,
2432                    com.android.internal.R.styleable.AndroidManifestProvider_description,
2433                    com.android.internal.R.styleable.AndroidManifestProvider_enabled);
2434            mParseProviderArgs.tag = "<provider>";
2435        }
2436
2437        mParseProviderArgs.sa = sa;
2438        mParseProviderArgs.flags = flags;
2439
2440        Provider p = new Provider(mParseProviderArgs, new ProviderInfo());
2441        if (outError[0] != null) {
2442            sa.recycle();
2443            return null;
2444        }
2445
2446        p.info.exported = sa.getBoolean(
2447                com.android.internal.R.styleable.AndroidManifestProvider_exported, true);
2448
2449        String cpname = sa.getNonConfigurationString(
2450                com.android.internal.R.styleable.AndroidManifestProvider_authorities, 0);
2451
2452        p.info.isSyncable = sa.getBoolean(
2453                com.android.internal.R.styleable.AndroidManifestProvider_syncable,
2454                false);
2455
2456        String permission = sa.getNonConfigurationString(
2457                com.android.internal.R.styleable.AndroidManifestProvider_permission, 0);
2458        String str = sa.getNonConfigurationString(
2459                com.android.internal.R.styleable.AndroidManifestProvider_readPermission, 0);
2460        if (str == null) {
2461            str = permission;
2462        }
2463        if (str == null) {
2464            p.info.readPermission = owner.applicationInfo.permission;
2465        } else {
2466            p.info.readPermission =
2467                str.length() > 0 ? str.toString().intern() : null;
2468        }
2469        str = sa.getNonConfigurationString(
2470                com.android.internal.R.styleable.AndroidManifestProvider_writePermission, 0);
2471        if (str == null) {
2472            str = permission;
2473        }
2474        if (str == null) {
2475            p.info.writePermission = owner.applicationInfo.permission;
2476        } else {
2477            p.info.writePermission =
2478                str.length() > 0 ? str.toString().intern() : null;
2479        }
2480
2481        p.info.grantUriPermissions = sa.getBoolean(
2482                com.android.internal.R.styleable.AndroidManifestProvider_grantUriPermissions,
2483                false);
2484
2485        p.info.multiprocess = sa.getBoolean(
2486                com.android.internal.R.styleable.AndroidManifestProvider_multiprocess,
2487                false);
2488
2489        p.info.initOrder = sa.getInt(
2490                com.android.internal.R.styleable.AndroidManifestProvider_initOrder,
2491                0);
2492
2493        p.info.flags = 0;
2494
2495        if (sa.getBoolean(
2496                com.android.internal.R.styleable.AndroidManifestProvider_singleUser,
2497                false)) {
2498            p.info.flags |= ProviderInfo.FLAG_SINGLE_USER;
2499            if (p.info.exported) {
2500                Slog.w(TAG, "Provider exported request ignored due to singleUser: "
2501                        + p.className + " at " + mArchiveSourcePath + " "
2502                        + parser.getPositionDescription());
2503                p.info.exported = false;
2504            }
2505        }
2506
2507        sa.recycle();
2508
2509        if ((owner.applicationInfo.flags&ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0) {
2510            // A heavy-weight application can not have providers in its main process
2511            // We can do direct compare because we intern all strings.
2512            if (p.info.processName == owner.packageName) {
2513                outError[0] = "Heavy-weight applications can not have providers in main process";
2514                return null;
2515            }
2516        }
2517
2518        if (cpname == null) {
2519            outError[0] = "<provider> does not incude authorities attribute";
2520            return null;
2521        }
2522        p.info.authority = cpname.intern();
2523
2524        if (!parseProviderTags(res, parser, attrs, p, outError)) {
2525            return null;
2526        }
2527
2528        return p;
2529    }
2530
2531    private boolean parseProviderTags(Resources res,
2532            XmlPullParser parser, AttributeSet attrs,
2533            Provider outInfo, String[] outError)
2534            throws XmlPullParserException, IOException {
2535        int outerDepth = parser.getDepth();
2536        int type;
2537        while ((type=parser.next()) != XmlPullParser.END_DOCUMENT
2538               && (type != XmlPullParser.END_TAG
2539                       || parser.getDepth() > outerDepth)) {
2540            if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
2541                continue;
2542            }
2543
2544            if (parser.getName().equals("meta-data")) {
2545                if ((outInfo.metaData=parseMetaData(res, parser, attrs,
2546                        outInfo.metaData, outError)) == null) {
2547                    return false;
2548                }
2549
2550            } else if (parser.getName().equals("grant-uri-permission")) {
2551                TypedArray sa = res.obtainAttributes(attrs,
2552                        com.android.internal.R.styleable.AndroidManifestGrantUriPermission);
2553
2554                PatternMatcher pa = null;
2555
2556                String str = sa.getNonConfigurationString(
2557                        com.android.internal.R.styleable.AndroidManifestGrantUriPermission_path, 0);
2558                if (str != null) {
2559                    pa = new PatternMatcher(str, PatternMatcher.PATTERN_LITERAL);
2560                }
2561
2562                str = sa.getNonConfigurationString(
2563                        com.android.internal.R.styleable.AndroidManifestGrantUriPermission_pathPrefix, 0);
2564                if (str != null) {
2565                    pa = new PatternMatcher(str, PatternMatcher.PATTERN_PREFIX);
2566                }
2567
2568                str = sa.getNonConfigurationString(
2569                        com.android.internal.R.styleable.AndroidManifestGrantUriPermission_pathPattern, 0);
2570                if (str != null) {
2571                    pa = new PatternMatcher(str, PatternMatcher.PATTERN_SIMPLE_GLOB);
2572                }
2573
2574                sa.recycle();
2575
2576                if (pa != null) {
2577                    if (outInfo.info.uriPermissionPatterns == null) {
2578                        outInfo.info.uriPermissionPatterns = new PatternMatcher[1];
2579                        outInfo.info.uriPermissionPatterns[0] = pa;
2580                    } else {
2581                        final int N = outInfo.info.uriPermissionPatterns.length;
2582                        PatternMatcher[] newp = new PatternMatcher[N+1];
2583                        System.arraycopy(outInfo.info.uriPermissionPatterns, 0, newp, 0, N);
2584                        newp[N] = pa;
2585                        outInfo.info.uriPermissionPatterns = newp;
2586                    }
2587                    outInfo.info.grantUriPermissions = true;
2588                } else {
2589                    if (!RIGID_PARSER) {
2590                        Slog.w(TAG, "Unknown element under <path-permission>: "
2591                                + parser.getName() + " at " + mArchiveSourcePath + " "
2592                                + parser.getPositionDescription());
2593                        XmlUtils.skipCurrentTag(parser);
2594                        continue;
2595                    } else {
2596                        outError[0] = "No path, pathPrefix, or pathPattern for <path-permission>";
2597                        return false;
2598                    }
2599                }
2600                XmlUtils.skipCurrentTag(parser);
2601
2602            } else if (parser.getName().equals("path-permission")) {
2603                TypedArray sa = res.obtainAttributes(attrs,
2604                        com.android.internal.R.styleable.AndroidManifestPathPermission);
2605
2606                PathPermission pa = null;
2607
2608                String permission = sa.getNonConfigurationString(
2609                        com.android.internal.R.styleable.AndroidManifestPathPermission_permission, 0);
2610                String readPermission = sa.getNonConfigurationString(
2611                        com.android.internal.R.styleable.AndroidManifestPathPermission_readPermission, 0);
2612                if (readPermission == null) {
2613                    readPermission = permission;
2614                }
2615                String writePermission = sa.getNonConfigurationString(
2616                        com.android.internal.R.styleable.AndroidManifestPathPermission_writePermission, 0);
2617                if (writePermission == null) {
2618                    writePermission = permission;
2619                }
2620
2621                boolean havePerm = false;
2622                if (readPermission != null) {
2623                    readPermission = readPermission.intern();
2624                    havePerm = true;
2625                }
2626                if (writePermission != null) {
2627                    writePermission = writePermission.intern();
2628                    havePerm = true;
2629                }
2630
2631                if (!havePerm) {
2632                    if (!RIGID_PARSER) {
2633                        Slog.w(TAG, "No readPermission or writePermssion for <path-permission>: "
2634                                + parser.getName() + " at " + mArchiveSourcePath + " "
2635                                + parser.getPositionDescription());
2636                        XmlUtils.skipCurrentTag(parser);
2637                        continue;
2638                    } else {
2639                        outError[0] = "No readPermission or writePermssion for <path-permission>";
2640                        return false;
2641                    }
2642                }
2643
2644                String path = sa.getNonConfigurationString(
2645                        com.android.internal.R.styleable.AndroidManifestPathPermission_path, 0);
2646                if (path != null) {
2647                    pa = new PathPermission(path,
2648                            PatternMatcher.PATTERN_LITERAL, readPermission, writePermission);
2649                }
2650
2651                path = sa.getNonConfigurationString(
2652                        com.android.internal.R.styleable.AndroidManifestPathPermission_pathPrefix, 0);
2653                if (path != null) {
2654                    pa = new PathPermission(path,
2655                            PatternMatcher.PATTERN_PREFIX, readPermission, writePermission);
2656                }
2657
2658                path = sa.getNonConfigurationString(
2659                        com.android.internal.R.styleable.AndroidManifestPathPermission_pathPattern, 0);
2660                if (path != null) {
2661                    pa = new PathPermission(path,
2662                            PatternMatcher.PATTERN_SIMPLE_GLOB, readPermission, writePermission);
2663                }
2664
2665                sa.recycle();
2666
2667                if (pa != null) {
2668                    if (outInfo.info.pathPermissions == null) {
2669                        outInfo.info.pathPermissions = new PathPermission[1];
2670                        outInfo.info.pathPermissions[0] = pa;
2671                    } else {
2672                        final int N = outInfo.info.pathPermissions.length;
2673                        PathPermission[] newp = new PathPermission[N+1];
2674                        System.arraycopy(outInfo.info.pathPermissions, 0, newp, 0, N);
2675                        newp[N] = pa;
2676                        outInfo.info.pathPermissions = newp;
2677                    }
2678                } else {
2679                    if (!RIGID_PARSER) {
2680                        Slog.w(TAG, "No path, pathPrefix, or pathPattern for <path-permission>: "
2681                                + parser.getName() + " at " + mArchiveSourcePath + " "
2682                                + parser.getPositionDescription());
2683                        XmlUtils.skipCurrentTag(parser);
2684                        continue;
2685                    }
2686                    outError[0] = "No path, pathPrefix, or pathPattern for <path-permission>";
2687                    return false;
2688                }
2689                XmlUtils.skipCurrentTag(parser);
2690
2691            } else {
2692                if (!RIGID_PARSER) {
2693                    Slog.w(TAG, "Unknown element under <provider>: "
2694                            + parser.getName() + " at " + mArchiveSourcePath + " "
2695                            + parser.getPositionDescription());
2696                    XmlUtils.skipCurrentTag(parser);
2697                    continue;
2698                } else {
2699                    outError[0] = "Bad element under <provider>: " + parser.getName();
2700                    return false;
2701                }
2702            }
2703        }
2704        return true;
2705    }
2706
2707    private Service parseService(Package owner, Resources res,
2708            XmlPullParser parser, AttributeSet attrs, int flags, String[] outError)
2709            throws XmlPullParserException, IOException {
2710        TypedArray sa = res.obtainAttributes(attrs,
2711                com.android.internal.R.styleable.AndroidManifestService);
2712
2713        if (mParseServiceArgs == null) {
2714            mParseServiceArgs = new ParseComponentArgs(owner, outError,
2715                    com.android.internal.R.styleable.AndroidManifestService_name,
2716                    com.android.internal.R.styleable.AndroidManifestService_label,
2717                    com.android.internal.R.styleable.AndroidManifestService_icon,
2718                    com.android.internal.R.styleable.AndroidManifestService_logo,
2719                    mSeparateProcesses,
2720                    com.android.internal.R.styleable.AndroidManifestService_process,
2721                    com.android.internal.R.styleable.AndroidManifestService_description,
2722                    com.android.internal.R.styleable.AndroidManifestService_enabled);
2723            mParseServiceArgs.tag = "<service>";
2724        }
2725
2726        mParseServiceArgs.sa = sa;
2727        mParseServiceArgs.flags = flags;
2728
2729        Service s = new Service(mParseServiceArgs, new ServiceInfo());
2730        if (outError[0] != null) {
2731            sa.recycle();
2732            return null;
2733        }
2734
2735        boolean setExported = sa.hasValue(
2736                com.android.internal.R.styleable.AndroidManifestService_exported);
2737        if (setExported) {
2738            s.info.exported = sa.getBoolean(
2739                    com.android.internal.R.styleable.AndroidManifestService_exported, false);
2740        }
2741
2742        String str = sa.getNonConfigurationString(
2743                com.android.internal.R.styleable.AndroidManifestService_permission, 0);
2744        if (str == null) {
2745            s.info.permission = owner.applicationInfo.permission;
2746        } else {
2747            s.info.permission = str.length() > 0 ? str.toString().intern() : null;
2748        }
2749
2750        s.info.flags = 0;
2751        if (sa.getBoolean(
2752                com.android.internal.R.styleable.AndroidManifestService_stopWithTask,
2753                false)) {
2754            s.info.flags |= ServiceInfo.FLAG_STOP_WITH_TASK;
2755        }
2756        if (sa.getBoolean(
2757                com.android.internal.R.styleable.AndroidManifestService_isolatedProcess,
2758                false)) {
2759            s.info.flags |= ServiceInfo.FLAG_ISOLATED_PROCESS;
2760        }
2761        if (sa.getBoolean(
2762                com.android.internal.R.styleable.AndroidManifestService_singleUser,
2763                false)) {
2764            s.info.flags |= ServiceInfo.FLAG_SINGLE_USER;
2765            if (s.info.exported) {
2766                Slog.w(TAG, "Service exported request ignored due to singleUser: "
2767                        + s.className + " at " + mArchiveSourcePath + " "
2768                        + parser.getPositionDescription());
2769                s.info.exported = false;
2770            }
2771            setExported = true;
2772        }
2773
2774        sa.recycle();
2775
2776        if ((owner.applicationInfo.flags&ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0) {
2777            // A heavy-weight application can not have services in its main process
2778            // We can do direct compare because we intern all strings.
2779            if (s.info.processName == owner.packageName) {
2780                outError[0] = "Heavy-weight applications can not have services in main process";
2781                return null;
2782            }
2783        }
2784
2785        int outerDepth = parser.getDepth();
2786        int type;
2787        while ((type=parser.next()) != XmlPullParser.END_DOCUMENT
2788               && (type != XmlPullParser.END_TAG
2789                       || parser.getDepth() > outerDepth)) {
2790            if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
2791                continue;
2792            }
2793
2794            if (parser.getName().equals("intent-filter")) {
2795                ServiceIntentInfo intent = new ServiceIntentInfo(s);
2796                if (!parseIntent(res, parser, attrs, flags, intent, outError, false)) {
2797                    return null;
2798                }
2799
2800                s.intents.add(intent);
2801            } else if (parser.getName().equals("meta-data")) {
2802                if ((s.metaData=parseMetaData(res, parser, attrs, s.metaData,
2803                        outError)) == null) {
2804                    return null;
2805                }
2806            } else {
2807                if (!RIGID_PARSER) {
2808                    Slog.w(TAG, "Unknown element under <service>: "
2809                            + parser.getName() + " at " + mArchiveSourcePath + " "
2810                            + parser.getPositionDescription());
2811                    XmlUtils.skipCurrentTag(parser);
2812                    continue;
2813                } else {
2814                    outError[0] = "Bad element under <service>: " + parser.getName();
2815                    return null;
2816                }
2817            }
2818        }
2819
2820        if (!setExported) {
2821            s.info.exported = s.intents.size() > 0;
2822        }
2823
2824        return s;
2825    }
2826
2827    private boolean parseAllMetaData(Resources res,
2828            XmlPullParser parser, AttributeSet attrs, String tag,
2829            Component outInfo, String[] outError)
2830            throws XmlPullParserException, IOException {
2831        int outerDepth = parser.getDepth();
2832        int type;
2833        while ((type=parser.next()) != XmlPullParser.END_DOCUMENT
2834               && (type != XmlPullParser.END_TAG
2835                       || parser.getDepth() > outerDepth)) {
2836            if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
2837                continue;
2838            }
2839
2840            if (parser.getName().equals("meta-data")) {
2841                if ((outInfo.metaData=parseMetaData(res, parser, attrs,
2842                        outInfo.metaData, outError)) == null) {
2843                    return false;
2844                }
2845            } else {
2846                if (!RIGID_PARSER) {
2847                    Slog.w(TAG, "Unknown element under " + tag + ": "
2848                            + parser.getName() + " at " + mArchiveSourcePath + " "
2849                            + parser.getPositionDescription());
2850                    XmlUtils.skipCurrentTag(parser);
2851                    continue;
2852                } else {
2853                    outError[0] = "Bad element under " + tag + ": " + parser.getName();
2854                    return false;
2855                }
2856            }
2857        }
2858        return true;
2859    }
2860
2861    private Bundle parseMetaData(Resources res,
2862            XmlPullParser parser, AttributeSet attrs,
2863            Bundle data, String[] outError)
2864            throws XmlPullParserException, IOException {
2865
2866        TypedArray sa = res.obtainAttributes(attrs,
2867                com.android.internal.R.styleable.AndroidManifestMetaData);
2868
2869        if (data == null) {
2870            data = new Bundle();
2871        }
2872
2873        String name = sa.getNonConfigurationString(
2874                com.android.internal.R.styleable.AndroidManifestMetaData_name, 0);
2875        if (name == null) {
2876            outError[0] = "<meta-data> requires an android:name attribute";
2877            sa.recycle();
2878            return null;
2879        }
2880
2881        name = name.intern();
2882
2883        TypedValue v = sa.peekValue(
2884                com.android.internal.R.styleable.AndroidManifestMetaData_resource);
2885        if (v != null && v.resourceId != 0) {
2886            //Slog.i(TAG, "Meta data ref " + name + ": " + v);
2887            data.putInt(name, v.resourceId);
2888        } else {
2889            v = sa.peekValue(
2890                    com.android.internal.R.styleable.AndroidManifestMetaData_value);
2891            //Slog.i(TAG, "Meta data " + name + ": " + v);
2892            if (v != null) {
2893                if (v.type == TypedValue.TYPE_STRING) {
2894                    CharSequence cs = v.coerceToString();
2895                    data.putString(name, cs != null ? cs.toString().intern() : null);
2896                } else if (v.type == TypedValue.TYPE_INT_BOOLEAN) {
2897                    data.putBoolean(name, v.data != 0);
2898                } else if (v.type >= TypedValue.TYPE_FIRST_INT
2899                        && v.type <= TypedValue.TYPE_LAST_INT) {
2900                    data.putInt(name, v.data);
2901                } else if (v.type == TypedValue.TYPE_FLOAT) {
2902                    data.putFloat(name, v.getFloat());
2903                } else {
2904                    if (!RIGID_PARSER) {
2905                        Slog.w(TAG, "<meta-data> only supports string, integer, float, color, boolean, and resource reference types: "
2906                                + parser.getName() + " at " + mArchiveSourcePath + " "
2907                                + parser.getPositionDescription());
2908                    } else {
2909                        outError[0] = "<meta-data> only supports string, integer, float, color, boolean, and resource reference types";
2910                        data = null;
2911                    }
2912                }
2913            } else {
2914                outError[0] = "<meta-data> requires an android:value or android:resource attribute";
2915                data = null;
2916            }
2917        }
2918
2919        sa.recycle();
2920
2921        XmlUtils.skipCurrentTag(parser);
2922
2923        return data;
2924    }
2925
2926    private static VerifierInfo parseVerifier(Resources res, XmlPullParser parser,
2927            AttributeSet attrs, int flags, String[] outError) throws XmlPullParserException,
2928            IOException {
2929        final TypedArray sa = res.obtainAttributes(attrs,
2930                com.android.internal.R.styleable.AndroidManifestPackageVerifier);
2931
2932        final String packageName = sa.getNonResourceString(
2933                com.android.internal.R.styleable.AndroidManifestPackageVerifier_name);
2934
2935        final String encodedPublicKey = sa.getNonResourceString(
2936                com.android.internal.R.styleable.AndroidManifestPackageVerifier_publicKey);
2937
2938        sa.recycle();
2939
2940        if (packageName == null || packageName.length() == 0) {
2941            Slog.i(TAG, "verifier package name was null; skipping");
2942            return null;
2943        } else if (encodedPublicKey == null) {
2944            Slog.i(TAG, "verifier " + packageName + " public key was null; skipping");
2945        }
2946
2947        EncodedKeySpec keySpec;
2948        try {
2949            final byte[] encoded = Base64.decode(encodedPublicKey, Base64.DEFAULT);
2950            keySpec = new X509EncodedKeySpec(encoded);
2951        } catch (IllegalArgumentException e) {
2952            Slog.i(TAG, "Could not parse verifier " + packageName + " public key; invalid Base64");
2953            return null;
2954        }
2955
2956        /* First try the key as an RSA key. */
2957        try {
2958            final KeyFactory keyFactory = KeyFactory.getInstance("RSA");
2959            final PublicKey publicKey = keyFactory.generatePublic(keySpec);
2960            return new VerifierInfo(packageName, publicKey);
2961        } catch (NoSuchAlgorithmException e) {
2962            Log.wtf(TAG, "Could not parse public key because RSA isn't included in build");
2963            return null;
2964        } catch (InvalidKeySpecException e) {
2965            // Not a RSA public key.
2966        }
2967
2968        /* Now try it as a DSA key. */
2969        try {
2970            final KeyFactory keyFactory = KeyFactory.getInstance("DSA");
2971            final PublicKey publicKey = keyFactory.generatePublic(keySpec);
2972            return new VerifierInfo(packageName, publicKey);
2973        } catch (NoSuchAlgorithmException e) {
2974            Log.wtf(TAG, "Could not parse public key because DSA isn't included in build");
2975            return null;
2976        } catch (InvalidKeySpecException e) {
2977            // Not a DSA public key.
2978        }
2979
2980        return null;
2981    }
2982
2983    private static final String ANDROID_RESOURCES
2984            = "http://schemas.android.com/apk/res/android";
2985
2986    private boolean parseIntent(Resources res,
2987            XmlPullParser parser, AttributeSet attrs, int flags,
2988            IntentInfo outInfo, String[] outError, boolean isActivity)
2989            throws XmlPullParserException, IOException {
2990
2991        TypedArray sa = res.obtainAttributes(attrs,
2992                com.android.internal.R.styleable.AndroidManifestIntentFilter);
2993
2994        int priority = sa.getInt(
2995                com.android.internal.R.styleable.AndroidManifestIntentFilter_priority, 0);
2996        outInfo.setPriority(priority);
2997
2998        TypedValue v = sa.peekValue(
2999                com.android.internal.R.styleable.AndroidManifestIntentFilter_label);
3000        if (v != null && (outInfo.labelRes=v.resourceId) == 0) {
3001            outInfo.nonLocalizedLabel = v.coerceToString();
3002        }
3003
3004        outInfo.icon = sa.getResourceId(
3005                com.android.internal.R.styleable.AndroidManifestIntentFilter_icon, 0);
3006
3007        outInfo.logo = sa.getResourceId(
3008                com.android.internal.R.styleable.AndroidManifestIntentFilter_logo, 0);
3009
3010        sa.recycle();
3011
3012        int outerDepth = parser.getDepth();
3013        int type;
3014        while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
3015                && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) {
3016            if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
3017                continue;
3018            }
3019
3020            String nodeName = parser.getName();
3021            if (nodeName.equals("action")) {
3022                String value = attrs.getAttributeValue(
3023                        ANDROID_RESOURCES, "name");
3024                if (value == null || value == "") {
3025                    outError[0] = "No value supplied for <android:name>";
3026                    return false;
3027                }
3028                XmlUtils.skipCurrentTag(parser);
3029
3030                outInfo.addAction(value);
3031            } else if (nodeName.equals("category")) {
3032                String value = attrs.getAttributeValue(
3033                        ANDROID_RESOURCES, "name");
3034                if (value == null || value == "") {
3035                    outError[0] = "No value supplied for <android:name>";
3036                    return false;
3037                }
3038                XmlUtils.skipCurrentTag(parser);
3039
3040                outInfo.addCategory(value);
3041
3042            } else if (nodeName.equals("data")) {
3043                sa = res.obtainAttributes(attrs,
3044                        com.android.internal.R.styleable.AndroidManifestData);
3045
3046                String str = sa.getNonConfigurationString(
3047                        com.android.internal.R.styleable.AndroidManifestData_mimeType, 0);
3048                if (str != null) {
3049                    try {
3050                        outInfo.addDataType(str);
3051                    } catch (IntentFilter.MalformedMimeTypeException e) {
3052                        outError[0] = e.toString();
3053                        sa.recycle();
3054                        return false;
3055                    }
3056                }
3057
3058                str = sa.getNonConfigurationString(
3059                        com.android.internal.R.styleable.AndroidManifestData_scheme, 0);
3060                if (str != null) {
3061                    outInfo.addDataScheme(str);
3062                }
3063
3064                String host = sa.getNonConfigurationString(
3065                        com.android.internal.R.styleable.AndroidManifestData_host, 0);
3066                String port = sa.getNonConfigurationString(
3067                        com.android.internal.R.styleable.AndroidManifestData_port, 0);
3068                if (host != null) {
3069                    outInfo.addDataAuthority(host, port);
3070                }
3071
3072                str = sa.getNonConfigurationString(
3073                        com.android.internal.R.styleable.AndroidManifestData_path, 0);
3074                if (str != null) {
3075                    outInfo.addDataPath(str, PatternMatcher.PATTERN_LITERAL);
3076                }
3077
3078                str = sa.getNonConfigurationString(
3079                        com.android.internal.R.styleable.AndroidManifestData_pathPrefix, 0);
3080                if (str != null) {
3081                    outInfo.addDataPath(str, PatternMatcher.PATTERN_PREFIX);
3082                }
3083
3084                str = sa.getNonConfigurationString(
3085                        com.android.internal.R.styleable.AndroidManifestData_pathPattern, 0);
3086                if (str != null) {
3087                    outInfo.addDataPath(str, PatternMatcher.PATTERN_SIMPLE_GLOB);
3088                }
3089
3090                sa.recycle();
3091                XmlUtils.skipCurrentTag(parser);
3092            } else if (!RIGID_PARSER) {
3093                Slog.w(TAG, "Unknown element under <intent-filter>: "
3094                        + parser.getName() + " at " + mArchiveSourcePath + " "
3095                        + parser.getPositionDescription());
3096                XmlUtils.skipCurrentTag(parser);
3097            } else {
3098                outError[0] = "Bad element under <intent-filter>: " + parser.getName();
3099                return false;
3100            }
3101        }
3102
3103        outInfo.hasDefault = outInfo.hasCategory(Intent.CATEGORY_DEFAULT);
3104
3105        if (DEBUG_PARSER) {
3106            final StringBuilder cats = new StringBuilder("Intent d=");
3107            cats.append(outInfo.hasDefault);
3108            cats.append(", cat=");
3109
3110            final Iterator<String> it = outInfo.categoriesIterator();
3111            if (it != null) {
3112                while (it.hasNext()) {
3113                    cats.append(' ');
3114                    cats.append(it.next());
3115                }
3116            }
3117            Slog.d(TAG, cats.toString());
3118        }
3119
3120        return true;
3121    }
3122
3123    public final static class Package {
3124        public String packageName;
3125
3126        // For now we only support one application per package.
3127        public final ApplicationInfo applicationInfo = new ApplicationInfo();
3128
3129        public final ArrayList<Permission> permissions = new ArrayList<Permission>(0);
3130        public final ArrayList<PermissionGroup> permissionGroups = new ArrayList<PermissionGroup>(0);
3131        public final ArrayList<Activity> activities = new ArrayList<Activity>(0);
3132        public final ArrayList<Activity> receivers = new ArrayList<Activity>(0);
3133        public final ArrayList<Provider> providers = new ArrayList<Provider>(0);
3134        public final ArrayList<Service> services = new ArrayList<Service>(0);
3135        public final ArrayList<Instrumentation> instrumentation = new ArrayList<Instrumentation>(0);
3136
3137        public final ArrayList<String> requestedPermissions = new ArrayList<String>();
3138        public final ArrayList<Boolean> requestedPermissionsRequired = new ArrayList<Boolean>();
3139
3140        public ArrayList<String> protectedBroadcasts;
3141
3142        public ArrayList<String> usesLibraries = null;
3143        public ArrayList<String> usesOptionalLibraries = null;
3144        public String[] usesLibraryFiles = null;
3145
3146        public ArrayList<String> mOriginalPackages = null;
3147        public String mRealPackage = null;
3148        public ArrayList<String> mAdoptPermissions = null;
3149
3150        // We store the application meta-data independently to avoid multiple unwanted references
3151        public Bundle mAppMetaData = null;
3152
3153        // If this is a 3rd party app, this is the path of the zip file.
3154        public String mPath;
3155
3156        // The version code declared for this package.
3157        public int mVersionCode;
3158
3159        // The version name declared for this package.
3160        public String mVersionName;
3161
3162        // The shared user id that this package wants to use.
3163        public String mSharedUserId;
3164
3165        // The shared user label that this package wants to use.
3166        public int mSharedUserLabel;
3167
3168        // Signatures that were read from the package.
3169        public Signature mSignatures[];
3170
3171        // For use by package manager service for quick lookup of
3172        // preferred up order.
3173        public int mPreferredOrder = 0;
3174
3175        // For use by the package manager to keep track of the path to the
3176        // file an app came from.
3177        public String mScanPath;
3178
3179        // For use by package manager to keep track of where it has done dexopt.
3180        public boolean mDidDexOpt;
3181
3182        // // User set enabled state.
3183        // public int mSetEnabled = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT;
3184        //
3185        // // Whether the package has been stopped.
3186        // public boolean mSetStopped = false;
3187
3188        // Additional data supplied by callers.
3189        public Object mExtras;
3190
3191        // Whether an operation is currently pending on this package
3192        public boolean mOperationPending;
3193
3194        /*
3195         *  Applications hardware preferences
3196         */
3197        public final ArrayList<ConfigurationInfo> configPreferences =
3198                new ArrayList<ConfigurationInfo>();
3199
3200        /*
3201         *  Applications requested features
3202         */
3203        public ArrayList<FeatureInfo> reqFeatures = null;
3204
3205        public int installLocation;
3206
3207        /**
3208         * Digest suitable for comparing whether this package's manifest is the
3209         * same as another.
3210         */
3211        public ManifestDigest manifestDigest;
3212
3213        public Package(String _name) {
3214            packageName = _name;
3215            applicationInfo.packageName = _name;
3216            applicationInfo.uid = -1;
3217        }
3218
3219        public void setPackageName(String newName) {
3220            packageName = newName;
3221            applicationInfo.packageName = newName;
3222            for (int i=permissions.size()-1; i>=0; i--) {
3223                permissions.get(i).setPackageName(newName);
3224            }
3225            for (int i=permissionGroups.size()-1; i>=0; i--) {
3226                permissionGroups.get(i).setPackageName(newName);
3227            }
3228            for (int i=activities.size()-1; i>=0; i--) {
3229                activities.get(i).setPackageName(newName);
3230            }
3231            for (int i=receivers.size()-1; i>=0; i--) {
3232                receivers.get(i).setPackageName(newName);
3233            }
3234            for (int i=providers.size()-1; i>=0; i--) {
3235                providers.get(i).setPackageName(newName);
3236            }
3237            for (int i=services.size()-1; i>=0; i--) {
3238                services.get(i).setPackageName(newName);
3239            }
3240            for (int i=instrumentation.size()-1; i>=0; i--) {
3241                instrumentation.get(i).setPackageName(newName);
3242            }
3243        }
3244
3245        public boolean hasComponentClassName(String name) {
3246            for (int i=activities.size()-1; i>=0; i--) {
3247                if (name.equals(activities.get(i).className)) {
3248                    return true;
3249                }
3250            }
3251            for (int i=receivers.size()-1; i>=0; i--) {
3252                if (name.equals(receivers.get(i).className)) {
3253                    return true;
3254                }
3255            }
3256            for (int i=providers.size()-1; i>=0; i--) {
3257                if (name.equals(providers.get(i).className)) {
3258                    return true;
3259                }
3260            }
3261            for (int i=services.size()-1; i>=0; i--) {
3262                if (name.equals(services.get(i).className)) {
3263                    return true;
3264                }
3265            }
3266            for (int i=instrumentation.size()-1; i>=0; i--) {
3267                if (name.equals(instrumentation.get(i).className)) {
3268                    return true;
3269                }
3270            }
3271            return false;
3272        }
3273
3274        public String toString() {
3275            return "Package{"
3276                + Integer.toHexString(System.identityHashCode(this))
3277                + " " + packageName + "}";
3278        }
3279    }
3280
3281    public static class Component<II extends IntentInfo> {
3282        public final Package owner;
3283        public final ArrayList<II> intents;
3284        public final String className;
3285        public Bundle metaData;
3286
3287        ComponentName componentName;
3288        String componentShortName;
3289
3290        public Component(Package _owner) {
3291            owner = _owner;
3292            intents = null;
3293            className = null;
3294        }
3295
3296        public Component(final ParsePackageItemArgs args, final PackageItemInfo outInfo) {
3297            owner = args.owner;
3298            intents = new ArrayList<II>(0);
3299            String name = args.sa.getNonConfigurationString(args.nameRes, 0);
3300            if (name == null) {
3301                className = null;
3302                args.outError[0] = args.tag + " does not specify android:name";
3303                return;
3304            }
3305
3306            outInfo.name
3307                = buildClassName(owner.applicationInfo.packageName, name, args.outError);
3308            if (outInfo.name == null) {
3309                className = null;
3310                args.outError[0] = args.tag + " does not have valid android:name";
3311                return;
3312            }
3313
3314            className = outInfo.name;
3315
3316            int iconVal = args.sa.getResourceId(args.iconRes, 0);
3317            if (iconVal != 0) {
3318                outInfo.icon = iconVal;
3319                outInfo.nonLocalizedLabel = null;
3320            }
3321
3322            int logoVal = args.sa.getResourceId(args.logoRes, 0);
3323            if (logoVal != 0) {
3324                outInfo.logo = logoVal;
3325            }
3326
3327            TypedValue v = args.sa.peekValue(args.labelRes);
3328            if (v != null && (outInfo.labelRes=v.resourceId) == 0) {
3329                outInfo.nonLocalizedLabel = v.coerceToString();
3330            }
3331
3332            outInfo.packageName = owner.packageName;
3333        }
3334
3335        public Component(final ParseComponentArgs args, final ComponentInfo outInfo) {
3336            this(args, (PackageItemInfo)outInfo);
3337            if (args.outError[0] != null) {
3338                return;
3339            }
3340
3341            if (args.processRes != 0) {
3342                CharSequence pname;
3343                if (owner.applicationInfo.targetSdkVersion >= Build.VERSION_CODES.FROYO) {
3344                    pname = args.sa.getNonConfigurationString(args.processRes, 0);
3345                } else {
3346                    // Some older apps have been seen to use a resource reference
3347                    // here that on older builds was ignored (with a warning).  We
3348                    // need to continue to do this for them so they don't break.
3349                    pname = args.sa.getNonResourceString(args.processRes);
3350                }
3351                outInfo.processName = buildProcessName(owner.applicationInfo.packageName,
3352                        owner.applicationInfo.processName, pname,
3353                        args.flags, args.sepProcesses, args.outError);
3354            }
3355
3356            if (args.descriptionRes != 0) {
3357                outInfo.descriptionRes = args.sa.getResourceId(args.descriptionRes, 0);
3358            }
3359
3360            outInfo.enabled = args.sa.getBoolean(args.enabledRes, true);
3361        }
3362
3363        public Component(Component<II> clone) {
3364            owner = clone.owner;
3365            intents = clone.intents;
3366            className = clone.className;
3367            componentName = clone.componentName;
3368            componentShortName = clone.componentShortName;
3369        }
3370
3371        public ComponentName getComponentName() {
3372            if (componentName != null) {
3373                return componentName;
3374            }
3375            if (className != null) {
3376                componentName = new ComponentName(owner.applicationInfo.packageName,
3377                        className);
3378            }
3379            return componentName;
3380        }
3381
3382        public String getComponentShortName() {
3383            if (componentShortName != null) {
3384                return componentShortName;
3385            }
3386            ComponentName component = getComponentName();
3387            if (component != null) {
3388                componentShortName = component.flattenToShortString();
3389            }
3390            return componentShortName;
3391        }
3392
3393        public void setPackageName(String packageName) {
3394            componentName = null;
3395            componentShortName = null;
3396        }
3397    }
3398
3399    public final static class Permission extends Component<IntentInfo> {
3400        public final PermissionInfo info;
3401        public boolean tree;
3402        public PermissionGroup group;
3403
3404        public Permission(Package _owner) {
3405            super(_owner);
3406            info = new PermissionInfo();
3407        }
3408
3409        public Permission(Package _owner, PermissionInfo _info) {
3410            super(_owner);
3411            info = _info;
3412        }
3413
3414        public void setPackageName(String packageName) {
3415            super.setPackageName(packageName);
3416            info.packageName = packageName;
3417        }
3418
3419        public String toString() {
3420            return "Permission{"
3421                + Integer.toHexString(System.identityHashCode(this))
3422                + " " + info.name + "}";
3423        }
3424    }
3425
3426    public final static class PermissionGroup extends Component<IntentInfo> {
3427        public final PermissionGroupInfo info;
3428
3429        public PermissionGroup(Package _owner) {
3430            super(_owner);
3431            info = new PermissionGroupInfo();
3432        }
3433
3434        public PermissionGroup(Package _owner, PermissionGroupInfo _info) {
3435            super(_owner);
3436            info = _info;
3437        }
3438
3439        public void setPackageName(String packageName) {
3440            super.setPackageName(packageName);
3441            info.packageName = packageName;
3442        }
3443
3444        public String toString() {
3445            return "PermissionGroup{"
3446                + Integer.toHexString(System.identityHashCode(this))
3447                + " " + info.name + "}";
3448        }
3449    }
3450
3451    private static boolean copyNeeded(int flags, Package p, int enabledState, Bundle metaData) {
3452        if (enabledState != PackageManager.COMPONENT_ENABLED_STATE_DEFAULT) {
3453            boolean enabled = enabledState == PackageManager.COMPONENT_ENABLED_STATE_ENABLED;
3454            if (p.applicationInfo.enabled != enabled) {
3455                return true;
3456            }
3457        }
3458        if ((flags & PackageManager.GET_META_DATA) != 0
3459                && (metaData != null || p.mAppMetaData != null)) {
3460            return true;
3461        }
3462        if ((flags & PackageManager.GET_SHARED_LIBRARY_FILES) != 0
3463                && p.usesLibraryFiles != null) {
3464            return true;
3465        }
3466        return false;
3467    }
3468
3469    public static ApplicationInfo generateApplicationInfo(Package p, int flags, boolean stopped,
3470            int enabledState) {
3471        return generateApplicationInfo(p, flags, stopped, enabledState, UserId.getCallingUserId());
3472    }
3473
3474    public static ApplicationInfo generateApplicationInfo(Package p, int flags,
3475            boolean stopped, int enabledState, int userId) {
3476        if (p == null) return null;
3477        if (!copyNeeded(flags, p, enabledState, null) && userId == 0) {
3478            // CompatibilityMode is global state. It's safe to modify the instance
3479            // of the package.
3480            if (!sCompatibilityModeEnabled) {
3481                p.applicationInfo.disableCompatibilityMode();
3482            }
3483            if (stopped) {
3484                p.applicationInfo.flags |= ApplicationInfo.FLAG_STOPPED;
3485            } else {
3486                p.applicationInfo.flags &= ~ApplicationInfo.FLAG_STOPPED;
3487            }
3488            if (enabledState == PackageManager.COMPONENT_ENABLED_STATE_ENABLED) {
3489                p.applicationInfo.enabled = true;
3490            } else if (enabledState == PackageManager.COMPONENT_ENABLED_STATE_DISABLED
3491                    || enabledState == PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER) {
3492                p.applicationInfo.enabled = false;
3493            }
3494            p.applicationInfo.enabledSetting = enabledState;
3495            return p.applicationInfo;
3496        }
3497
3498        // Make shallow copy so we can store the metadata/libraries safely
3499        ApplicationInfo ai = new ApplicationInfo(p.applicationInfo);
3500        if (userId != 0) {
3501            ai.uid = UserId.getUid(userId, ai.uid);
3502            ai.dataDir = PackageManager.getDataDirForUser(userId, ai.packageName);
3503        }
3504        if ((flags & PackageManager.GET_META_DATA) != 0) {
3505            ai.metaData = p.mAppMetaData;
3506        }
3507        if ((flags & PackageManager.GET_SHARED_LIBRARY_FILES) != 0) {
3508            ai.sharedLibraryFiles = p.usesLibraryFiles;
3509        }
3510        if (!sCompatibilityModeEnabled) {
3511            ai.disableCompatibilityMode();
3512        }
3513        if (stopped) {
3514            ai.flags |= ApplicationInfo.FLAG_STOPPED;
3515        } else {
3516            ai.flags &= ~ApplicationInfo.FLAG_STOPPED;
3517        }
3518        if (enabledState == PackageManager.COMPONENT_ENABLED_STATE_ENABLED) {
3519            ai.enabled = true;
3520        } else if (enabledState == PackageManager.COMPONENT_ENABLED_STATE_DISABLED
3521                || enabledState == PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER) {
3522            ai.enabled = false;
3523        }
3524        ai.enabledSetting = enabledState;
3525        return ai;
3526    }
3527
3528    public static final PermissionInfo generatePermissionInfo(
3529            Permission p, int flags) {
3530        if (p == null) return null;
3531        if ((flags&PackageManager.GET_META_DATA) == 0) {
3532            return p.info;
3533        }
3534        PermissionInfo pi = new PermissionInfo(p.info);
3535        pi.metaData = p.metaData;
3536        return pi;
3537    }
3538
3539    public static final PermissionGroupInfo generatePermissionGroupInfo(
3540            PermissionGroup pg, int flags) {
3541        if (pg == null) return null;
3542        if ((flags&PackageManager.GET_META_DATA) == 0) {
3543            return pg.info;
3544        }
3545        PermissionGroupInfo pgi = new PermissionGroupInfo(pg.info);
3546        pgi.metaData = pg.metaData;
3547        return pgi;
3548    }
3549
3550    public final static class Activity extends Component<ActivityIntentInfo> {
3551        public final ActivityInfo info;
3552
3553        public Activity(final ParseComponentArgs args, final ActivityInfo _info) {
3554            super(args, _info);
3555            info = _info;
3556            info.applicationInfo = args.owner.applicationInfo;
3557        }
3558
3559        public void setPackageName(String packageName) {
3560            super.setPackageName(packageName);
3561            info.packageName = packageName;
3562        }
3563
3564        public String toString() {
3565            return "Activity{"
3566                + Integer.toHexString(System.identityHashCode(this))
3567                + " " + getComponentShortName() + "}";
3568        }
3569    }
3570
3571    public static final ActivityInfo generateActivityInfo(Activity a, int flags, boolean stopped,
3572            int enabledState, int userId) {
3573        if (a == null) return null;
3574        if (!copyNeeded(flags, a.owner, enabledState, a.metaData) && userId == 0) {
3575            return a.info;
3576        }
3577        // Make shallow copies so we can store the metadata safely
3578        ActivityInfo ai = new ActivityInfo(a.info);
3579        ai.metaData = a.metaData;
3580        ai.applicationInfo = generateApplicationInfo(a.owner, flags, stopped, enabledState, userId);
3581        return ai;
3582    }
3583
3584    public final static class Service extends Component<ServiceIntentInfo> {
3585        public final ServiceInfo info;
3586
3587        public Service(final ParseComponentArgs args, final ServiceInfo _info) {
3588            super(args, _info);
3589            info = _info;
3590            info.applicationInfo = args.owner.applicationInfo;
3591        }
3592
3593        public void setPackageName(String packageName) {
3594            super.setPackageName(packageName);
3595            info.packageName = packageName;
3596        }
3597
3598        public String toString() {
3599            return "Service{"
3600                + Integer.toHexString(System.identityHashCode(this))
3601                + " " + getComponentShortName() + "}";
3602        }
3603    }
3604
3605    public static final ServiceInfo generateServiceInfo(Service s, int flags, boolean stopped,
3606            int enabledState, int userId) {
3607        if (s == null) return null;
3608        if (!copyNeeded(flags, s.owner, enabledState, s.metaData)
3609                && userId == UserId.getUserId(s.info.applicationInfo.uid)) {
3610            return s.info;
3611        }
3612        // Make shallow copies so we can store the metadata safely
3613        ServiceInfo si = new ServiceInfo(s.info);
3614        si.metaData = s.metaData;
3615        si.applicationInfo = generateApplicationInfo(s.owner, flags, stopped, enabledState, userId);
3616        return si;
3617    }
3618
3619    public final static class Provider extends Component {
3620        public final ProviderInfo info;
3621        public boolean syncable;
3622
3623        public Provider(final ParseComponentArgs args, final ProviderInfo _info) {
3624            super(args, _info);
3625            info = _info;
3626            info.applicationInfo = args.owner.applicationInfo;
3627            syncable = false;
3628        }
3629
3630        public Provider(Provider existingProvider) {
3631            super(existingProvider);
3632            this.info = existingProvider.info;
3633            this.syncable = existingProvider.syncable;
3634        }
3635
3636        public void setPackageName(String packageName) {
3637            super.setPackageName(packageName);
3638            info.packageName = packageName;
3639        }
3640
3641        public String toString() {
3642            return "Provider{"
3643                + Integer.toHexString(System.identityHashCode(this))
3644                + " " + info.name + "}";
3645        }
3646    }
3647
3648    public static final ProviderInfo generateProviderInfo(Provider p, int flags, boolean stopped,
3649            int enabledState, int userId) {
3650        if (p == null) return null;
3651        if (!copyNeeded(flags, p.owner, enabledState, p.metaData)
3652                && ((flags & PackageManager.GET_URI_PERMISSION_PATTERNS) != 0
3653                        || p.info.uriPermissionPatterns == null)
3654                && userId == 0) {
3655            return p.info;
3656        }
3657        // Make shallow copies so we can store the metadata safely
3658        ProviderInfo pi = new ProviderInfo(p.info);
3659        pi.metaData = p.metaData;
3660        if ((flags & PackageManager.GET_URI_PERMISSION_PATTERNS) == 0) {
3661            pi.uriPermissionPatterns = null;
3662        }
3663        pi.applicationInfo = generateApplicationInfo(p.owner, flags, stopped, enabledState, userId);
3664        return pi;
3665    }
3666
3667    public final static class Instrumentation extends Component {
3668        public final InstrumentationInfo info;
3669
3670        public Instrumentation(final ParsePackageItemArgs args, final InstrumentationInfo _info) {
3671            super(args, _info);
3672            info = _info;
3673        }
3674
3675        public void setPackageName(String packageName) {
3676            super.setPackageName(packageName);
3677            info.packageName = packageName;
3678        }
3679
3680        public String toString() {
3681            return "Instrumentation{"
3682                + Integer.toHexString(System.identityHashCode(this))
3683                + " " + getComponentShortName() + "}";
3684        }
3685    }
3686
3687    public static final InstrumentationInfo generateInstrumentationInfo(
3688            Instrumentation i, int flags) {
3689        if (i == null) return null;
3690        if ((flags&PackageManager.GET_META_DATA) == 0) {
3691            return i.info;
3692        }
3693        InstrumentationInfo ii = new InstrumentationInfo(i.info);
3694        ii.metaData = i.metaData;
3695        return ii;
3696    }
3697
3698    public static class IntentInfo extends IntentFilter {
3699        public boolean hasDefault;
3700        public int labelRes;
3701        public CharSequence nonLocalizedLabel;
3702        public int icon;
3703        public int logo;
3704    }
3705
3706    public final static class ActivityIntentInfo extends IntentInfo {
3707        public final Activity activity;
3708
3709        public ActivityIntentInfo(Activity _activity) {
3710            activity = _activity;
3711        }
3712
3713        public String toString() {
3714            return "ActivityIntentInfo{"
3715                + Integer.toHexString(System.identityHashCode(this))
3716                + " " + activity.info.name + "}";
3717        }
3718    }
3719
3720    public final static class ServiceIntentInfo extends IntentInfo {
3721        public final Service service;
3722
3723        public ServiceIntentInfo(Service _service) {
3724            service = _service;
3725        }
3726
3727        public String toString() {
3728            return "ServiceIntentInfo{"
3729                + Integer.toHexString(System.identityHashCode(this))
3730                + " " + service.info.name + "}";
3731        }
3732    }
3733
3734    /**
3735     * @hide
3736     */
3737    public static void setCompatibilityModeEnabled(boolean compatibilityModeEnabled) {
3738        sCompatibilityModeEnabled = compatibilityModeEnabled;
3739    }
3740}
3741