Examples with START_TAG org.xmlpull.v1.XmlPullParser.START_TAG used on opensource projects

Example 26 with START_TAG

use of org.xmlpull.v1.XmlPullParser.START_TAG in project platform_frameworks_base by android.

the class NetworkPolicyManagerService method readPolicyAL.

private void readPolicyAL() {
    if (LOGV)
        Slog.v(TAG, "readPolicyAL()");
    // clear any existing policy and read from disk
    mNetworkPolicy.clear();
    mUidPolicy.clear();
    FileInputStream fis = null;
    try {
        fis = mPolicyFile.openRead();
        final XmlPullParser in = Xml.newPullParser();
        in.setInput(fis, StandardCharsets.UTF_8.name());
        int type;
        int version = VERSION_INIT;
        boolean insideWhitelist = false;
        while ((type = in.next()) != END_DOCUMENT) {
            final String tag = in.getName();
            if (type == START_TAG) {
                if (TAG_POLICY_LIST.equals(tag)) {
                    final boolean oldValue = mRestrictBackground;
                    version = readIntAttribute(in, ATTR_VERSION);
                    if (version >= VERSION_ADDED_RESTRICT_BACKGROUND) {
                        mRestrictBackground = readBooleanAttribute(in, ATTR_RESTRICT_BACKGROUND);
                    } else {
                        mRestrictBackground = false;
                    }
                    if (mRestrictBackground != oldValue) {
                        // Some early services may have read the default value,
                        // so notify them that it's changed
                        mHandler.obtainMessage(MSG_RESTRICT_BACKGROUND_CHANGED, mRestrictBackground ? 1 : 0, 0).sendToTarget();
                    }
                } else if (TAG_NETWORK_POLICY.equals(tag)) {
                    final int networkTemplate = readIntAttribute(in, ATTR_NETWORK_TEMPLATE);
                    final String subscriberId = in.getAttributeValue(null, ATTR_SUBSCRIBER_ID);
                    final String networkId;
                    if (version >= VERSION_ADDED_NETWORK_ID) {
                        networkId = in.getAttributeValue(null, ATTR_NETWORK_ID);
                    } else {
                        networkId = null;
                    }
                    final int cycleDay = readIntAttribute(in, ATTR_CYCLE_DAY);
                    final String cycleTimezone;
                    if (version >= VERSION_ADDED_TIMEZONE) {
                        cycleTimezone = in.getAttributeValue(null, ATTR_CYCLE_TIMEZONE);
                    } else {
                        cycleTimezone = Time.TIMEZONE_UTC;
                    }
                    final long warningBytes = readLongAttribute(in, ATTR_WARNING_BYTES);
                    final long limitBytes = readLongAttribute(in, ATTR_LIMIT_BYTES);
                    final long lastLimitSnooze;
                    if (version >= VERSION_SPLIT_SNOOZE) {
                        lastLimitSnooze = readLongAttribute(in, ATTR_LAST_LIMIT_SNOOZE);
                    } else if (version >= VERSION_ADDED_SNOOZE) {
                        lastLimitSnooze = readLongAttribute(in, ATTR_LAST_SNOOZE);
                    } else {
                        lastLimitSnooze = SNOOZE_NEVER;
                    }
                    final boolean metered;
                    if (version >= VERSION_ADDED_METERED) {
                        metered = readBooleanAttribute(in, ATTR_METERED);
                    } else {
                        switch(networkTemplate) {
                            case MATCH_MOBILE_3G_LOWER:
                            case MATCH_MOBILE_4G:
                            case MATCH_MOBILE_ALL:
                                metered = true;
                                break;
                            default:
                                metered = false;
                        }
                    }
                    final long lastWarningSnooze;
                    if (version >= VERSION_SPLIT_SNOOZE) {
                        lastWarningSnooze = readLongAttribute(in, ATTR_LAST_WARNING_SNOOZE);
                    } else {
                        lastWarningSnooze = SNOOZE_NEVER;
                    }
                    final boolean inferred;
                    if (version >= VERSION_ADDED_INFERRED) {
                        inferred = readBooleanAttribute(in, ATTR_INFERRED);
                    } else {
                        inferred = false;
                    }
                    final NetworkTemplate template = new NetworkTemplate(networkTemplate, subscriberId, networkId);
                    if (template.isPersistable()) {
                        mNetworkPolicy.put(template, new NetworkPolicy(template, cycleDay, cycleTimezone, warningBytes, limitBytes, lastWarningSnooze, lastLimitSnooze, metered, inferred));
                    }
                } else if (TAG_UID_POLICY.equals(tag)) {
                    final int uid = readIntAttribute(in, ATTR_UID);
                    final int policy = readIntAttribute(in, ATTR_POLICY);
                    if (UserHandle.isApp(uid)) {
                        setUidPolicyUncheckedUL(uid, policy, false);
                    } else {
                        Slog.w(TAG, "unable to apply policy to UID " + uid + "; ignoring");
                    }
                } else if (TAG_APP_POLICY.equals(tag)) {
                    final int appId = readIntAttribute(in, ATTR_APP_ID);
                    final int policy = readIntAttribute(in, ATTR_POLICY);
                    // TODO: set for other users during upgrade
                    // app policy is deprecated so this is only used in pre system user split.
                    final int uid = UserHandle.getUid(UserHandle.USER_SYSTEM, appId);
                    if (UserHandle.isApp(uid)) {
                        setUidPolicyUncheckedUL(uid, policy, false);
                    } else {
                        Slog.w(TAG, "unable to apply policy to UID " + uid + "; ignoring");
                    }
                } else if (TAG_WHITELIST.equals(tag)) {
                    insideWhitelist = true;
                } else if (TAG_RESTRICT_BACKGROUND.equals(tag) && insideWhitelist) {
                    final int uid = readIntAttribute(in, ATTR_UID);
                    mRestrictBackgroundWhitelistUids.put(uid, true);
                } else if (TAG_REVOKED_RESTRICT_BACKGROUND.equals(tag) && insideWhitelist) {
                    final int uid = readIntAttribute(in, ATTR_UID);
                    mRestrictBackgroundWhitelistRevokedUids.put(uid, true);
                }
            } else if (type == END_TAG) {
                if (TAG_WHITELIST.equals(tag)) {
                    insideWhitelist = false;
                }
            }
        }
    } catch (FileNotFoundException e) {
        // missing policy is okay, probably first boot
        upgradeLegacyBackgroundDataUL();
    } catch (IOException e) {
        Log.wtf(TAG, "problem reading network policy", e);
    } catch (XmlPullParserException e) {
        Log.wtf(TAG, "problem reading network policy", e);
    } finally {
        IoUtils.closeQuietly(fis);
    }
}

