Examples with ArrayMap android.util.ArrayMap used on opensource projects

Example 66 with ArrayMap

use of android.util.ArrayMap in project platform_frameworks_base by android.

the class ActivityManagerService method dumpAssociationsLocked.

void dumpAssociationsLocked(FileDescriptor fd, PrintWriter pw, String[] args, int opti, boolean dumpAll, boolean dumpClient, String dumpPackage) {
    pw.println("ACTIVITY MANAGER ASSOCIATIONS (dumpsys activity associations)");
    int dumpUid = 0;
    if (dumpPackage != null) {
        IPackageManager pm = AppGlobals.getPackageManager();
        try {
            dumpUid = pm.getPackageUid(dumpPackage, MATCH_UNINSTALLED_PACKAGES, 0);
        } catch (RemoteException e) {
        }
    }
    boolean printedAnything = false;
    final long now = SystemClock.uptimeMillis();
    for (int i1 = 0, N1 = mAssociations.size(); i1 < N1; i1++) {
        ArrayMap<ComponentName, SparseArray<ArrayMap<String, Association>>> targetComponents = mAssociations.valueAt(i1);
        for (int i2 = 0, N2 = targetComponents.size(); i2 < N2; i2++) {
            SparseArray<ArrayMap<String, Association>> sourceUids = targetComponents.valueAt(i2);
            for (int i3 = 0, N3 = sourceUids.size(); i3 < N3; i3++) {
                ArrayMap<String, Association> sourceProcesses = sourceUids.valueAt(i3);
                for (int i4 = 0, N4 = sourceProcesses.size(); i4 < N4; i4++) {
                    Association ass = sourceProcesses.valueAt(i4);
                    if (dumpPackage != null) {
                        if (!ass.mTargetComponent.getPackageName().equals(dumpPackage) && UserHandle.getAppId(ass.mSourceUid) != dumpUid) {
                            continue;
                        }
                    }
                    printedAnything = true;
                    pw.print("  ");
                    pw.print(ass.mTargetProcess);
                    pw.print("/");
                    UserHandle.formatUid(pw, ass.mTargetUid);
                    pw.print(" <- ");
                    pw.print(ass.mSourceProcess);
                    pw.print("/");
                    UserHandle.formatUid(pw, ass.mSourceUid);
                    pw.println();
                    pw.print("    via ");
                    pw.print(ass.mTargetComponent.flattenToShortString());
                    pw.println();
                    pw.print("    ");
                    long dur = ass.mTime;
                    if (ass.mNesting > 0) {
                        dur += now - ass.mStartTime;
                    }
                    TimeUtils.formatDuration(dur, pw);
                    pw.print(" (");
                    pw.print(ass.mCount);
                    pw.print(" times)");
                    pw.print("  ");
                    for (int i = 0; i < ass.mStateTimes.length; i++) {
                        long amt = ass.mStateTimes[i];
                        if (ass.mLastState - ActivityManager.MIN_PROCESS_STATE == i) {
                            amt += now - ass.mLastStateUptime;
                        }
                        if (amt != 0) {
                            pw.print(" ");
                            pw.print(ProcessList.makeProcStateString(i + ActivityManager.MIN_PROCESS_STATE));
                            pw.print("=");
                            TimeUtils.formatDuration(amt, pw);
                            if (ass.mLastState - ActivityManager.MIN_PROCESS_STATE == i) {
                                pw.print("*");
                            }
                        }
                    }
                    pw.println();
                    if (ass.mNesting > 0) {
                        pw.print("    Currently active: ");
                        TimeUtils.formatDuration(now - ass.mStartTime, pw);
                        pw.println();
                    }
                }
            }
        }
    }
    if (!printedAnything) {
        pw.println("  (nothing)");
    }
}

Example 67 with ArrayMap

use of android.util.ArrayMap in project platform_frameworks_base by android.

the class TaskStack method createAffiliatedGroupings.

/**
     * Temporary: This method will simulate affiliation groups
     */
