Examples with XmlSerializer org.xmlpull.v1.XmlSerializer used on opensource projects

Example 76 with XmlSerializer

use of org.xmlpull.v1.XmlSerializer in project android_frameworks_base by DirtyUnicorns.

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), StandardCharsets.UTF_8.name());
            saveToXml(serializer);
            serializer.flush();
            success = true;
        } finally {
            if (success) {
                mAtomicFile.finishWrite(os);
            } else {
                mAtomicFile.failWrite(os);
            }
        }
    } catch (IOException ex) {
        Slog.w(InputManagerService.TAG, "Failed to save input manager persistent store data.", ex);
    }
}

Example 77 with XmlSerializer

use of org.xmlpull.v1.XmlSerializer in project android_frameworks_base by DirtyUnicorns.

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;
    boolean checkin = false;
    String packageName = null;
    ArraySet<String> permissionNames = 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] [--checkin] [cmd] ...");
            pw.println("    --checkin: dump for a checkin");
            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[eatures]: list device features");
            pw.println("    k[eysets]: print known keysets");
            pw.println("    r[esolvers] [activity|service|receiver|content]: dump intent resolvers");
            pw.println("    perm[issions]: dump permissions");
            pw.println("    permission [name ...]: dump declaration and use of given permission");
            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("    d[omain-preferred-apps]: print domains preferred apps");
            pw.println("    i[ntent-filter-verifiers]|ifv: print intent filter verifier info");
            pw.println("    version: print database version info");
            pw.println("    write: write current settings now");
            pw.println("    installs: details about install sessions");
            pw.println("    check-permission <permission> <package> [<user>]: does pkg hold perm?");
            pw.println("    dexopt: dump dexopt state");
            pw.println("    compiler-stats: dump compiler statistics");
            pw.println("    <package.name>: info about given package");
            return;
        } else if ("--checkin".equals(opt)) {
            checkin = true;
        } 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;
            // When dumping a single package, we always dump all of its
            // filter information since the amount of data will be reasonable.
            dumpState.setOptionEnabled(DumpState.OPTION_SHOW_FILTERS);
        } else if ("check-permission".equals(cmd)) {
            if (opti >= args.length) {
                pw.println("Error: check-permission missing permission argument");
                return;
            }
            String perm = args[opti];
            opti++;
            if (opti >= args.length) {
                pw.println("Error: check-permission missing package argument");
                return;
            }
            String pkg = args[opti];
            opti++;
            int user = UserHandle.getUserId(Binder.getCallingUid());
            if (opti < args.length) {
                try {
                    user = Integer.parseInt(args[opti]);
                } catch (NumberFormatException e) {
                    pw.println("Error: check-permission user argument is not a number: " + args[opti]);
                    return;
                }
            }
            pw.println(checkPermission(perm, pkg, user));
            return;
        } 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)) {
            if (opti >= args.length) {
                dumpState.setDump(DumpState.DUMP_ACTIVITY_RESOLVERS | DumpState.DUMP_SERVICE_RESOLVERS | DumpState.DUMP_RECEIVER_RESOLVERS | DumpState.DUMP_CONTENT_RESOLVERS);
            } else {
                while (opti < args.length) {
                    String name = args[opti];
                    if ("a".equals(name) || "activity".equals(name)) {
                        dumpState.setDump(DumpState.DUMP_ACTIVITY_RESOLVERS);
                    } else if ("s".equals(name) || "service".equals(name)) {
                        dumpState.setDump(DumpState.DUMP_SERVICE_RESOLVERS);
                    } else if ("r".equals(name) || "receiver".equals(name)) {
                        dumpState.setDump(DumpState.DUMP_RECEIVER_RESOLVERS);
                    } else if ("c".equals(name) || "content".equals(name)) {
                        dumpState.setDump(DumpState.DUMP_CONTENT_RESOLVERS);
                    } else {
                        pw.println("Error: unknown resolver table type: " + name);
                        return;
                    }
                    opti++;
                }
            }
        } else if ("perm".equals(cmd) || "permissions".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_PERMISSIONS);
        } else if ("permission".equals(cmd)) {
            if (opti >= args.length) {
                pw.println("Error: permission requires permission name");
                return;
            }
            permissionNames = new ArraySet<>();
            while (opti < args.length) {
                permissionNames.add(args[opti]);
                opti++;
            }
            dumpState.setDump(DumpState.DUMP_PERMISSIONS | DumpState.DUMP_PACKAGES | DumpState.DUMP_SHARED_USERS);
        } 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 ("d".equals(cmd) || "domain-preferred-apps".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_DOMAIN_PREFERRED);
        } 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);
        } else if ("i".equals(cmd) || "ifv".equals(cmd) || "intent-filter-verifiers".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_INTENT_FILTER_VERIFIERS);
        } else if ("version".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_VERSION);
        } else if ("k".equals(cmd) || "keysets".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_KEYSETS);
        } else if ("installs".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_INSTALLS);
        } else if ("frozen".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_FROZEN);
        } else if ("dexopt".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_DEXOPT);
        } else if ("compiler-stats".equals(cmd)) {
            dumpState.setDump(DumpState.DUMP_COMPILER_STATS);
        } else if ("write".equals(cmd)) {
            synchronized (mPackages) {
                mSettings.writeLPr();
                pw.println("Settings written.");
                return;
            }
        }
    }
    if (checkin) {
        pw.println("vers,1");
    }
    // reader
    synchronized (mPackages) {
        if (dumpState.isDumping(DumpState.DUMP_VERSION) && packageName == null) {
            if (!checkin) {
                if (dumpState.onTitlePrinted())
                    pw.println();
                pw.println("Database versions:");
                mSettings.dumpVersionLPr(new IndentingPrintWriter(pw, "  "));
            }
        }
        if (dumpState.isDumping(DumpState.DUMP_VERIFIERS) && packageName == null) {
            if (!checkin) {
                if (dumpState.onTitlePrinted())
                    pw.println();
                pw.println("Verifiers:");
                pw.print("  Required: ");
                pw.print(mRequiredVerifierPackage);
                pw.print(" (uid=");
                pw.print(getPackageUid(mRequiredVerifierPackage, MATCH_DEBUG_TRIAGED_MISSING, UserHandle.USER_SYSTEM));
                pw.println(")");
            } else if (mRequiredVerifierPackage != null) {
                pw.print("vrfy,");
                pw.print(mRequiredVerifierPackage);
                pw.print(",");
                pw.println(getPackageUid(mRequiredVerifierPackage, MATCH_DEBUG_TRIAGED_MISSING, UserHandle.USER_SYSTEM));
            }
        }
        if (dumpState.isDumping(DumpState.DUMP_INTENT_FILTER_VERIFIERS) && packageName == null) {
            if (mIntentFilterVerifierComponent != null) {
                String verifierPackageName = mIntentFilterVerifierComponent.getPackageName();
                if (!checkin) {
                    if (dumpState.onTitlePrinted())
                        pw.println();
                    pw.println("Intent Filter Verifier:");
                    pw.print("  Using: ");
                    pw.print(verifierPackageName);
                    pw.print(" (uid=");
                    pw.print(getPackageUid(verifierPackageName, MATCH_DEBUG_TRIAGED_MISSING, UserHandle.USER_SYSTEM));
                    pw.println(")");
                } else if (verifierPackageName != null) {
                    pw.print("ifv,");
                    pw.print(verifierPackageName);
                    pw.print(",");
                    pw.println(getPackageUid(verifierPackageName, MATCH_DEBUG_TRIAGED_MISSING, UserHandle.USER_SYSTEM));
                }
            } else {
                pw.println();
                pw.println("No Intent Filter Verifier available!");
            }
        }
        if (dumpState.isDumping(DumpState.DUMP_LIBS) && packageName == null) {
            boolean printedHeader = false;
            final Iterator<String> it = mSharedLibraries.keySet().iterator();
            while (it.hasNext()) {
                String name = it.next();
                SharedLibraryEntry ent = mSharedLibraries.get(name);
                if (!checkin) {
                    if (!printedHeader) {
                        if (dumpState.onTitlePrinted())
                            pw.println();
                        pw.println("Libraries:");
                        printedHeader = true;
                    }
                    pw.print("  ");
                } else {
                    pw.print("lib,");
                }
                pw.print(name);
                if (!checkin) {
                    pw.print(" -> ");
                }
                if (ent.path != null) {
                    if (!checkin) {
                        pw.print("(jar) ");
                        pw.print(ent.path);
                    } else {
                        pw.print(",jar,");
                        pw.print(ent.path);
                    }
                } else {
                    if (!checkin) {
                        pw.print("(apk) ");
                        pw.print(ent.apk);
                    } else {
                        pw.print(",apk,");
                        pw.print(ent.apk);
                    }
                }
                pw.println();
            }
        }
        if (dumpState.isDumping(DumpState.DUMP_FEATURES) && packageName == null) {
            if (dumpState.onTitlePrinted())
                pw.println();
            if (!checkin) {
                pw.println("Features:");
            }
            for (FeatureInfo feat : mAvailableFeatures.values()) {
                if (checkin) {
                    pw.print("feat,");
                    pw.print(feat.name);
                    pw.print(",");
                    pw.println(feat.version);
                } else {
                    pw.print("  ");
                    pw.print(feat.name);
                    if (feat.version > 0) {
                        pw.print(" version=");
                        pw.print(feat.version);
                    }
                    pw.println();
                }
            }
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_ACTIVITY_RESOLVERS)) {
            if (mActivities.dump(pw, dumpState.getTitlePrinted() ? "\nActivity Resolver Table:" : "Activity Resolver Table:", "  ", packageName, dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS), true)) {
                dumpState.setTitlePrinted(true);
            }
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_RECEIVER_RESOLVERS)) {
            if (mReceivers.dump(pw, dumpState.getTitlePrinted() ? "\nReceiver Resolver Table:" : "Receiver Resolver Table:", "  ", packageName, dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS), true)) {
                dumpState.setTitlePrinted(true);
            }
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_SERVICE_RESOLVERS)) {
            if (mServices.dump(pw, dumpState.getTitlePrinted() ? "\nService Resolver Table:" : "Service Resolver Table:", "  ", packageName, dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS), true)) {
                dumpState.setTitlePrinted(true);
            }
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_CONTENT_RESOLVERS)) {
            if (mProviders.dump(pw, dumpState.getTitlePrinted() ? "\nProvider Resolver Table:" : "Provider Resolver Table:", "  ", packageName, dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS), true)) {
                dumpState.setTitlePrinted(true);
            }
        }
        if (!checkin && 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, true, false)) {
                    dumpState.setTitlePrinted(true);
                }
            }
        }
        if (!checkin && 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, StandardCharsets.UTF_8.name());
                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 (!checkin && dumpState.isDumping(DumpState.DUMP_DOMAIN_PREFERRED) && packageName == null) {
            pw.println();
            int count = mSettings.mPackages.size();
            if (count == 0) {
                pw.println("No applications!");
                pw.println();
            } else {
                final String prefix = "  ";
                Collection<PackageSetting> allPackageSettings = mSettings.mPackages.values();
                if (allPackageSettings.size() == 0) {
                    pw.println("No domain preferred apps!");
                    pw.println();
                } else {
                    pw.println("App verification status:");
                    pw.println();
                    count = 0;
                    for (PackageSetting ps : allPackageSettings) {
                        IntentFilterVerificationInfo ivi = ps.getIntentFilterVerificationInfo();
                        if (ivi == null || ivi.getPackageName() == null)
                            continue;
                        pw.println(prefix + "Package: " + ivi.getPackageName());
                        pw.println(prefix + "Domains: " + ivi.getDomainsString());
                        pw.println(prefix + "Status:  " + ivi.getStatusString());
                        pw.println();
                        count++;
                    }
                    if (count == 0) {
                        pw.println(prefix + "No app verification established.");
                        pw.println();
                    }
                    for (int userId : sUserManager.getUserIds()) {
                        pw.println("App linkages for user " + userId + ":");
                        pw.println();
                        count = 0;
                        for (PackageSetting ps : allPackageSettings) {
                            final long status = ps.getDomainVerificationStatusForUser(userId);
                            if (status >> 32 == INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_UNDEFINED) {
                                continue;
                            }
                            pw.println(prefix + "Package: " + ps.name);
                            pw.println(prefix + "Domains: " + dumpDomainString(ps.name));
                            String statusStr = IntentFilterVerificationInfo.getStatusStringFromValue(status);
                            pw.println(prefix + "Status:  " + statusStr);
                            pw.println();
                            count++;
                        }
                        if (count == 0) {
                            pw.println(prefix + "No configured app linkages.");
                            pw.println();
                        }
                    }
                }
            }
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_PERMISSIONS)) {
            mSettings.dumpPermissionsLPr(pw, packageName, permissionNames, dumpState);
            if (packageName == null && permissionNames == null) {
                for (int iperm = 0; iperm < mAppOpPermissionPackages.size(); iperm++) {
                    if (iperm == 0) {
                        if (dumpState.onTitlePrinted())
                            pw.println();
                        pw.println("AppOp Permissions:");
                    }
                    pw.print("  AppOp Permission ");
                    pw.print(mAppOpPermissionPackages.keyAt(iperm));
                    pw.println(":");
                    ArraySet<String> pkgs = mAppOpPermissionPackages.valueAt(iperm);
                    for (int ipkg = 0; ipkg < pkgs.size(); ipkg++) {
                        pw.print("    ");
                        pw.println(pkgs.valueAt(ipkg));
                    }
                }
            }
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_PROVIDERS)) {
            boolean printedSomething = false;
            for (PackageParser.Provider p : mProviders.mProviders.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("  ");
                p.printComponentShortName(pw);
                pw.println(":");
                pw.print("    ");
                pw.println(p.toString());
            }
            printedSomething = false;
            for (Map.Entry<String, PackageParser.Provider> entry : mProvidersByAuthority.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 (!checkin && dumpState.isDumping(DumpState.DUMP_KEYSETS)) {
            mSettings.mKeySetManagerService.dumpLPr(pw, packageName, dumpState);
        }
        if (dumpState.isDumping(DumpState.DUMP_PACKAGES)) {
            mSettings.dumpPackagesLPr(pw, packageName, permissionNames, dumpState, checkin);
        }
        if (dumpState.isDumping(DumpState.DUMP_SHARED_USERS)) {
            mSettings.dumpSharedUsersLPr(pw, packageName, permissionNames, dumpState, checkin);
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_PERMISSIONS) && packageName == null) {
            mSettings.dumpRestoredPermissionGrantsLPr(pw, dumpState);
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_INSTALLS) && packageName == null) {
            // the given package is involved with.
            if (dumpState.onTitlePrinted())
                pw.println();
            mInstallerService.dump(new IndentingPrintWriter(pw, "  ", 120));
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_FROZEN) && packageName == null) {
            // the given package is involved with.
            if (dumpState.onTitlePrinted())
                pw.println();
            final IndentingPrintWriter ipw = new IndentingPrintWriter(pw, "  ", 120);
            ipw.println();
            ipw.println("Frozen packages:");
            ipw.increaseIndent();
            if (mFrozenPackages.size() == 0) {
                ipw.println("(none)");
            } else {
                for (int i = 0; i < mFrozenPackages.size(); i++) {
                    ipw.println(mFrozenPackages.valueAt(i));
                }
            }
            ipw.decreaseIndent();
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_DEXOPT)) {
            if (dumpState.onTitlePrinted())
                pw.println();
            dumpDexoptStateLPr(pw, packageName);
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_COMPILER_STATS)) {
            if (dumpState.onTitlePrinted())
                pw.println();
            dumpCompilerStatsLPr(pw, packageName);
        }
        if (!checkin && dumpState.isDumping(DumpState.DUMP_MESSAGES) && packageName == null) {
            if (dumpState.onTitlePrinted())
                pw.println();
            mSettings.dumpReadMessagesLPr(pw, dumpState);
            pw.println();
            pw.println("Package warning messages:");
            BufferedReader in = null;
            String line = null;
            try {
                in = new BufferedReader(new FileReader(getSettingsProblemFile()));
                while ((line = in.readLine()) != null) {
                    if (line.contains("ignored: updated version"))
                        continue;
                    pw.println(line);
                }
            } catch (IOException ignored) {
            } finally {
                IoUtils.closeQuietly(in);
            }
        }
        if (checkin && dumpState.isDumping(DumpState.DUMP_MESSAGES)) {
            BufferedReader in = null;
            String line = null;
            try {
                in = new BufferedReader(new FileReader(getSettingsProblemFile()));
                while ((line = in.readLine()) != null) {
                    if (line.contains("ignored: updated version"))
                        continue;
                    pw.print("msg,");
                    pw.println(line);
                }
            } catch (IOException ignored) {
            } finally {
                IoUtils.closeQuietly(in);
            }
        }
    }
}