Example 27 with START_TAG

use of org.xmlpull.v1.XmlPullParser.START_TAG in project android_frameworks_base by DirtyUnicorns.

the class MountService method readSettingsLocked.

private void readSettingsLocked() {
    mRecords.clear();
    mPrimaryStorageUuid = getDefaultPrimaryStorageUuid();
    mForceAdoptable = false;
    FileInputStream fis = null;
    try {
        fis = mSettingsFile.openRead();
        final XmlPullParser in = Xml.newPullParser();
        in.setInput(fis, StandardCharsets.UTF_8.name());
        int type;
        while ((type = in.next()) != END_DOCUMENT) {
            if (type == START_TAG) {
                final String tag = in.getName();
                if (TAG_VOLUMES.equals(tag)) {
                    final int version = readIntAttribute(in, ATTR_VERSION, VERSION_INIT);
                    final boolean primaryPhysical = SystemProperties.getBoolean(StorageManager.PROP_PRIMARY_PHYSICAL, false);
                    final boolean validAttr = (version >= VERSION_FIX_PRIMARY) || (version >= VERSION_ADD_PRIMARY && !primaryPhysical);
                    if (validAttr) {
                        mPrimaryStorageUuid = readStringAttribute(in, ATTR_PRIMARY_STORAGE_UUID);
                    }
                    mForceAdoptable = readBooleanAttribute(in, ATTR_FORCE_ADOPTABLE, false);
                } else if (TAG_VOLUME.equals(tag)) {
                    final VolumeRecord rec = readVolumeRecord(in);
                    mRecords.put(rec.fsUuid, rec);
                }
            }
        }
    } catch (FileNotFoundException e) {
    // Missing metadata is okay, probably first boot
    } catch (IOException e) {
        Slog.wtf(TAG, "Failed reading metadata", e);
    } catch (XmlPullParserException e) {
        Slog.wtf(TAG, "Failed reading metadata", e);
    } finally {
        IoUtils.closeQuietly(fis);
    }
}

