Examples with FastXmlSerializer com.android.internal.util.FastXmlSerializer used on opensource projects

Example 21 with FastXmlSerializer

use of com.android.internal.util.FastXmlSerializer in project android_frameworks_base by ParanoidAndroid.

the class CompatModePackages method saveCompatModes.

void saveCompatModes() {
    HashMap<String, Integer> pkgs;
    synchronized (mService) {
        pkgs = new HashMap<String, Integer>(mPackages);
    }
    FileOutputStream fos = null;
    try {
        fos = mFile.startWrite();
        XmlSerializer out = new FastXmlSerializer();
        out.setOutput(fos, "utf-8");
        out.startDocument(null, true);
        out.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
        out.startTag(null, "compat-packages");
        final IPackageManager pm = AppGlobals.getPackageManager();
        final int screenLayout = mService.mConfiguration.screenLayout;
        final int smallestScreenWidthDp = mService.mConfiguration.smallestScreenWidthDp;
        final Iterator<Map.Entry<String, Integer>> it = pkgs.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<String, Integer> entry = it.next();
            String pkg = entry.getKey();
            int mode = entry.getValue();
            if (mode == 0) {
                continue;
            }
            ApplicationInfo ai = null;
            try {
                ai = pm.getApplicationInfo(pkg, 0, 0);
            } catch (RemoteException e) {
            }
            if (ai == null) {
                continue;
            }
            CompatibilityInfo info = new CompatibilityInfo(ai, screenLayout, smallestScreenWidthDp, false);
            if (info.alwaysSupportsScreen()) {
                continue;
            }
            if (info.neverSupportsScreen()) {
                continue;
            }
            out.startTag(null, "pkg");
            out.attribute(null, "name", pkg);
            out.attribute(null, "mode", Integer.toString(mode));
            out.endTag(null, "pkg");
        }
        out.endTag(null, "compat-packages");
        out.endDocument();
        mFile.finishWrite(fos);
    } catch (java.io.IOException e1) {
        Slog.w(TAG, "Error writing compat packages", e1);
        if (fos != null) {
            mFile.failWrite(fos);
        }
    }
}

Example 22 with FastXmlSerializer

use of com.android.internal.util.FastXmlSerializer in project android_frameworks_base by ParanoidAndroid.

the class PersistentDataStore method save.

private void save() {
    final FileOutputStream os;
    try {
        os = mAtomicFile.startWrite();
        boolean success = false;
        try {
            XmlSerializer serializer = new FastXmlSerializer();
            serializer.setOutput(new BufferedOutputStream(os), "utf-8");
            saveToXml(serializer);
            serializer.flush();
            success = true;
        } finally {
            if (success) {
                mAtomicFile.finishWrite(os);
            } else {
                mAtomicFile.failWrite(os);
            }
        }
    } catch (IOException ex) {
        Slog.w(TAG, "Failed to save display manager persistent store data.", ex);
    }
}

Example 23 with FastXmlSerializer

use of com.android.internal.util.FastXmlSerializer in project android_frameworks_base by ParanoidAndroid.

the class UserManagerService method writeApplicationRestrictionsLocked.

private void writeApplicationRestrictionsLocked(String packageName, Bundle restrictions, int userId) {
    FileOutputStream fos = null;
    AtomicFile restrictionsFile = new AtomicFile(new File(Environment.getUserSystemDirectory(userId), RESTRICTIONS_FILE_PREFIX + packageName + ".xml"));
    try {
        fos = restrictionsFile.startWrite();
        final BufferedOutputStream bos = new BufferedOutputStream(fos);
        // XmlSerializer serializer = XmlUtils.serializerInstance();
        final XmlSerializer serializer = new FastXmlSerializer();
        serializer.setOutput(bos, "utf-8");
        serializer.startDocument(null, true);
        serializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
        serializer.startTag(null, TAG_RESTRICTIONS);
        for (String key : restrictions.keySet()) {
            Object value = restrictions.get(key);
            serializer.startTag(null, TAG_ENTRY);
            serializer.attribute(null, ATTR_KEY, key);
            if (value instanceof Boolean) {
                serializer.attribute(null, ATTR_VALUE_TYPE, ATTR_TYPE_BOOLEAN);
                serializer.text(value.toString());
            } else if (value == null || value instanceof String) {
                serializer.attribute(null, ATTR_VALUE_TYPE, ATTR_TYPE_STRING);
                serializer.text(value != null ? (String) value : "");
            } else {
                serializer.attribute(null, ATTR_VALUE_TYPE, ATTR_TYPE_STRING_ARRAY);
                String[] values = (String[]) value;
                serializer.attribute(null, ATTR_MULTIPLE, Integer.toString(values.length));
                for (String choice : values) {
                    serializer.startTag(null, TAG_VALUE);
                    serializer.text(choice != null ? choice : "");
                    serializer.endTag(null, TAG_VALUE);
                }
            }
            serializer.endTag(null, TAG_ENTRY);
        }
        serializer.endTag(null, TAG_RESTRICTIONS);
        serializer.endDocument();
        restrictionsFile.finishWrite(fos);
    } catch (Exception e) {
        restrictionsFile.failWrite(fos);
        Slog.e(LOG_TAG, "Error writing application restrictions list");
    }
}

