packages/SystemUI/src/com/android/systemui/statusbar/NotificationMediaManager.java

   1 /*
   2  * Copyright (C) 2017 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License
  15  */
  16 package com.android.systemui.statusbar;
  17
  18 import static com.android.systemui.Dependency.MAIN_HANDLER;
  19 import static com.android.systemui.statusbar.StatusBarState.KEYGUARD;
  20 import static com.android.systemui.statusbar.phone.StatusBar.DEBUG_MEDIA_FAKE_ARTWORK;
  21 import static com.android.systemui.statusbar.phone.StatusBar.ENABLE_LOCKSCREEN_WALLPAPER;
  22 import static com.android.systemui.statusbar.phone.StatusBar.SHOW_LOCKSCREEN_MEDIA_ARTWORK;
  23
  24 import android.annotation.MainThread;
  25 import android.annotation.Nullable;
  26 import android.app.Notification;
  27 import android.content.Context;
  28 import android.graphics.Bitmap;
  29 import android.graphics.drawable.BitmapDrawable;
  30 import android.graphics.drawable.ColorDrawable;
  31 import android.graphics.drawable.Drawable;
  32 import android.graphics.drawable.Icon;
  33 import android.media.MediaMetadata;
  34 import android.media.session.MediaController;
  35 import android.media.session.MediaSession;
  36 import android.media.session.MediaSessionManager;
  37 import android.media.session.PlaybackState;
  38 import android.os.AsyncTask;
  39 import android.os.Handler;
  40 import android.os.Trace;
  41 import android.os.UserHandle;
  42 import android.provider.DeviceConfig;
  43 import android.provider.DeviceConfig.Properties;
  44 import android.util.ArraySet;
  45 import android.util.Log;
  46 import android.view.View;
  47 import android.widget.ImageView;
  48
  49 import com.android.internal.config.sysui.SystemUiDeviceConfigFlags;
  50 import com.android.internal.statusbar.NotificationVisibility;
  51 import com.android.systemui.Dependency;
  52 import com.android.systemui.Dumpable;
  53 import com.android.systemui.Interpolators;
  54 import com.android.systemui.colorextraction.SysuiColorExtractor;
  55 import com.android.systemui.plugins.statusbar.StatusBarStateController;
  56 import com.android.systemui.statusbar.notification.NotificationEntryListener;
  57 import com.android.systemui.statusbar.notification.NotificationEntryManager;
  58 import com.android.systemui.statusbar.notification.collection.NotificationEntry;
  59 import com.android.systemui.statusbar.phone.BiometricUnlockController;
  60 import com.android.systemui.statusbar.phone.LockscreenWallpaper;
  61 import com.android.systemui.statusbar.phone.ScrimController;
  62 import com.android.systemui.statusbar.phone.ScrimState;
  63 import com.android.systemui.statusbar.phone.ShadeController;
  64 import com.android.systemui.statusbar.phone.StatusBarWindowController;
  65 import com.android.systemui.statusbar.policy.KeyguardMonitor;
  66
  67 import java.io.FileDescriptor;
  68 import java.io.PrintWriter;
  69 import java.lang.ref.WeakReference;
  70 import java.util.ArrayList;
  71 import java.util.List;
  72 import java.util.Set;
  73
  74 import javax.inject.Inject;
  75 import javax.inject.Singleton;
  76
  77 import dagger.Lazy;
  78
  79 /**
  80  * Handles tasks and state related to media notifications. For example, there is a 'current' media
  81  * notification, which this class keeps track of.
  82  */
  83 @Singleton
  84 public class NotificationMediaManager implements Dumpable {
  85     private static final String TAG = "NotificationMediaManager";
  86     public static final boolean DEBUG_MEDIA = false;
  87
  88     private final StatusBarStateController mStatusBarStateController
  89             = Dependency.get(StatusBarStateController.class);
  90     private final SysuiColorExtractor mColorExtractor = Dependency.get(SysuiColorExtractor.class);
  91     private final KeyguardMonitor mKeyguardMonitor = Dependency.get(KeyguardMonitor.class);
  92
  93     // Late binding
  94     private NotificationEntryManager mEntryManager;
  95
  96     // Late binding, also @Nullable due to being in com.android.systemui.statusbar.phone package
  97     @Nullable
  98     private Lazy<ShadeController> mShadeController;
  99     @Nullable
 100     private Lazy<StatusBarWindowController> mStatusBarWindowController;
 101
 102     @Nullable
 103     private BiometricUnlockController mBiometricUnlockController;
 104     @Nullable
 105     private ScrimController mScrimController;
 106     @Nullable
 107     private LockscreenWallpaper mLockscreenWallpaper;
 108
 109     private final Handler mHandler = Dependency.get(MAIN_HANDLER);
 110
 111     private final Context mContext;
 112     private final MediaSessionManager mMediaSessionManager;
 113     private final ArrayList<MediaListener> mMediaListeners;
 114     private final MediaArtworkProcessor mMediaArtworkProcessor;
 115     private final Set<AsyncTask<?, ?, ?>> mProcessArtworkTasks = new ArraySet<>();
 116
 117     protected NotificationPresenter mPresenter;
 118     private MediaController mMediaController;
 119     private String mMediaNotificationKey;
 120     private MediaMetadata mMediaMetadata;
 121
 122     private BackDropView mBackdrop;
 123     private ImageView mBackdropFront;
 124     private ImageView mBackdropBack;
 125
 126     private boolean mShowCompactMediaSeekbar;
 127     private final DeviceConfig.OnPropertiesChangedListener mPropertiesChangedListener =
 128             new DeviceConfig.OnPropertiesChangedListener() {
 129         @Override
 130         public void onPropertiesChanged(Properties properties) {
 131             for (String name : properties.getKeyset()) {
 132                 if (SystemUiDeviceConfigFlags.COMPACT_MEDIA_SEEKBAR_ENABLED.equals(name)) {
 133                     String value = properties.getString(name, null);
 134                     if (DEBUG_MEDIA) {
 135                         Log.v(TAG, "DEBUG_MEDIA: compact media seekbar flag updated: " + value);
 136                     }
 137                     mShowCompactMediaSeekbar = "true".equals(value);
 138                 }
 139             }
 140         }
 141     };
 142
 143     private final MediaController.Callback mMediaListener = new MediaController.Callback() {
 144         @Override
 145         public void onPlaybackStateChanged(PlaybackState state) {
 146             super.onPlaybackStateChanged(state);
 147             if (DEBUG_MEDIA) {
 148                 Log.v(TAG, "DEBUG_MEDIA: onPlaybackStateChanged: " + state);
 149             }
 150             if (state != null) {
 151                 if (!isPlaybackActive(state.getState())) {
 152                     clearCurrentMediaNotification();
 153                 }
 154                 dispatchUpdateMediaMetaData(true /* changed */, true /* allowAnimation */);
 155             }
 156         }
 157
 158         @Override
 159         public void onMetadataChanged(MediaMetadata metadata) {
 160             super.onMetadataChanged(metadata);
 161             if (DEBUG_MEDIA) {
 162                 Log.v(TAG, "DEBUG_MEDIA: onMetadataChanged: " + metadata);
 163             }
 164             mMediaArtworkProcessor.clearCache();
 165             mMediaMetadata = metadata;
 166             dispatchUpdateMediaMetaData(true /* changed */, true /* allowAnimation */);
 167         }
 168     };
 169
 170     @Inject
 171     public NotificationMediaManager(
 172             Context context,
 173             Lazy<ShadeController> shadeController,
 174             Lazy<StatusBarWindowController> statusBarWindowController,
 175             NotificationEntryManager notificationEntryManager,
 176             MediaArtworkProcessor mediaArtworkProcessor) {
 177         mContext = context;
 178         mMediaArtworkProcessor = mediaArtworkProcessor;
 179         mMediaListeners = new ArrayList<>();
 180         mMediaSessionManager
 181                 = (MediaSessionManager) mContext.getSystemService(Context.MEDIA_SESSION_SERVICE);
 182         // TODO: use MediaSessionManager.SessionListener to hook us up to future updates
 183         // in session state
 184         mShadeController = shadeController;
 185         mStatusBarWindowController = statusBarWindowController;
 186         mEntryManager = notificationEntryManager;
 187         notificationEntryManager.addNotificationEntryListener(new NotificationEntryListener() {
 188             @Override
 189             public void onEntryRemoved(
 190                     NotificationEntry entry,
 191                     NotificationVisibility visibility,
 192                     boolean removedByUser) {
 193                 onNotificationRemoved(entry.key);
 194             }
 195         });
 196
 197         mShowCompactMediaSeekbar = "true".equals(
 198                 DeviceConfig.getProperty(DeviceConfig.NAMESPACE_SYSTEMUI,
 199                     SystemUiDeviceConfigFlags.COMPACT_MEDIA_SEEKBAR_ENABLED));
 200
 201         DeviceConfig.addOnPropertiesChangedListener(DeviceConfig.NAMESPACE_SYSTEMUI,
 202                 mContext.getMainExecutor(),
 203                 mPropertiesChangedListener);
 204     }
 205
 206     public void setUpWithPresenter(NotificationPresenter presenter) {
 207         mPresenter = presenter;
 208     }
 209
 210     public void onNotificationRemoved(String key) {
 211         if (key.equals(mMediaNotificationKey)) {
 212             clearCurrentMediaNotification();
 213             dispatchUpdateMediaMetaData(true /* changed */, true /* allowEnterAnimation */);
 214         }
 215     }
 216
 217     public String getMediaNotificationKey() {
 218         return mMediaNotificationKey;
 219     }
 220
 221     public MediaMetadata getMediaMetadata() {
 222         return mMediaMetadata;
 223     }
 224
 225     public boolean getShowCompactMediaSeekbar() {
 226         return mShowCompactMediaSeekbar;
 227     }
 228
 229     public Icon getMediaIcon() {
 230         if (mMediaNotificationKey == null) {
 231             return null;
 232         }
 233         synchronized (mEntryManager.getNotificationData()) {
 234             NotificationEntry entry = mEntryManager.getNotificationData().get(mMediaNotificationKey);
 235             if (entry == null || entry.expandedIcon == null) {
 236                 return null;
 237             }
 238
 239             return entry.expandedIcon.getSourceIcon();
 240         }
 241     }
 242
 243     public void addCallback(MediaListener callback) {
 244         mMediaListeners.add(callback);
 245         callback.onMetadataOrStateChanged(mMediaMetadata,
 246                 getMediaControllerPlaybackState(mMediaController));
 247     }
 248
 249     public void removeCallback(MediaListener callback) {
 250         mMediaListeners.remove(callback);
 251     }
 252
 253     public void findAndUpdateMediaNotifications() {
 254         boolean metaDataChanged = false;
 255
 256         synchronized (mEntryManager.getNotificationData()) {
 257             ArrayList<NotificationEntry> activeNotifications =
 258                     mEntryManager.getNotificationData().getActiveNotifications();
 259             final int N = activeNotifications.size();
 260
 261             // Promote the media notification with a controller in 'playing' state, if any.
 262             NotificationEntry mediaNotification = null;
 263             MediaController controller = null;
 264             for (int i = 0; i < N; i++) {
 265                 final NotificationEntry entry = activeNotifications.get(i);
 266
 267                 if (entry.isMediaNotification()) {
 268                     final MediaSession.Token token =
 269                             entry.notification.getNotification().extras.getParcelable(
 270                                     Notification.EXTRA_MEDIA_SESSION);
 271                     if (token != null) {
 272                         MediaController aController = new MediaController(mContext, token);
 273                         if (PlaybackState.STATE_PLAYING ==
 274                                 getMediaControllerPlaybackState(aController)) {
 275                             if (DEBUG_MEDIA) {
 276                                 Log.v(TAG, "DEBUG_MEDIA: found mediastyle controller matching "
 277                                         + entry.notification.getKey());
 278                             }
 279                             mediaNotification = entry;
 280                             controller = aController;
 281                             break;
 282                         }
 283                     }
 284                 }
 285             }
 286             if (mediaNotification == null) {
 287                 // Still nothing? OK, let's just look for live media sessions and see if they match
 288                 // one of our notifications. This will catch apps that aren't (yet!) using media
 289                 // notifications.
 290
 291                 if (mMediaSessionManager != null) {
 292                     // TODO: Should this really be for all users?
 293                     final List<MediaController> sessions
 294                             = mMediaSessionManager.getActiveSessionsForUser(
 295                             null,
 296                             UserHandle.USER_ALL);
 297
 298                     for (MediaController aController : sessions) {
 299                         if (PlaybackState.STATE_PLAYING ==
 300                                 getMediaControllerPlaybackState(aController)) {
 301                             // now to see if we have one like this
 302                             final String pkg = aController.getPackageName();
 303
 304                             for (int i = 0; i < N; i++) {
 305                                 final NotificationEntry entry = activeNotifications.get(i);
 306                                 if (entry.notification.getPackageName().equals(pkg)) {
 307                                     if (DEBUG_MEDIA) {
 308                                         Log.v(TAG, "DEBUG_MEDIA: found controller matching "
 309                                                 + entry.notification.getKey());
 310                                     }
 311                                     controller = aController;
 312                                     mediaNotification = entry;
 313                                     break;
 314                                 }
 315                             }
 316                         }
 317                     }
 318                 }
 319             }
 320
 321             if (controller != null && !sameSessions(mMediaController, controller)) {
 322                 // We have a new media session
 323                 clearCurrentMediaNotificationSession();
 324                 mMediaController = controller;
 325                 mMediaController.registerCallback(mMediaListener);
 326                 mMediaMetadata = mMediaController.getMetadata();
 327                 if (DEBUG_MEDIA) {
 328                     Log.v(TAG, "DEBUG_MEDIA: insert listener, found new controller: "
 329                             + mMediaController + ", receive metadata: " + mMediaMetadata);
 330                 }
 331
 332                 metaDataChanged = true;
 333             }
 334
 335             if (mediaNotification != null
 336                     && !mediaNotification.notification.getKey().equals(mMediaNotificationKey)) {
 337                 mMediaNotificationKey = mediaNotification.notification.getKey();
 338                 if (DEBUG_MEDIA) {
 339                     Log.v(TAG, "DEBUG_MEDIA: Found new media notification: key="
 340                             + mMediaNotificationKey);
 341                 }
 342             }
 343         }
 344
 345         if (metaDataChanged) {
 346             mEntryManager.updateNotifications();
 347         }
 348
 349         dispatchUpdateMediaMetaData(metaDataChanged, true /* allowEnterAnimation */);
 350     }
 351
 352     public void clearCurrentMediaNotification() {
 353         mMediaNotificationKey = null;
 354         clearCurrentMediaNotificationSession();
 355     }
 356
 357     private void dispatchUpdateMediaMetaData(boolean changed, boolean allowEnterAnimation) {
 358         if (mPresenter != null) {
 359             mPresenter.updateMediaMetaData(changed, allowEnterAnimation);
 360         }
 361         @PlaybackState.State int state = getMediaControllerPlaybackState(mMediaController);
 362         ArrayList<MediaListener> callbacks = new ArrayList<>(mMediaListeners);
 363         for (int i = 0; i < callbacks.size(); i++) {
 364             callbacks.get(i).onMetadataOrStateChanged(mMediaMetadata, state);
 365         }
 366     }
 367
 368     @Override
 369     public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
 370         pw.print("    mMediaSessionManager=");
 371         pw.println(mMediaSessionManager);
 372         pw.print("    mMediaNotificationKey=");
 373         pw.println(mMediaNotificationKey);
 374         pw.print("    mMediaController=");
 375         pw.print(mMediaController);
 376         if (mMediaController != null) {
 377             pw.print(" state=" + mMediaController.getPlaybackState());
 378         }
 379         pw.println();
 380         pw.print("    mMediaMetadata=");
 381         pw.print(mMediaMetadata);
 382         if (mMediaMetadata != null) {
 383             pw.print(" title=" + mMediaMetadata.getText(MediaMetadata.METADATA_KEY_TITLE));
 384         }
 385         pw.println();
 386     }
 387
 388     private boolean isPlaybackActive(int state) {
 389         return state != PlaybackState.STATE_STOPPED && state != PlaybackState.STATE_ERROR
 390                 && state != PlaybackState.STATE_NONE;
 391     }
 392
 393     private boolean sameSessions(MediaController a, MediaController b) {
 394         if (a == b) {
 395             return true;
 396         }
 397         if (a == null) {
 398             return false;
 399         }
 400         return a.controlsSameSession(b);
 401     }
 402
 403     private int getMediaControllerPlaybackState(MediaController controller) {
 404         if (controller != null) {
 405             final PlaybackState playbackState = controller.getPlaybackState();
 406             if (playbackState != null) {
 407                 return playbackState.getState();
 408             }
 409         }
 410         return PlaybackState.STATE_NONE;
 411     }
 412
 413     private void clearCurrentMediaNotificationSession() {
 414         mMediaArtworkProcessor.clearCache();
 415         mMediaMetadata = null;
 416         if (mMediaController != null) {
 417             if (DEBUG_MEDIA) {
 418                 Log.v(TAG, "DEBUG_MEDIA: Disconnecting from old controller: "
 419                         + mMediaController.getPackageName());
 420             }
 421             mMediaController.unregisterCallback(mMediaListener);
 422         }
 423         mMediaController = null;
 424     }
 425
 426     /**
 427      * Refresh or remove lockscreen artwork from media metadata or the lockscreen wallpaper.
 428      */
 429     public void updateMediaMetaData(boolean metaDataChanged, boolean allowEnterAnimation) {
 430         Trace.beginSection("StatusBar#updateMediaMetaData");
 431         if (!SHOW_LOCKSCREEN_MEDIA_ARTWORK) {
 432             Trace.endSection();
 433             return;
 434         }
 435
 436         if (mBackdrop == null) {
 437             Trace.endSection();
 438             return; // called too early
 439         }
 440
 441         boolean wakeAndUnlock = mBiometricUnlockController != null
 442             && mBiometricUnlockController.isWakeAndUnlock();
 443         if (mKeyguardMonitor.isLaunchTransitionFadingAway() || wakeAndUnlock) {
 444             mBackdrop.setVisibility(View.INVISIBLE);
 445             Trace.endSection();
 446             return;
 447         }
 448
 449         MediaMetadata mediaMetadata = getMediaMetadata();
 450
 451         if (DEBUG_MEDIA) {
 452             Log.v(TAG, "DEBUG_MEDIA: updating album art for notification "
 453                     + getMediaNotificationKey()
 454                     + " metadata=" + mediaMetadata
 455                     + " metaDataChanged=" + metaDataChanged
 456                     + " state=" + mStatusBarStateController.getState());
 457         }
 458
 459         Bitmap artworkBitmap = null;
 460         if (mediaMetadata != null) {
 461             artworkBitmap = mediaMetadata.getBitmap(MediaMetadata.METADATA_KEY_ART);
 462             if (artworkBitmap == null) {
 463                 artworkBitmap = mediaMetadata.getBitmap(MediaMetadata.METADATA_KEY_ALBUM_ART);
 464             }
 465         }
 466
 467         // Process artwork on a background thread and send the resulting bitmap to
 468         // finishUpdateMediaMetaData.
 469         if (metaDataChanged) {
 470             for (AsyncTask<?, ?, ?> task : mProcessArtworkTasks) {
 471                 task.cancel(true);
 472             }
 473             mProcessArtworkTasks.clear();
 474         }
 475         if (artworkBitmap != null) {
 476             mProcessArtworkTasks.add(new ProcessArtworkTask(this, metaDataChanged,
 477                     allowEnterAnimation).execute(artworkBitmap));
 478         } else {
 479             finishUpdateMediaMetaData(metaDataChanged, allowEnterAnimation, null);
 480         }
 481
 482         Trace.endSection();
 483     }
 484
 485     private void finishUpdateMediaMetaData(boolean metaDataChanged, boolean allowEnterAnimation,
 486             @Nullable Bitmap bmp) {
 487         Drawable artworkDrawable = null;
 488         if (bmp != null) {
 489             artworkDrawable = new BitmapDrawable(mBackdropBack.getResources(), bmp);
 490         }
 491         boolean hasMediaArtwork = artworkDrawable != null;
 492         boolean allowWhenShade = false;
 493         if (ENABLE_LOCKSCREEN_WALLPAPER && artworkDrawable == null) {
 494             Bitmap lockWallpaper =
 495                     mLockscreenWallpaper != null ? mLockscreenWallpaper.getBitmap() : null;
 496             if (lockWallpaper != null) {
 497                 artworkDrawable = new LockscreenWallpaper.WallpaperDrawable(
 498                         mBackdropBack.getResources(), lockWallpaper);
 499                 // We're in the SHADE mode on the SIM screen - yet we still need to show
 500                 // the lockscreen wallpaper in that mode.
 501                 allowWhenShade = mStatusBarStateController.getState() == KEYGUARD;
 502             }
 503         }
 504
 505         ShadeController shadeController = mShadeController.get();
 506         StatusBarWindowController windowController = mStatusBarWindowController.get();
 507         boolean hideBecauseOccluded = shadeController != null && shadeController.isOccluded();
 508
 509         final boolean hasArtwork = artworkDrawable != null;
 510         mColorExtractor.setHasMediaArtwork(hasMediaArtwork);
 511         if (mScrimController != null) {
 512             mScrimController.setHasBackdrop(hasArtwork);
 513         }
 514
 515         if ((hasArtwork || DEBUG_MEDIA_FAKE_ARTWORK)
 516                 && (mStatusBarStateController.getState() != StatusBarState.SHADE || allowWhenShade)
 517                 &&  mBiometricUnlockController != null && mBiometricUnlockController.getMode()
 518                         != BiometricUnlockController.MODE_WAKE_AND_UNLOCK_PULSING
 519                 && !hideBecauseOccluded) {
 520             // time to show some art!
 521             if (mBackdrop.getVisibility() != View.VISIBLE) {
 522                 mBackdrop.setVisibility(View.VISIBLE);
 523                 if (allowEnterAnimation) {
 524                     mBackdrop.setAlpha(0);
 525                     mBackdrop.animate().alpha(1f);
 526                 } else {
 527                     mBackdrop.animate().cancel();
 528                     mBackdrop.setAlpha(1f);
 529                 }
 530                 if (windowController != null) {
 531                     windowController.setBackdropShowing(true);
 532                 }
 533                 metaDataChanged = true;
 534                 if (DEBUG_MEDIA) {
 535                     Log.v(TAG, "DEBUG_MEDIA: Fading in album artwork");
 536                 }
 537             }
 538             if (metaDataChanged) {
 539                 if (mBackdropBack.getDrawable() != null) {
 540                     Drawable drawable =
 541                             mBackdropBack.getDrawable().getConstantState()
 542                                     .newDrawable(mBackdropFront.getResources()).mutate();
 543                     mBackdropFront.setImageDrawable(drawable);
 544                     mBackdropFront.setAlpha(1f);
 545                     mBackdropFront.setVisibility(View.VISIBLE);
 546                 } else {
 547                     mBackdropFront.setVisibility(View.INVISIBLE);
 548                 }
 549
 550                 if (DEBUG_MEDIA_FAKE_ARTWORK) {
 551                     final int c = 0xFF000000 | (int)(Math.random() * 0xFFFFFF);
 552                     Log.v(TAG, String.format("DEBUG_MEDIA: setting new color: 0x%08x", c));
 553                     mBackdropBack.setBackgroundColor(0xFFFFFFFF);
 554                     mBackdropBack.setImageDrawable(new ColorDrawable(c));
 555                 } else {
 556                     mBackdropBack.setImageDrawable(artworkDrawable);
 557                 }
 558
 559                 if (mBackdropFront.getVisibility() == View.VISIBLE) {
 560                     if (DEBUG_MEDIA) {
 561                         Log.v(TAG, "DEBUG_MEDIA: Crossfading album artwork from "
 562                                 + mBackdropFront.getDrawable()
 563                                 + " to "
 564                                 + mBackdropBack.getDrawable());
 565                     }
 566                     mBackdropFront.animate()
 567                             .setDuration(250)
 568                             .alpha(0f).withEndAction(mHideBackdropFront);
 569                 }
 570             }
 571         } else {
 572             // need to hide the album art, either because we are unlocked, on AOD
 573             // or because the metadata isn't there to support it
 574             if (mBackdrop.getVisibility() != View.GONE) {
 575                 if (DEBUG_MEDIA) {
 576                     Log.v(TAG, "DEBUG_MEDIA: Fading out album artwork");
 577                 }
 578                 boolean cannotAnimateDoze = shadeController != null
 579                         && shadeController.isDozing()
 580                         && !ScrimState.AOD.getAnimateChange();
 581                 if (mBiometricUnlockController != null && mBiometricUnlockController.getMode()
 582                         == BiometricUnlockController.MODE_WAKE_AND_UNLOCK_PULSING
 583                         || hideBecauseOccluded || cannotAnimateDoze) {
 584
 585                     // We are unlocking directly - no animation!
 586                     mBackdrop.setVisibility(View.GONE);
 587                     mBackdropBack.setImageDrawable(null);
 588                     if (windowController != null) {
 589                         windowController.setBackdropShowing(false);
 590                     }
 591                 } else {
 592                     if (windowController != null) {
 593                         windowController.setBackdropShowing(false);
 594                     }
 595                     mBackdrop.animate()
 596                             .alpha(0)
 597                             .setInterpolator(Interpolators.ACCELERATE_DECELERATE)
 598                             .setDuration(300)
 599                             .setStartDelay(0)
 600                             .withEndAction(() -> {
 601                                 mBackdrop.setVisibility(View.GONE);
 602                                 mBackdropFront.animate().cancel();
 603                                 mBackdropBack.setImageDrawable(null);
 604                                 mHandler.post(mHideBackdropFront);
 605                             });
 606                     if (mKeyguardMonitor.isKeyguardFadingAway()) {
 607                         mBackdrop.animate()
 608                                 // Make it disappear faster, as the focus should be on the activity
 609                                 // behind.
 610                                 .setDuration(mKeyguardMonitor.getKeyguardFadingAwayDuration() / 2)
 611                                 .setStartDelay(mKeyguardMonitor.getKeyguardFadingAwayDelay())
 612                                 .setInterpolator(Interpolators.LINEAR)
 613                                 .start();
 614                     }
 615                 }
 616             }
 617         }
 618     }
 619
 620     public void setup(BackDropView backdrop, ImageView backdropFront, ImageView backdropBack,
 621             ScrimController scrimController, LockscreenWallpaper lockscreenWallpaper) {
 622         mBackdrop = backdrop;
 623         mBackdropFront = backdropFront;
 624         mBackdropBack = backdropBack;
 625         mScrimController = scrimController;
 626         mLockscreenWallpaper = lockscreenWallpaper;
 627     }
 628
 629     public void setBiometricUnlockController(BiometricUnlockController biometricUnlockController) {
 630         mBiometricUnlockController = biometricUnlockController;
 631     }
 632
 633     /**
 634      * Hide the album artwork that is fading out and release its bitmap.
 635      */
 636     protected final Runnable mHideBackdropFront = new Runnable() {
 637         @Override
 638         public void run() {
 639             if (DEBUG_MEDIA) {
 640                 Log.v(TAG, "DEBUG_MEDIA: removing fade layer");
 641             }
 642             mBackdropFront.setVisibility(View.INVISIBLE);
 643             mBackdropFront.animate().cancel();
 644             mBackdropFront.setImageDrawable(null);
 645         }
 646     };
 647
 648     private Bitmap processArtwork(Bitmap artwork) {
 649         return mMediaArtworkProcessor.processArtwork(mContext, artwork);
 650     }
 651
 652     @MainThread
 653     private void removeTask(AsyncTask<?, ?, ?> task) {
 654         mProcessArtworkTasks.remove(task);
 655     }
 656
 657     /**
 658      * {@link AsyncTask} to prepare album art for use as backdrop on lock screen.
 659      */
 660     private static final class ProcessArtworkTask extends AsyncTask<Bitmap, Void, Bitmap> {
 661
 662         private final WeakReference<NotificationMediaManager> mManagerRef;
 663         private final boolean mMetaDataChanged;
 664         private final boolean mAllowEnterAnimation;
 665
 666         ProcessArtworkTask(NotificationMediaManager manager, boolean changed,
 667                 boolean allowAnimation) {
 668             mManagerRef = new WeakReference<>(manager);
 669             mMetaDataChanged = changed;
 670             mAllowEnterAnimation = allowAnimation;
 671         }
 672
 673         @Override
 674         protected Bitmap doInBackground(Bitmap... bitmaps) {
 675             NotificationMediaManager manager = mManagerRef.get();
 676             if (manager == null || bitmaps.length == 0 || isCancelled()) {
 677                 return null;
 678             }
 679             return manager.processArtwork(bitmaps[0]);
 680         }
 681
 682         @Override
 683         protected void onPostExecute(@Nullable Bitmap result) {
 684             NotificationMediaManager manager = mManagerRef.get();
 685             if (manager != null && !isCancelled()) {
 686                 manager.removeTask(this);
 687                 manager.finishUpdateMediaMetaData(mMetaDataChanged, mAllowEnterAnimation, result);
 688             }
 689         }
 690
 691         @Override
 692         protected void onCancelled(Bitmap result) {
 693             if (result != null) {
 694                 result.recycle();
 695             }
 696             NotificationMediaManager manager = mManagerRef.get();
 697             if (manager != null) {
 698                 manager.removeTask(this);
 699             }
 700         }
 701     }
 702
 703     public interface MediaListener {
 704         /**
 705          * Called whenever there's new metadata or playback state.
 706          * @param metadata Current metadata.
 707          * @param state Current playback state
 708          * @see PlaybackState.State
 709          */
 710         void onMetadataOrStateChanged(MediaMetadata metadata, @PlaybackState.State int state);
 711     }
 712 }