Example 28 with START_TAG

use of org.xmlpull.v1.XmlPullParser.START_TAG in project android_frameworks_base by DirtyUnicorns.

the class ActivityRecord method restoreFromXml.

static ActivityRecord restoreFromXml(XmlPullParser in, ActivityStackSupervisor stackSupervisor) throws IOException, XmlPullParserException {
    Intent intent = null;
    PersistableBundle persistentState = null;
    int launchedFromUid = 0;
    String launchedFromPackage = null;
    String resolvedType = null;
    boolean componentSpecified = false;
    int userId = 0;
    long createTime = -1;
    final int outerDepth = in.getDepth();
    TaskDescription taskDescription = new TaskDescription();
    for (int attrNdx = in.getAttributeCount() - 1; attrNdx >= 0; --attrNdx) {
        final String attrName = in.getAttributeName(attrNdx);
        final String attrValue = in.getAttributeValue(attrNdx);
        if (TaskPersister.DEBUG)
            Slog.d(TaskPersister.TAG, "ActivityRecord: attribute name=" + attrName + " value=" + attrValue);
        if (ATTR_ID.equals(attrName)) {
            createTime = Long.valueOf(attrValue);
        } else if (ATTR_LAUNCHEDFROMUID.equals(attrName)) {
            launchedFromUid = Integer.parseInt(attrValue);
        } else if (ATTR_LAUNCHEDFROMPACKAGE.equals(attrName)) {
            launchedFromPackage = attrValue;
        } else if (ATTR_RESOLVEDTYPE.equals(attrName)) {
            resolvedType = attrValue;
        } else if (ATTR_COMPONENTSPECIFIED.equals(attrName)) {
            componentSpecified = Boolean.valueOf(attrValue);
        } else if (ATTR_USERID.equals(attrName)) {
            userId = Integer.parseInt(attrValue);
        } else if (attrName.startsWith(TaskDescription.ATTR_TASKDESCRIPTION_PREFIX)) {
            taskDescription.restoreFromXml(attrName, attrValue);
        } else {
            Log.d(TAG, "Unknown ActivityRecord attribute=" + attrName);
        }
    }
    int event;
    while (((event = in.next()) != XmlPullParser.END_DOCUMENT) && (event != XmlPullParser.END_TAG || in.getDepth() >= outerDepth)) {
        if (event == XmlPullParser.START_TAG) {
            final String name = in.getName();
            if (TaskPersister.DEBUG)
                Slog.d(TaskPersister.TAG, "ActivityRecord: START_TAG name=" + name);
            if (TAG_INTENT.equals(name)) {
                intent = Intent.restoreFromXml(in);
                if (TaskPersister.DEBUG)
                    Slog.d(TaskPersister.TAG, "ActivityRecord: intent=" + intent);
            } else if (TAG_PERSISTABLEBUNDLE.equals(name)) {
                persistentState = PersistableBundle.restoreFromXml(in);
                if (TaskPersister.DEBUG)
                    Slog.d(TaskPersister.TAG, "ActivityRecord: persistentState=" + persistentState);
            } else {
                Slog.w(TAG, "restoreActivity: unexpected name=" + name);
                XmlUtils.skipCurrentTag(in);
            }
        }
    }
    if (intent == null) {
        throw new XmlPullParserException("restoreActivity error intent=" + intent);
    }
    final ActivityManagerService service = stackSupervisor.mService;
    final ActivityInfo aInfo = stackSupervisor.resolveActivity(intent, resolvedType, 0, null, userId);
    if (aInfo == null) {
        throw new XmlPullParserException("restoreActivity resolver error. Intent=" + intent + " resolvedType=" + resolvedType);
    }
    final ActivityRecord r = new ActivityRecord(service, /*caller*/
    null, launchedFromUid, launchedFromPackage, intent, resolvedType, aInfo, service.getConfiguration(), null, null, 0, componentSpecified, false, stackSupervisor, null, null, null);
    r.persistentState = persistentState;
    r.taskDescription = taskDescription;
    r.createTime = createTime;
    return r;
}