Example 24 with FastXmlSerializer

use of com.android.internal.util.FastXmlSerializer in project android_frameworks_base by ParanoidAndroid.

the class UserManagerService method writeUserLocked.

/*
     * Writes the user file in this format:
     *
     * <user flags="20039023" id="0">
     *   <name>Primary</name>
     * </user>
     */
private void writeUserLocked(UserInfo userInfo) {
    FileOutputStream fos = null;
    AtomicFile userFile = new AtomicFile(new File(mUsersDir, userInfo.id + ".xml"));
    try {
        fos = userFile.startWrite();
        final BufferedOutputStream bos = new BufferedOutputStream(fos);
        // XmlSerializer serializer = XmlUtils.serializerInstance();
        final XmlSerializer serializer = new FastXmlSerializer();
        serializer.setOutput(bos, "utf-8");
        serializer.startDocument(null, true);
        serializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
        serializer.startTag(null, TAG_USER);
        serializer.attribute(null, ATTR_ID, Integer.toString(userInfo.id));
        serializer.attribute(null, ATTR_SERIAL_NO, Integer.toString(userInfo.serialNumber));
        serializer.attribute(null, ATTR_FLAGS, Integer.toString(userInfo.flags));
        serializer.attribute(null, ATTR_CREATION_TIME, Long.toString(userInfo.creationTime));
        serializer.attribute(null, ATTR_LAST_LOGGED_IN_TIME, Long.toString(userInfo.lastLoggedInTime));
        if (userInfo.iconPath != null) {
            serializer.attribute(null, ATTR_ICON_PATH, userInfo.iconPath);
        }
        if (userInfo.partial) {
            serializer.attribute(null, ATTR_PARTIAL, "true");
        }
        serializer.startTag(null, TAG_NAME);
        serializer.text(userInfo.name);
        serializer.endTag(null, TAG_NAME);
        Bundle restrictions = mUserRestrictions.get(userInfo.id);
        if (restrictions != null) {
            serializer.startTag(null, TAG_RESTRICTIONS);
            writeBoolean(serializer, restrictions, UserManager.DISALLOW_CONFIG_WIFI);
            writeBoolean(serializer, restrictions, UserManager.DISALLOW_MODIFY_ACCOUNTS);
            writeBoolean(serializer, restrictions, UserManager.DISALLOW_INSTALL_APPS);
            writeBoolean(serializer, restrictions, UserManager.DISALLOW_UNINSTALL_APPS);
            writeBoolean(serializer, restrictions, UserManager.DISALLOW_SHARE_LOCATION);
            writeBoolean(serializer, restrictions, UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES);
            writeBoolean(serializer, restrictions, UserManager.DISALLOW_CONFIG_BLUETOOTH);
            writeBoolean(serializer, restrictions, UserManager.DISALLOW_USB_FILE_TRANSFER);
            writeBoolean(serializer, restrictions, UserManager.DISALLOW_CONFIG_CREDENTIALS);
            writeBoolean(serializer, restrictions, UserManager.DISALLOW_REMOVE_USER);
            serializer.endTag(null, TAG_RESTRICTIONS);
        }
        serializer.endTag(null, TAG_USER);
        serializer.endDocument();
        userFile.finishWrite(fos);
    } catch (Exception ioe) {
        Slog.e(LOG_TAG, "Error writing user info " + userInfo.id + "\n" + ioe);
        userFile.failWrite(fos);
    }
}

Example 25 with FastXmlSerializer

use of com.android.internal.util.FastXmlSerializer in project android_frameworks_base by ParanoidAndroid.

the class PackageManagerService method dump.

