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

Example 6 with MutableBoolean

use of android.util.MutableBoolean in project android_frameworks_base by ResurrectionRemix.

the class TaskStackViewTouchHandler method onBeginDrag.

@Override
public void onBeginDrag(View v) {
    TaskView tv = (TaskView) v;
    // Disable clipping with the stack while we are swiping
    tv.setClipViewInStack(false);
    // Disallow touch events from this task view
    tv.setTouchEnabled(false);
    // Disallow parents from intercepting touch events
    final ViewParent parent = mSv.getParent();
    if (parent != null) {
        parent.requestDisallowInterceptTouchEvent(true);
    }
    // Add this task to the set of tasks we are deleting
    mSv.addIgnoreTask(tv.getTask());
    // Determine if we are animating the other tasks while dismissing this task
    mCurrentTasks = new ArrayList<Task>(mSv.getStack().getStackTasks());
    MutableBoolean isFrontMostTask = new MutableBoolean(false);
    Task anchorTask = mSv.findAnchorTask(mCurrentTasks, isFrontMostTask);
    TaskStackLayoutAlgorithm layoutAlgorithm = mSv.getStackAlgorithm();
    TaskStackViewScroller stackScroller = mSv.getScroller();
    if (anchorTask != null) {
        // Get the current set of task transforms
        mSv.getCurrentTaskTransforms(mCurrentTasks, mCurrentTaskTransforms);
        // Get the stack scroll of the task to anchor to (since we are removing something, the
        // front most task will be our anchor task)
        float prevAnchorTaskScroll = 0;
        boolean pullStackForward = mCurrentTasks.size() > 0;
        if (pullStackForward) {
            prevAnchorTaskScroll = layoutAlgorithm.getStackScrollForTask(anchorTask);
        }
        // Calculate where the views would be without the deleting tasks
        mSv.updateLayoutAlgorithm(false);
        float newStackScroll = stackScroller.getStackScroll();
        if (isFrontMostTask.value) {
            // Bound the stack scroll to pull tasks forward if necessary
            newStackScroll = stackScroller.getBoundedStackScroll(newStackScroll);
        } else if (pullStackForward) {
            // Otherwise, offset the scroll by the movement of the anchor task
            float anchorTaskScroll = layoutAlgorithm.getStackScrollForTaskIgnoreOverrides(anchorTask);
            float stackScrollOffset = (anchorTaskScroll - prevAnchorTaskScroll);
            if (layoutAlgorithm.getFocusState() != TaskStackLayoutAlgorithm.STATE_FOCUSED) {
                // If we are focused, we don't want the front task to move, but otherwise, we
                // allow the back task to move up, and the front task to move back
                stackScrollOffset *= 0.75f;
            }
            newStackScroll = stackScroller.getBoundedStackScroll(stackScroller.getStackScroll() + stackScrollOffset);
        }
        // Pick up the newly visible views, not including the deleting tasks
        mSv.bindVisibleTaskViews(newStackScroll, true);
        // Get the final set of task transforms (with task removed)
        mSv.getLayoutTaskTransforms(newStackScroll, TaskStackLayoutAlgorithm.STATE_UNFOCUSED, mCurrentTasks, true, /* ignoreTaskOverrides */
        mFinalTaskTransforms);
        // Set the target to scroll towards upon dismissal
        mTargetStackScroll = newStackScroll;
    /*
             * Post condition: All views that will be visible as a part of the gesture are retrieved
             *                 and at their initial positions.  The stack is still at the current
             *                 scroll, but the layout is updated without the task currently being
             *                 dismissed.  The final layout is in the unfocused stack state, which
             *                 will be applied when the current task is dismissed.
             */
    }
}

Example 7 with MutableBoolean

use of android.util.MutableBoolean in project android_frameworks_base by ResurrectionRemix.

the class EventBus method registerSubscriber.

/**
     * Registers a new subscriber.
     */