Example 29 with START_TAG

use of org.xmlpull.v1.XmlPullParser.START_TAG in project android_frameworks_base by DirtyUnicorns.

the class ActivityManagerService method readGrantedUriPermissionsLocked.

private void readGrantedUriPermissionsLocked() {
    if (DEBUG_URI_PERMISSION)
        Slog.v(TAG_URI_PERMISSION, "readGrantedUriPermissions()");
    final long now = System.currentTimeMillis();
    FileInputStream fis = null;
    try {
        fis = mGrantFile.openRead();
        final XmlPullParser in = Xml.newPullParser();
        in.setInput(fis, StandardCharsets.UTF_8.name());
        int type;
        while ((type = in.next()) != END_DOCUMENT) {
            final String tag = in.getName();
            if (type == START_TAG) {
                if (TAG_URI_GRANT.equals(tag)) {
                    final int sourceUserId;
                    final int targetUserId;
                    final int userHandle = readIntAttribute(in, ATTR_USER_HANDLE, UserHandle.USER_NULL);
                    if (userHandle != UserHandle.USER_NULL) {
                        // For backwards compatibility.
                        sourceUserId = userHandle;
                        targetUserId = userHandle;
                    } else {
                        sourceUserId = readIntAttribute(in, ATTR_SOURCE_USER_ID);
                        targetUserId = readIntAttribute(in, ATTR_TARGET_USER_ID);
                    }
                    final String sourcePkg = in.getAttributeValue(null, ATTR_SOURCE_PKG);
                    final String targetPkg = in.getAttributeValue(null, ATTR_TARGET_PKG);
                    final Uri uri = Uri.parse(in.getAttributeValue(null, ATTR_URI));
                    final boolean prefix = readBooleanAttribute(in, ATTR_PREFIX);
                    final int modeFlags = readIntAttribute(in, ATTR_MODE_FLAGS);
                    final long createdTime = readLongAttribute(in, ATTR_CREATED_TIME, now);
                    // Sanity check that provider still belongs to source package
                    // Both direct boot aware and unaware packages are fine as we
                    // will do filtering at query time to avoid multiple parsing.
                    final ProviderInfo pi = getProviderInfoLocked(uri.getAuthority(), sourceUserId, MATCH_DIRECT_BOOT_AWARE | MATCH_DIRECT_BOOT_UNAWARE);
                    if (pi != null && sourcePkg.equals(pi.packageName)) {
                        int targetUid = -1;
                        try {
                            targetUid = AppGlobals.getPackageManager().getPackageUid(targetPkg, MATCH_UNINSTALLED_PACKAGES, targetUserId);
                        } catch (RemoteException e) {
                        }
                        if (targetUid != -1) {
                            final UriPermission perm = findOrCreateUriPermissionLocked(sourcePkg, targetPkg, targetUid, new GrantUri(sourceUserId, uri, prefix));
                            perm.initPersistedModes(modeFlags, createdTime);
                        }
                    } else {
                        Slog.w(TAG, "Persisted grant for " + uri + " had source " + sourcePkg + " but instead found " + pi);
                    }
                }
            }
        }
    } catch (FileNotFoundException e) {
    // Missing grants is okay
    } catch (IOException e) {
        Slog.wtf(TAG, "Failed reading Uri grants", e);
    } catch (XmlPullParserException e) {
        Slog.wtf(TAG, "Failed reading Uri grants", e);
    } finally {
        IoUtils.closeQuietly(fis);
    }
}

Example 30 with START_TAG

use of org.xmlpull.v1.XmlPullParser.START_TAG in project android_frameworks_base by DirtyUnicorns.

the class TaskPersister method restoreTasksForUserLocked.