void createAffiliatedGroupings(Context context) {
    mGroups.clear();
    mAffinitiesGroups.clear();
    if (RecentsDebugFlags.Static.EnableMockTaskGroups) {
        ArrayMap<Task.TaskKey, Task> taskMap = new ArrayMap<>();
        // Sort all tasks by increasing firstActiveTime of the task
        ArrayList<Task> tasks = mStackTaskList.getTasks();
        Collections.sort(tasks, new Comparator<Task>() {

            @Override
            public int compare(Task task, Task task2) {
                return Long.compare(task.key.firstActiveTime, task2.key.firstActiveTime);
            }
        });
        // Create groups when sequential packages are the same
        NamedCounter counter = new NamedCounter("task-group", "");
        int taskCount = tasks.size();
        String prevPackage = "";
        int prevAffiliation = -1;
        Random r = new Random();
        int groupCountDown = RecentsDebugFlags.Static.MockTaskGroupsTaskCount;
        for (int i = 0; i < taskCount; i++) {
            Task t = tasks.get(i);
            String packageName = t.key.getComponent().getPackageName();
            packageName = "pkg";
            TaskGrouping group;
            if (packageName.equals(prevPackage) && groupCountDown > 0) {
                group = getGroupWithAffiliation(prevAffiliation);
                groupCountDown--;
            } else {
                int affiliation = IndividualTaskIdOffset + t.key.id;
                group = new TaskGrouping(affiliation);
                addGroup(group);
                prevAffiliation = affiliation;
                prevPackage = packageName;
                groupCountDown = RecentsDebugFlags.Static.MockTaskGroupsTaskCount;
            }
            group.addTask(t);
            taskMap.put(t.key, t);
        }
        // Sort groups by increasing latestActiveTime of the group
        Collections.sort(mGroups, new Comparator<TaskGrouping>() {

            @Override
            public int compare(TaskGrouping taskGrouping, TaskGrouping taskGrouping2) {
                return Long.compare(taskGrouping.latestActiveTimeInGroup, taskGrouping2.latestActiveTimeInGroup);
            }
        });
        // Sort group tasks by increasing firstActiveTime of the task, and also build a new list
        // of tasks
        int taskIndex = 0;
        int groupCount = mGroups.size();
        for (int i = 0; i < groupCount; i++) {
            TaskGrouping group = mGroups.get(i);
            Collections.sort(group.mTaskKeys, new Comparator<Task.TaskKey>() {

                @Override
                public int compare(Task.TaskKey taskKey, Task.TaskKey taskKey2) {
                    return Long.compare(taskKey.firstActiveTime, taskKey2.firstActiveTime);
                }
            });
            ArrayList<Task.TaskKey> groupTasks = group.mTaskKeys;
            int groupTaskCount = groupTasks.size();
            for (int j = 0; j < groupTaskCount; j++) {
                tasks.set(taskIndex, taskMap.get(groupTasks.get(j)));
                taskIndex++;
            }
        }
        mStackTaskList.set(tasks);
    } else {
        // Create the task groups
        ArrayMap<Task.TaskKey, Task> tasksMap = new ArrayMap<>();
        ArrayList<Task> tasks = mStackTaskList.getTasks();
        int taskCount = tasks.size();
        for (int i = 0; i < taskCount; i++) {
            Task t = tasks.get(i);
            TaskGrouping group;
            if (RecentsDebugFlags.Static.EnableAffiliatedTaskGroups) {
                int affiliation = t.affiliationTaskId > 0 ? t.affiliationTaskId : IndividualTaskIdOffset + t.key.id;
                if (mAffinitiesGroups.containsKey(affiliation)) {
                    group = getGroupWithAffiliation(affiliation);
                } else {
                    group = new TaskGrouping(affiliation);
                    addGroup(group);
                }
            } else {
                group = new TaskGrouping(t.key.id);
                addGroup(group);
            }
            group.addTask(t);
            tasksMap.put(t.key, t);
        }
        // Update the task colors for each of the groups
        float minAlpha = context.getResources().getFloat(R.dimen.recents_task_affiliation_color_min_alpha_percentage);
        int taskGroupCount = mGroups.size();
        for (int i = 0; i < taskGroupCount; i++) {
            TaskGrouping group = mGroups.get(i);
            taskCount = group.getTaskCount();
            // Ignore the groups that only have one task
            if (taskCount <= 1)
                continue;
            // Calculate the group color distribution
            int affiliationColor = tasksMap.get(group.mTaskKeys.get(0)).affiliationColor;
            float alphaStep = (1f - minAlpha) / taskCount;
            float alpha = 1f;
            for (int j = 0; j < taskCount; j++) {
                Task t = tasksMap.get(group.mTaskKeys.get(j));
                t.colorPrimary = Utilities.getColorWithOverlay(affiliationColor, Color.WHITE, alpha);
                alpha -= alphaStep;
            }
        }
    }
}

Example 68 with ArrayMap

use of android.util.ArrayMap in project platform_frameworks_base by android.

the class IpConnectivityMetrics method makeRateLimitingBuckets.