private void registerSubscriber(Object subscriber, int priority, MutableBoolean hasInterprocessEventsChangedOut) {
    // Fail immediately if we are being called from the non-main thread
    long callingThreadId = Thread.currentThread().getId();
    if (callingThreadId != mHandler.getLooper().getThread().getId()) {
        throw new RuntimeException("Can not register() a subscriber from a non-main thread.");
    }
    // Return immediately if this exact subscriber is already registered
    if (findRegisteredSubscriber(subscriber, false)) {
        return;
    }
    long t1 = 0;
    if (DEBUG_TRACE_ALL) {
        t1 = SystemClock.currentTimeMicro();
        logWithPid("registerSubscriber(" + subscriber.getClass().getSimpleName() + ")");
    }
    Subscriber sub = new Subscriber(subscriber, SystemClock.uptimeMillis());
    Class<?> subscriberType = subscriber.getClass();
    ArrayList<EventHandlerMethod> subscriberMethods = mSubscriberTypeMap.get(subscriberType);
    if (subscriberMethods != null) {
        if (DEBUG_TRACE_ALL) {
            logWithPid("Subscriber class type already registered");
        }
        // events
        for (EventHandlerMethod method : subscriberMethods) {
            ArrayList<EventHandler> eventTypeHandlers = mEventTypeMap.get(method.eventType);
            eventTypeHandlers.add(new EventHandler(sub, method, priority));
            sortEventHandlersByPriority(eventTypeHandlers);
        }
        mSubscribers.add(sub);
        return;
    } else {
        if (DEBUG_TRACE_ALL) {
            logWithPid("Subscriber class type requires registration");
        }
        // If we are parsing this type from scratch, ensure we add it to the subscriber type
        // map, and pull out he handler methods below
        subscriberMethods = new ArrayList<>();
        mSubscriberTypeMap.put(subscriberType, subscriberMethods);
        mSubscribers.add(sub);
    }
    // Find all the valid event bus handler methods of the subscriber
    MutableBoolean isInterprocessEvent = new MutableBoolean(false);
    Method[] methods = subscriberType.getDeclaredMethods();
    for (Method m : methods) {
        Class<?>[] parameterTypes = m.getParameterTypes();
        isInterprocessEvent.value = false;
        if (isValidEventBusHandlerMethod(m, parameterTypes, isInterprocessEvent)) {
            Class<? extends Event> eventType = (Class<? extends Event>) parameterTypes[0];
            ArrayList<EventHandler> eventTypeHandlers = mEventTypeMap.get(eventType);
            if (eventTypeHandlers == null) {
                eventTypeHandlers = new ArrayList<>();
                mEventTypeMap.put(eventType, eventTypeHandlers);
            }
            if (isInterprocessEvent.value) {
                try {
                    // Enforce that the event must have a Bundle constructor
                    eventType.getConstructor(Bundle.class);
                    mInterprocessEventNameMap.put(eventType.getName(), (Class<? extends InterprocessEvent>) eventType);
                    if (hasInterprocessEventsChangedOut != null) {
                        hasInterprocessEventsChangedOut.value = true;
                    }
                } catch (NoSuchMethodException e) {
                    throw new RuntimeException("Expected InterprocessEvent to have a Bundle constructor");
                }
            }
            EventHandlerMethod method = new EventHandlerMethod(m, eventType);
            EventHandler handler = new EventHandler(sub, method, priority);
            eventTypeHandlers.add(handler);
            subscriberMethods.add(method);
            sortEventHandlersByPriority(eventTypeHandlers);
            if (DEBUG_TRACE_ALL) {
                logWithPid("  * Method: " + m.getName() + " event: " + parameterTypes[0].getSimpleName() + " interprocess? " + isInterprocessEvent.value);
            }
        }
    }
    if (DEBUG_TRACE_ALL) {
        logWithPid("Registered " + subscriber.getClass().getSimpleName() + " in " + (SystemClock.currentTimeMicro() - t1) + " microseconds");
    }
}

Example 8 with MutableBoolean

use of android.util.MutableBoolean in project android_frameworks_base by ResurrectionRemix.

the class EventBus method registerInterprocessAsCurrentUser.

/**
     * Registers a subscriber to receive interprocess events with the given priority.
     *
     * @param subscriber the subscriber to handle events.  If this is the first instance of the
     *                   subscriber's class type that has been registered, the class's methods will
     *                   be scanned for appropriate event handler methods.
     * @param priority the priority that this subscriber will receive events relative to other
     *                 subscribers
     */
public void registerInterprocessAsCurrentUser(Context context, Object subscriber, int priority) {
    if (DEBUG_TRACE_ALL) {
        logWithPid("registerInterprocessAsCurrentUser(" + subscriber.getClass().getSimpleName() + ")");
    }
    // Register the subscriber normally, and update the broadcast receiver filter if this is
    // a new subscriber type with interprocess events
    MutableBoolean hasInterprocessEventsChanged = new MutableBoolean(false);
    registerSubscriber(subscriber, priority, hasInterprocessEventsChanged);
    if (DEBUG_TRACE_ALL) {
        logWithPid("hasInterprocessEventsChanged: " + hasInterprocessEventsChanged.value);
    }
    if (hasInterprocessEventsChanged.value) {
        registerReceiverForInterprocessEvents(context);
    }
}