Example 78 with XmlSerializer

use of org.xmlpull.v1.XmlSerializer in project android_frameworks_base by DirtyUnicorns.

the class PackageManagerService method getPermissionGrantBackup.

@Override
public byte[] getPermissionGrantBackup(int userId) {
    if (Binder.getCallingUid() != Process.SYSTEM_UID) {
        throw new SecurityException("Only the system may call getPermissionGrantBackup()");
    }
    ByteArrayOutputStream dataStream = new ByteArrayOutputStream();
    try {
        final XmlSerializer serializer = new FastXmlSerializer();
        serializer.setOutput(dataStream, StandardCharsets.UTF_8.name());
        serializer.startDocument(null, true);
        serializer.startTag(null, TAG_PERMISSION_BACKUP);
        synchronized (mPackages) {
            serializeRuntimePermissionGrantsLPr(serializer, userId);
        }
        serializer.endTag(null, TAG_PERMISSION_BACKUP);
        serializer.endDocument();
        serializer.flush();
    } catch (Exception e) {
        if (DEBUG_BACKUP) {
            Slog.e(TAG, "Unable to write default apps for backup", e);
        }
        return null;
    }
    return dataStream.toByteArray();
}

Example 79 with XmlSerializer

use of org.xmlpull.v1.XmlSerializer in project android_frameworks_base by DirtyUnicorns.