private static ArrayMap<Class<?>, TokenBucket> makeRateLimitingBuckets() {
    ArrayMap<Class<?>, TokenBucket> map = new ArrayMap<>();
    // one token every minute, 50 tokens max: burst of ~50 events every hour.
    map.put(ApfProgramEvent.class, new TokenBucket((int) DateUtils.MINUTE_IN_MILLIS, 50));
    return map;
}

Example 69 with ArrayMap

use of android.util.ArrayMap in project platform_frameworks_base by android.

the class KeySetManagerServiceTest method testRemoveAppKSDataDefined.

/* remove package which used defined and upgrade keysets and ensure  removed */
public void testRemoveAppKSDataDefined() throws ReflectiveOperationException {
    /* create PackageSetting and add to Settings mPackages */
    PackageSetting ps = generateFakePackageSetting("packageA");
    mPackagesMap.put(ps.name, ps);
    /* collect key and add */
    ArrayMap<String, ArraySet<PublicKey>> definedKS = new ArrayMap<String, ArraySet<PublicKey>>();
    ArraySet<PublicKey> keys = new ArraySet<PublicKey>();
    PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA);
    keys.add(keyA);
    /* removal requires signing keyset to be specified (since all apps are
         * assumed to have it).  We skipped this in the defined tests, but can't
         * here. */
    mKsms.addSigningKeySetToPackageLPw(ps, keys);
    definedKS.put("aliasA", keys);
    mKsms.addDefinedKeySetsToPackageLPw(ps, definedKS);
    ArraySet<String> upgradeKS = new ArraySet<String>();
    upgradeKS.add("aliasA");
    mKsms.addUpgradeKeySetsToPackageLPw(ps, upgradeKS);
    mKsms.removeAppKeySetDataLPw(ps.name);
    assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 1));
    assertEquals(0, KeySetUtils.getPubKeyRefCount(mKsms, 1));
    LongSparseArray<ArraySet<Long>> ksMapping = KeySetUtils.getKeySetMapping(mKsms);
    assertEquals(0, ksMapping.size());
    assertEquals(PackageKeySetData.KEYSET_UNASSIGNED, ps.keySetData.getProperSigningKeySet());
    assertEquals(0, ps.keySetData.getAliases().size());
    assertNull(ps.keySetData.getUpgradeKeySets());
}

Example 70 with ArrayMap

use of android.util.ArrayMap in project platform_frameworks_base by android.

the class KeySetManagerServiceTest method testAddDefinedKSToPackageOrthoUpgr.

/* upgrd defined keyset ortho (make sure previous is removed for pkg) */
public void testAddDefinedKSToPackageOrthoUpgr() throws ReflectiveOperationException {
    /* create PackageSetting and add to Settings mPackages */
    PackageSetting ps = generateFakePackageSetting("packageA");
    mPackagesMap.put(ps.name, ps);
    /* collect key and add */
    ArrayMap<String, ArraySet<PublicKey>> definedKS = new ArrayMap<String, ArraySet<PublicKey>>();
    ArraySet<PublicKey> keys = new ArraySet<PublicKey>();
    PublicKey keyA = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyA);
    keys.add(keyA);
    definedKS.put("aliasA", keys);
    mKsms.addDefinedKeySetsToPackageLPw(ps, definedKS);
    /* now upgrade to different defined key-set */
    keys = new ArraySet<PublicKey>();
    PublicKey keyB = PackageParser.parsePublicKey(KeySetStrings.ctsKeySetPublicKeyB);
    keys.add(keyB);
    definedKS.remove("aliasA");
    definedKS.put("aliasB", keys);
    mKsms.addDefinedKeySetsToPackageLPw(ps, definedKS);
    assertEquals(0, KeySetUtils.getKeySetRefCount(mKsms, 1));
    assertEquals(0, KeySetUtils.getPubKeyRefCount(mKsms, 1));
    assertEquals(1, KeySetUtils.getKeySetRefCount(mKsms, 2));
    assertEquals(1, KeySetUtils.getPubKeyRefCount(mKsms, 2));
    assertEquals(keyB, KeySetUtils.getPubKey(mKsms, 2));
    LongSparseArray<ArraySet<Long>> ksMapping = KeySetUtils.getKeySetMapping(mKsms);
    assertEquals(1, ksMapping.size());
    ArraySet<Long> mapping = ksMapping.get(2);
    assertEquals(1, mapping.size());
    assertTrue(mapping.contains(new Long(2)));
    assertNull(ps.keySetData.getAliases().get("aliasA"));
    assertNotNull(ps.keySetData.getAliases().get("aliasB"));
    assertEquals(new Long(2), ps.keySetData.getAliases().get("aliasB"));
}