@Override
protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
    if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP) != PackageManager.PERMISSION_GRANTED) {
        pw.println("Permission Denial: can't dump ActivityManager from from pid=" + Binder.getCallingPid() + ", uid=" + Binder.getCallingUid() + " without permission " + android.Manifest.permission.DUMP);
        return;
    }
    DumpState dumpState = new DumpState();
    boolean fullPreferred = false;
    String packageName = null;
    int opti = 0;
    while (opti < args.length) {
        String opt = args[opti];
        if (opt == null || opt.length() <= 0 || opt.charAt(0) != '-') {
            break;
        }
        opti++;
        if ("-a".equals(opt)) {
        // Right now we only know how to print all.
        } else if ("-h".equals(opt)) {
            pw.println("Package manager dump options:");
            pw.println("  [-h] [-f] [cmd] ...");
            pw.println("    -f: print details of intent filters");
            pw.println("    -h: print this help");
            pw.println("  cmd may be one of:");
            pw.println("    l[ibraries]: list known shared libraries");
            pw.println("    f[ibraries]: list device features");
            pw.println("    r[esolvers]: dump intent resolvers");
            pw.println("    perm[issions]: dump permissions");
            pw.println("    pref[erred]: print preferred package settings");
            pw.println("    preferred-xml [--full]: print preferred package settings as xml");
            pw.println("    prov[iders]: dump content providers");
            pw.println("    p[ackages]: dump installed packages");
            pw.println("    s[hared-users]: dump shared user IDs");
            pw.println("    m[essages]: print collected runtime messages");
            pw.println("    v[erifiers]: print package verifier info");
            pw.println("    <package.name>: info about given package");
            return;
        } else if ("-f".equals(opt)) {
            dumpState.setOptionEnabled(DumpState.OPTION_SHOW_FILTERS);
        } else {
            pw.println("Unknown argument: " + opt + "; use -h for help");
        }
    }
    // Is the caller requesting to dump a particular piece of data?
    if (opti < args.length) {
        String cmd = args[opti];
        opti++;
        // Is this a package name?
        if ("android".equals(cmd) || cmd.contains(".")) {
            packageName = cmd;
        } else if ("l".equals(cmd) || "libraries".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_LIBS);
        } else if ("f".equals(cmd) || "features".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_FEATURES);
        } else if ("r".equals(cmd) || "resolvers".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_RESOLVERS);
        } else if ("perm".equals(cmd) || "permissions".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_PERMISSIONS);
        } else if ("pref".equals(cmd) || "preferred".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_PREFERRED);
        } else if ("preferred-xml".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_PREFERRED_XML);
            if (opti < args.length && "--full".equals(args[opti])) {
                fullPreferred = true;
                opti++;
            }
        } else if ("p".equals(cmd) || "packages".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_PACKAGES);
        } else if ("s".equals(cmd) || "shared-users".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_SHARED_USERS);
        } else if ("prov".equals(cmd) || "providers".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_PROVIDERS);
        } else if ("m".equals(cmd) || "messages".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_MESSAGES);
        } else if ("v".equals(cmd) || "verifiers".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_VERIFIERS);
        }
    }
    // reader
    synchronized (mPackages) {
        if (dumpState.isDumping(DumpState.DUMP_VERIFIERS) && packageName == null) {
            if (dumpState.onTitlePrinted())
                pw.println(" ");
            pw.println("Verifiers:");
            pw.print("  Required: ");
            pw.print(mRequiredVerifierPackage);
            pw.print(" (uid=");
            pw.print(getPackageUid(mRequiredVerifierPackage, 0));
            pw.println(")");
        }
        if (dumpState.isDumping(DumpState.DUMP_LIBS) && packageName == null) {
            if (dumpState.onTitlePrinted())
                pw.println(" ");
            pw.println("Libraries:");
            final Iterator<String> it = mSharedLibraries.keySet().iterator();
            while (it.hasNext()) {
                String name = it.next();
                pw.print("  ");
                pw.print(name);
                pw.print(" -> ");
                SharedLibraryEntry ent = mSharedLibraries.get(name);
                if (ent.path != null) {
                    pw.print("(jar) ");
                    pw.print(ent.path);
                } else {
                    pw.print("(apk) ");
                    pw.print(ent.apk);
                }
                pw.println();
            }
        }
        if (dumpState.isDumping(DumpState.DUMP_FEATURES) && packageName == null) {
            if (dumpState.onTitlePrinted())
                pw.println(" ");
            pw.println("Features:");
            Iterator<String> it = mAvailableFeatures.keySet().iterator();
            while (it.hasNext()) {
                String name = it.next();
                pw.print("  ");
                pw.println(name);
            }
        }
        if (dumpState.isDumping(DumpState.DUMP_RESOLVERS)) {
            if (mActivities.dump(pw, dumpState.getTitlePrinted() ? "\nActivity Resolver Table:" : "Activity Resolver Table:", "  ", packageName, dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS))) {
                dumpState.setTitlePrinted(true);
            }
            if (mReceivers.dump(pw, dumpState.getTitlePrinted() ? "\nReceiver Resolver Table:" : "Receiver Resolver Table:", "  ", packageName, dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS))) {
                dumpState.setTitlePrinted(true);
            }
            if (mServices.dump(pw, dumpState.getTitlePrinted() ? "\nService Resolver Table:" : "Service Resolver Table:", "  ", packageName, dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS))) {
                dumpState.setTitlePrinted(true);
            }
        }
        if (dumpState.isDumping(DumpState.DUMP_PREFERRED)) {
            for (int i = 0; i < mSettings.mPreferredActivities.size(); i++) {
                PreferredIntentResolver pir = mSettings.mPreferredActivities.valueAt(i);
                int user = mSettings.mPreferredActivities.keyAt(i);
                if (pir.dump(pw, dumpState.getTitlePrinted() ? "\nPreferred Activities User " + user + ":" : "Preferred Activities User " + user + ":", "  ", packageName, dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS))) {
                    dumpState.setTitlePrinted(true);
                }
            }
        }
        if (dumpState.isDumping(DumpState.DUMP_PREFERRED_XML)) {
            pw.flush();
            FileOutputStream fout = new FileOutputStream(fd);
            BufferedOutputStream str = new BufferedOutputStream(fout);
            XmlSerializer serializer = new FastXmlSerializer();
            try {
                serializer.setOutput(str, "utf-8");
                serializer.startDocument(null, true);
                serializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
                mSettings.writePreferredActivitiesLPr(serializer, 0, fullPreferred);
                serializer.endDocument();
                serializer.flush();
            } catch (IllegalArgumentException e) {
                pw.println("Failed writing: " + e);
            } catch (IllegalStateException e) {
                pw.println("Failed writing: " + e);
            } catch (IOException e) {
                pw.println("Failed writing: " + e);
            }
        }
        if (dumpState.isDumping(DumpState.DUMP_PERMISSIONS)) {
            mSettings.dumpPermissionsLPr(pw, packageName, dumpState);
        }
        if (dumpState.isDumping(DumpState.DUMP_PROVIDERS)) {
            boolean printedSomething = false;
            for (PackageParser.Provider p : mProvidersByComponent.values()) {
                if (packageName != null && !packageName.equals(p.info.packageName)) {
                    continue;
                }
                if (!printedSomething) {
                    if (dumpState.onTitlePrinted())
                        pw.println(" ");
                    pw.println("Registered ContentProviders:");
                    printedSomething = true;
                }
                pw.print("  ");
                pw.print(p.getComponentShortName());
                pw.println(":");
                pw.print("    ");
                pw.println(p.toString());
            }
            printedSomething = false;
            for (Map.Entry<String, PackageParser.Provider> entry : mProviders.entrySet()) {
                PackageParser.Provider p = entry.getValue();
                if (packageName != null && !packageName.equals(p.info.packageName)) {
                    continue;
                }
                if (!printedSomething) {
                    if (dumpState.onTitlePrinted())
                        pw.println(" ");
                    pw.println("ContentProvider Authorities:");
                    printedSomething = true;
                }
                pw.print("  [");
                pw.print(entry.getKey());
                pw.println("]:");
                pw.print("    ");
                pw.println(p.toString());
                if (p.info != null && p.info.applicationInfo != null) {
                    final String appInfo = p.info.applicationInfo.toString();
                    pw.print("      applicationInfo=");
                    pw.println(appInfo);
                }
            }
        }
        if (dumpState.isDumping(DumpState.DUMP_PACKAGES)) {
            mSettings.dumpPackagesLPr(pw, packageName, dumpState);
        }
        if (dumpState.isDumping(DumpState.DUMP_SHARED_USERS)) {
            mSettings.dumpSharedUsersLPr(pw, packageName, dumpState);
        }
        if (dumpState.isDumping(DumpState.DUMP_MESSAGES) && packageName == null) {
            if (dumpState.onTitlePrinted())
                pw.println(" ");
            mSettings.dumpReadMessagesLPr(pw, dumpState);
            pw.println(" ");
            pw.println("Package warning messages:");
            final File fname = getSettingsProblemFile();
            FileInputStream in = null;
            try {
                in = new FileInputStream(fname);
                final int avail = in.available();
                final byte[] data = new byte[avail];
                in.read(data);
                pw.print(new String(data));
            } catch (FileNotFoundException e) {
            } catch (IOException e) {
            } finally {
                if (in != null) {
                    try {
                        in.close();
                    } catch (IOException e) {
                    }
                }
            }
        }
    }
}