the class MountService method writeSettingsLocked.

private void writeSettingsLocked() {
    FileOutputStream fos = null;
    try {
        fos = mSettingsFile.startWrite();
        XmlSerializer out = new FastXmlSerializer();
        out.setOutput(fos, StandardCharsets.UTF_8.name());
        out.startDocument(null, true);
        out.startTag(null, TAG_VOLUMES);
        writeIntAttribute(out, ATTR_VERSION, VERSION_FIX_PRIMARY);
        writeStringAttribute(out, ATTR_PRIMARY_STORAGE_UUID, mPrimaryStorageUuid);
        writeBooleanAttribute(out, ATTR_FORCE_ADOPTABLE, mForceAdoptable);
        final int size = mRecords.size();
        for (int i = 0; i < size; i++) {
            final VolumeRecord rec = mRecords.valueAt(i);
            writeVolumeRecord(out, rec);
        }
        out.endTag(null, TAG_VOLUMES);
        out.endDocument();
        mSettingsFile.finishWrite(fos);
    } catch (IOException e) {
        if (fos != null) {
            mSettingsFile.failWrite(fos);
        }
    }
}

Example 80 with XmlSerializer

use of org.xmlpull.v1.XmlSerializer in project android_frameworks_base by DirtyUnicorns.

the class AccountManagerBackupHelper method backupAccountAccessPermissions.