Example 9 with MutableBoolean

use of android.util.MutableBoolean in project android_frameworks_base by DirtyUnicorns.

the class RecentsImpl method toggleRecents.

public void toggleRecents(int growTarget) {
    // Skip this toggle if we are already waiting to trigger recents via alt-tab
    if (mFastAltTabTrigger.isDozing()) {
        return;
    }
    mDraggingInRecents = false;
    mLaunchedWhileDocking = false;
    mTriggeredFromAltTab = false;
    try {
        SystemServicesProxy ssp = Recents.getSystemServices();
        MutableBoolean isHomeStackVisible = new MutableBoolean(true);
        long elapsedTime = SystemClock.elapsedRealtime() - mLastToggleTime;
        if (ssp.isRecentsActivityVisible(isHomeStackVisible)) {
            RecentsDebugFlags debugFlags = Recents.getDebugFlags();
            RecentsConfiguration config = Recents.getConfiguration();
            RecentsActivityLaunchState launchState = config.getLaunchState();
            if (!launchState.launchedWithAltTab) {
                // Has the user tapped quickly?
                boolean isQuickTap = ViewConfiguration.getDoubleTapMinTime() < elapsedTime && elapsedTime < ViewConfiguration.getDoubleTapTimeout();
                if (Recents.getConfiguration().isGridEnabled) {
                    if (isQuickTap) {
                        EventBus.getDefault().post(new LaunchNextTaskRequestEvent());
                    } else {
                        EventBus.getDefault().post(new LaunchMostRecentTaskRequestEvent());
                    }
                } else {
                    if (!debugFlags.isPagingEnabled() || isQuickTap) {
                        // Launch the next focused task
                        EventBus.getDefault().post(new LaunchNextTaskRequestEvent());
                    } else {
                        // Notify recents to move onto the next task
                        EventBus.getDefault().post(new IterateRecentsEvent());
                    }
                }
            } else {
                // account
                if (elapsedTime < MIN_TOGGLE_DELAY_MS) {
                    return;
                }
                EventBus.getDefault().post(new ToggleRecentsEvent());
                mLastToggleTime = SystemClock.elapsedRealtime();
            }
            return;
        } else {
            // account
            if (elapsedTime < MIN_TOGGLE_DELAY_MS) {
                return;
            }
            // Otherwise, start the recents activity
            ActivityManager.RunningTaskInfo runningTask = ssp.getRunningTask();
            startRecentsActivity(runningTask, isHomeStackVisible.value, true, /* animate */
            growTarget);
            // Only close the other system windows if we are actually showing recents
            ssp.sendCloseSystemWindows(BaseStatusBar.SYSTEM_DIALOG_REASON_RECENT_APPS);
            mLastToggleTime = SystemClock.elapsedRealtime();
        }
    } catch (ActivityNotFoundException e) {
        Log.e(TAG, "Failed to launch RecentsActivity", e);
    }
}

Example 10 with MutableBoolean

use of android.util.MutableBoolean in project android_frameworks_base by DirtyUnicorns.

the class RecentsImpl method preloadRecents.

public void preloadRecents() {
    // Preload only the raw task list into a new load plan (which will be consumed by the
    // RecentsActivity) only if there is a task to animate to.
    SystemServicesProxy ssp = Recents.getSystemServices();
    MutableBoolean isHomeStackVisible = new MutableBoolean(true);
    if (!ssp.isRecentsActivityVisible(isHomeStackVisible)) {
        ActivityManager.RunningTaskInfo runningTask = ssp.getRunningTask();
        RecentsTaskLoader loader = Recents.getTaskLoader();
        sInstanceLoadPlan = loader.createLoadPlan(mContext);
        sInstanceLoadPlan.preloadRawTasks(!isHomeStackVisible.value);
        loader.preloadTasks(sInstanceLoadPlan, runningTask.id, !isHomeStackVisible.value);
        TaskStack stack = sInstanceLoadPlan.getTaskStack();
        if (stack.getTaskCount() > 0) {
            // Only preload the icon (but not the thumbnail since it may not have been taken for
            // the pausing activity)
            preloadIcon(runningTask.id);
            // At this point, we don't know anything about the stack state.  So only calculate
            // the dimensions of the thumbnail that we need for the transition into Recents, but
            // do not draw it until we construct the activity options when we start Recents
            updateHeaderBarLayout(stack, null);
        }
    }
}