SystemUI: attach a queue to media player notifications

Extend media player notificatoins to attach a queue below them, set via
the MediaController.setQueue() API, when available.

Long pressing on the notificaiton will reveal an option to disable the
queue.

The queue is currently hardcoded to be limited to 3 items.

Ticket: CYNGNOS-217
Change-Id: I3b8503cb47af2d36f031d06aefc1bfbe7ed80010
Signed-off-by: Roman Birg <roman@cyngn.com>

1 files changed, 231 insertions, 0 deletions

diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/MediaExpandableNotificationRow.java b/packages/SystemUI/src/com/android/systemui/statusbar/MediaExpandableNotificationRow.java
new file mode 100644
index 0000000..c25f146
--- /dev/null
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/MediaExpandableNotificationRow.java
@@ -0,0 +1,231 @@
+/*
+ * Copyright (C) 2015 The CyanogenMod Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+package com.android.systemui.statusbar;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.media.session.MediaController;
+import android.os.Build;
+import android.os.Handler;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.android.systemui.R;
+import com.android.systemui.cm.UserContentObserver;
+
+import cyanogenmod.providers.CMSettings;
+
+public class MediaExpandableNotificationRow extends ExpandableNotificationRow {
+
+    private static final String TAG = MediaExpandableNotificationRow.class.getSimpleName();
+    public static final boolean DEBUG = false;
+
+    public static final int MAX_QUEUE_ENTRIES = 3;
+
+    private QueueView mQueue;
+
+    private int mMaxQueueHeight;
+    private int mRowHeight;
+    private int mShadowHeight;
+    private int mDisplayedRows;
+
+    private SettingsObserver mSettingsObserver;
+    private boolean mQueueEnabled;
+
+    public MediaExpandableNotificationRow(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        mSettingsObserver = new SettingsObserver(new Handler());
+        mQueueEnabled = isQueueEnabled(context);
+
+        Resources res = mContext.getResources();
+
+        // 3 * queue_row_height + shadow height
+        mRowHeight = res.getDimensionPixelSize(R.dimen.queue_row_height);
+        mShadowHeight = res.getDimensionPixelSize(R.dimen.queue_top_shadow);
+    }
+
+    public boolean inflateGuts() {
+        if (getGuts() == null) {
+            mGutsStub.inflate();
+        }
+        if (!mQueueEnabled) {
+            return true;
+        }
+        return !mQueue.isUserSelectingRow();
+    }
+
+    @Override
+    protected void updateMaxHeights() {
+        // update queue height based on number of rows
+        int rows = mQueue != null ? mQueue.getCurrentQueueRowCount() : 0;
+        if (rows != mDisplayedRows) {
+            mMaxQueueHeight = rows * mRowHeight;
+            if (mMaxQueueHeight > 0) {
+                mMaxQueueHeight += mShadowHeight;
+            }
+            mDisplayedRows = rows;
+        }
+
+        int intrinsicBefore = getIntrinsicHeight();
+        View expandedChild = mPrivateLayout.getExpandedChild();
+        if (expandedChild == null) {
+            expandedChild = mPrivateLayout.getContractedChild();
+        }
+        mMaxExpandHeight = expandedChild.getHeight() + mMaxQueueHeight;
+
+        View headsUpChild = mPrivateLayout.getHeadsUpChild();
+        if (headsUpChild == null) {
+            headsUpChild = mPrivateLayout.getContractedChild();
+        }
+        mHeadsUpHeight = headsUpChild.getHeight();
+        if (intrinsicBefore != getIntrinsicHeight()) {
+            notifyHeightChanged(false /* needsAnimation */);
+        }
+        invalidateOutline();
+    }
+
+    @Override
+    public int getIntrinsicHeight() {
+        if (getGuts() != null && getGuts().isShown()) {
+            return getGuts().getActualHeight();
+        }
+        if (!mQueueEnabled) {
+            return super.getIntrinsicHeight();
+        }
+        if (mHideSensitiveForIntrinsicHeight) {
+            return getMinHeight();
+        }
+        if (isUserLocked()) {
+            return getActualHeight();
+        }
+        boolean inExpansionState = isExpanded();
+        if (!inExpansionState) {
+            // not expanded, so we return the collapsed size
+            return getMinHeight();
+        }
+        return getMaxContentHeight();
+    }
+
+    @Override
+    public int getMaxContentHeight() {
+        /**
+         * calls into NotificationContentView.getMaxHeight()
+         */
+        return getShowingLayout().getMaxHeight() + mMaxQueueHeight;
+    }
+
+    @Override
+    public void setHeightRange(int rowMinHeight, int rowMaxHeight) {
+        super.setHeightRange(rowMinHeight, rowMaxHeight);
+        mMaxViewHeight = Math.max(rowMaxHeight, getMaxContentHeight());
+    }
+
+    @Override
+    protected void onFinishInflate() {
+        super.onFinishInflate();
+        mQueue = (QueueView) findViewById(R.id.queue_view);
+        mQueue.setQueueEnabled(mQueueEnabled);
+        mQueue.setVisibility(mQueueEnabled ? View.VISIBLE : View.GONE);
+    }
+
+    public void setMediaController(MediaController mediaController) {
+        if (DEBUG) Log.d(TAG, "setMediaController() called with "
+                + "mediaController = [" + mediaController + "]");
+        if (mQueue.setController(mediaController) && mQueueEnabled) {
+            notifyHeightChanged(true);
+        }
+    }
+
+    @Override
+    public boolean dispatchGenericMotionEvent(MotionEvent ev) {
+        if (filterMotionEvent(ev)) {
+            return super.dispatchGenericMotionEvent(ev);
+        }
+        return false;
+    }
+
+    @Override
+    public boolean dispatchTouchEvent(MotionEvent ev) {
+        if (filterMotionEvent(ev)) {
+            return super.dispatchTouchEvent(ev);
+        }
+        return false;
+    }
+
+    @Override
+    protected boolean filterMotionEvent(MotionEvent event) {
+        if (!mQueueEnabled) {
+            return super.filterMotionEvent(event);
+        }
+        if (isExpanded() && mQueue.isUserSelectingRow()
+                && event.getActionMasked() != MotionEvent.ACTION_DOWN
+                && event.getActionMasked() != MotionEvent.ACTION_UP
+                && event.getActionMasked() != MotionEvent.ACTION_CANCEL) {
+            // this is for hotspot propogation?
+            return false;
+        }
+        return super.filterMotionEvent(event);
+    }
+
+    @Override
+    protected void onAttachedToWindow() {
+        super.onAttachedToWindow();
+        mSettingsObserver.observe();
+    }
+
+    @Override
+    protected void onDetachedFromWindow() {
+        super.onDetachedFromWindow();
+        mSettingsObserver.unobserve();
+    }
+
+    private class SettingsObserver extends UserContentObserver {
+
+        public SettingsObserver(Handler handler) {
+            super(handler);
+        }
+
+        @Override
+        protected void observe() {
+            super.observe();
+            mContext.getContentResolver().registerContentObserver(
+                    CMSettings.System.getUriFor(CMSettings.System.NOTIFICATION_PLAY_QUEUE),
+                    true, this);
+        }
+
+        @Override
+        protected void unobserve() {
+            super.unobserve();
+            mContext.getContentResolver().unregisterContentObserver(this);
+        }
+
+        @Override
+        protected void update() {
+            mQueueEnabled = isQueueEnabled(mContext);
+            mQueue.setQueueEnabled(mQueueEnabled);
+            mQueue.setVisibility(mQueueEnabled ? View.VISIBLE : View.GONE);
+            requestLayout();
+        }
+    }
+
+    public static boolean isQueueEnabled(Context context) {
+        return CMSettings.System.getInt(context.getContentResolver(),
+                CMSettings.System.NOTIFICATION_PLAY_QUEUE, 1) == 1;
+    }
+}