public byte[] backupAccountAccessPermissions(int userId) {
    final AccountManagerService.UserAccounts accounts = mAccountManagerService.getUserAccounts(userId);
    synchronized (accounts.cacheLock) {
        SQLiteDatabase db = accounts.openHelper.getReadableDatabase();
        try (Cursor cursor = db.rawQuery(ACCOUNT_ACCESS_GRANTS, null)) {
            if (cursor == null || !cursor.moveToFirst()) {
                return null;
            }
            final int nameColumnIdx = cursor.getColumnIndex(AccountManagerService.ACCOUNTS_NAME);
            final int uidColumnIdx = cursor.getColumnIndex(AccountManagerService.GRANTS_GRANTEE_UID);
            ByteArrayOutputStream dataStream = new ByteArrayOutputStream();
            try {
                final XmlSerializer serializer = new FastXmlSerializer();
                serializer.setOutput(dataStream, StandardCharsets.UTF_8.name());
                serializer.startDocument(null, true);
                serializer.startTag(null, TAG_PERMISSIONS);
                PackageManager packageManager = mAccountManagerService.mContext.getPackageManager();
                do {
                    final String accountName = cursor.getString(nameColumnIdx);
                    final int uid = cursor.getInt(uidColumnIdx);
                    final String[] packageNames = packageManager.getPackagesForUid(uid);
                    if (packageNames == null) {
                        continue;
                    }
                    for (String packageName : packageNames) {
                        String digest = PackageUtils.computePackageCertSha256Digest(packageManager, packageName, userId);
                        if (digest != null) {
                            serializer.startTag(null, TAG_PERMISSION);
                            serializer.attribute(null, ATTR_ACCOUNT_SHA_256, PackageUtils.computeSha256Digest(accountName.getBytes()));
                            serializer.attribute(null, ATTR_PACKAGE, packageName);
                            serializer.attribute(null, ATTR_DIGEST, digest);
                            serializer.endTag(null, TAG_PERMISSION);
                        }
                    }
                } while (cursor.moveToNext());
                serializer.endTag(null, TAG_PERMISSIONS);
                serializer.endDocument();
                serializer.flush();
            } catch (IOException e) {
                Log.e(TAG, "Error backing up account access grants", e);
                return null;
            }
            return dataStream.toByteArray();
        }
    }
}