List<TaskRecord> restoreTasksForUserLocked(final int userId) {
    final ArrayList<TaskRecord> tasks = new ArrayList<TaskRecord>();
    ArraySet<Integer> recoveredTaskIds = new ArraySet<Integer>();
    File userTasksDir = getUserTasksDir(userId);
    File[] recentFiles = userTasksDir.listFiles();
    if (recentFiles == null) {
        Slog.e(TAG, "restoreTasksForUserLocked: Unable to list files from " + userTasksDir);
        return tasks;
    }
    for (int taskNdx = 0; taskNdx < recentFiles.length; ++taskNdx) {
        File taskFile = recentFiles[taskNdx];
        if (DEBUG) {
            Slog.d(TAG, "restoreTasksForUserLocked: userId=" + userId + ", taskFile=" + taskFile.getName());
        }
        BufferedReader reader = null;
        boolean deleteFile = false;
        try {
            reader = new BufferedReader(new FileReader(taskFile));
            final XmlPullParser in = Xml.newPullParser();
            in.setInput(reader);
            int event;
            while (((event = in.next()) != XmlPullParser.END_DOCUMENT) && event != XmlPullParser.END_TAG) {
                final String name = in.getName();
                if (event == XmlPullParser.START_TAG) {
                    if (DEBUG)
                        Slog.d(TAG, "restoreTasksForUserLocked: START_TAG name=" + name);
                    if (TAG_TASK.equals(name)) {
                        final TaskRecord task = TaskRecord.restoreFromXml(in, mStackSupervisor);
                        if (DEBUG)
                            Slog.d(TAG, "restoreTasksForUserLocked: restored task=" + task);
                        if (task != null) {
                            // XXX Don't add to write queue... there is no reason to write
                            // out the stuff we just read, if we don't write it we will
                            // read the same thing again.
                            // mWriteQueue.add(new TaskWriteQueueItem(task));
                            final int taskId = task.taskId;
                            if (mStackSupervisor.anyTaskForIdLocked(taskId, /* restoreFromRecents= */
                            false, 0) != null) {
                                // Should not happen.
                                Slog.wtf(TAG, "Existing task with taskId " + taskId + "found");
                            } else if (userId != task.userId) {
                                // Should not happen.
                                Slog.wtf(TAG, "Task with userId " + task.userId + " found in " + userTasksDir.getAbsolutePath());
                            } else {
                                // Looks fine.
                                mStackSupervisor.setNextTaskIdForUserLocked(taskId, userId);
                                task.isPersistable = true;
                                tasks.add(task);
                                recoveredTaskIds.add(taskId);
                            }
                        } else {
                            Slog.e(TAG, "restoreTasksForUserLocked: Unable to restore taskFile=" + taskFile + ": " + fileToString(taskFile));
                        }
                    } else {
                        Slog.wtf(TAG, "restoreTasksForUserLocked: Unknown xml event=" + event + " name=" + name);
                    }
                }
                XmlUtils.skipCurrentTag(in);
            }
        } catch (Exception e) {
            Slog.wtf(TAG, "Unable to parse " + taskFile + ". Error ", e);
            Slog.e(TAG, "Failing file: " + fileToString(taskFile));
            deleteFile = true;
        } finally {
            IoUtils.closeQuietly(reader);
            if (deleteFile) {
                if (DEBUG)
                    Slog.d(TAG, "Deleting file=" + taskFile.getName());
                taskFile.delete();
            }
        }
    }
    if (!DEBUG) {
        removeObsoleteFiles(recoveredTaskIds, userTasksDir.listFiles());
    }
    // Fix up task affiliation from taskIds
    for (int taskNdx = tasks.size() - 1; taskNdx >= 0; --taskNdx) {
        final TaskRecord task = tasks.get(taskNdx);
        task.setPrevAffiliate(taskIdToTask(task.mPrevAffiliateTaskId, tasks));
        task.setNextAffiliate(taskIdToTask(task.mNextAffiliateTaskId, tasks));
    }
    Collections.sort(tasks, new Comparator<TaskRecord>() {

        @Override
        public int compare(TaskRecord lhs, TaskRecord rhs) {
            final long diff = rhs.mLastTimeMoved - lhs.mLastTimeMoved;
            if (diff < 0) {
                return -1;
            } else if (diff > 0) {
                return +1;
            } else {
                return 0;
            }
        }
    });
    return tasks;
}