mirror of
https://github.com/zarzet/SpotiFLAC-Mobile.git
synced 2026-11-21 20:00:49 +01:00
perf(android): reuse the cover copies when only the media item's text changes
Lock screen lyrics send the playing item again with each lyric line as its title. Every send copied the unchanged cover twice at 512 px for the session and once at 256 px for the notification (about 2.3 MB on the main thread), and refreshed the playback state only to add the media ID it already had. The copies of the current cover are now kept while it is the same bitmap and still intact, and the refresh is skipped when the state already names the item.
This commit is contained in:
1 parent
2c2a915955
commit
3dea8d7587
5 files changed
+199
-10
No files matched your search
+18
@@ -100,6 +100,22 @@ from the upstream package are not vendored.
|
||||
their pixels; the notification's 256 px large icon is now scaled from the
|
||||
512 px bitmap instead of from up to 1023 px (owner-approved). The app's
|
||||
instrumented `MediaControlMetadataTest` covers the 512 px bound.
|
||||
- Android: reuse the session's and notification's copies of the current
|
||||
cover while it is the same bitmap. The app's lock screen lyrics send the
|
||||
playing item again with each lyric line as its title, and each send copied
|
||||
the cover twice at 512 px for the session (`ALBUM_ART`, `DISPLAY_ICON`)
|
||||
and once at 256 px for the notification's large icon, about 2.3 MB on the
|
||||
main thread per line. `ArtCopies` (new, covered by `ArtCopiesTest.java`
|
||||
under `android/src/test`) keeps one copy per key for the current
|
||||
`artBitmap`; `MediaArtwork.forSession(metadata, copies)` and
|
||||
`MediaArtwork.copy(source, size, copies, key)` use it, the one-argument
|
||||
`forSession` (used by `MediaControlMetadataTest`) still copies. Each key
|
||||
still gets its own copy, a recycled copy is made again, a recycled cover
|
||||
has none (as before), another cover drops the kept copies without
|
||||
recycling them, and `onDestroy` clears them. `publishMetadata` also skips
|
||||
its playback state refresh when the state already names the item's media
|
||||
ID, since the refresh only adds that ID. The notification is still
|
||||
rebuilt, as its title changes.
|
||||
- Darwin: `setMediaItem` reuses the last `MPMediaItemArtwork` while its
|
||||
`artCacheFile` has the same path, device, inode, size and modification time
|
||||
(`artworkForFile:`), instead of reading the file into a new image and
|
||||
@@ -179,6 +195,7 @@ and Android Auto instead of disguising them as unrelated custom actions.
|
||||
Compared against the pub.dev 0.18.19 package in the local pub cache:
|
||||
|
||||
- `android/build.gradle.kts`, `android/gradle/wrapper/gradle-wrapper.properties`
|
||||
- `android/src/main/java/com/ryanheise/audioservice/ArtCopies.java` (new)
|
||||
- `android/src/main/java/com/ryanheise/audioservice/AudioService.java`
|
||||
- `android/src/main/java/com/ryanheise/audioservice/AudioServicePlugin.java`
|
||||
- `android/src/main/java/com/ryanheise/audioservice/MediaArtwork.java` (new)
|
||||
@@ -186,6 +203,7 @@ Compared against the pub.dev 0.18.19 package in the local pub cache:
|
||||
- `android/src/main/java/com/ryanheise/audioservice/PinnedMetadataCache.java` (new)
|
||||
- `android/src/main/java/com/ryanheise/audioservice/RecentArtCache.java` (new)
|
||||
- `android/src/main/java/com/ryanheise/audioservice/QueueItemIndex.java` (new)
|
||||
- `android/src/test/java/com/ryanheise/audioservice/ArtCopiesTest.java` (new)
|
||||
- `android/src/test/java/com/ryanheise/audioservice/PinnedMetadataCacheTest.java` (new)
|
||||
- `android/src/test/java/com/ryanheise/audioservice/RecentArtCacheTest.java` (new)
|
||||
- `android/src/test/java/com/ryanheise/audioservice/QueueItemIndexTest.java` (new)
|
||||
|
||||
+55
@@ -0,0 +1,55 @@
|
||||
package com.ryanheise.audioservice;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* The copies the session and notification take of the current cover, kept
|
||||
* while the cover is the same object, so an update that changes only text
|
||||
* (a lock screen lyric line) reuses them instead of copying the art again.
|
||||
* Nothing is recycled: the session and notification may still show a copy.
|
||||
*/
|
||||
final class ArtCopies<T> {
|
||||
interface Copier<T> {
|
||||
T copy(T source);
|
||||
}
|
||||
|
||||
interface Check<T> {
|
||||
boolean usable(T value);
|
||||
}
|
||||
|
||||
private final Check<T> usable;
|
||||
private final Map<String, T> copies = new HashMap<>();
|
||||
private T source;
|
||||
|
||||
ArtCopies(Check<T> usable) {
|
||||
this.usable = usable;
|
||||
}
|
||||
|
||||
/** The copy of source for key: a kept one while it is intact, else a new one. */
|
||||
synchronized T get(T source, String key, Copier<T> copier) {
|
||||
if (source == null || !usable.usable(source)) return null;
|
||||
if (source != this.source) {
|
||||
copies.clear();
|
||||
this.source = source;
|
||||
}
|
||||
T copy = copies.get(key);
|
||||
if (copy != null && usable.usable(copy)) return copy;
|
||||
copy = copier.copy(source);
|
||||
if (copy == null) {
|
||||
copies.remove(key);
|
||||
} else {
|
||||
copies.put(key, copy);
|
||||
}
|
||||
return copy;
|
||||
}
|
||||
|
||||
synchronized void clear() {
|
||||
copies.clear();
|
||||
source = null;
|
||||
}
|
||||
|
||||
synchronized int size() {
|
||||
return copies.size();
|
||||
}
|
||||
}
|
||||
Vendored
+16
-5
@@ -74,6 +74,7 @@ public class AudioService extends MediaBrowserServiceCompat {
|
||||
public static final int KEYCODE_BYPASS_PAUSE = KeyEvent.KEYCODE_MEDIA_RECORD;
|
||||
public static final int MAX_COMPACT_ACTIONS = 3;
|
||||
private static final int ART_CACHE_ENTRIES = 3;
|
||||
private static final String NOTIFICATION_ART = "notification";
|
||||
private static final long AUTO_ENABLED_ACTIONS = PlaybackStateCompat.ACTION_STOP
|
||||
| PlaybackStateCompat.ACTION_PAUSE
|
||||
| PlaybackStateCompat.ACTION_PLAY
|
||||
@@ -297,6 +298,8 @@ public class AudioService extends MediaBrowserServiceCompat {
|
||||
private int[] compactActionIndices;
|
||||
private MediaMetadataCompat mediaMetadata;
|
||||
private Bitmap artBitmap;
|
||||
// The session's and notification's copies of the current cover.
|
||||
private final ArtCopies<Bitmap> artCopies = MediaArtwork.newCopies();
|
||||
private String notificationChannelId;
|
||||
private RecentArtCache<Bitmap> artBitmapCache;
|
||||
private boolean playing = false;
|
||||
@@ -393,6 +396,7 @@ public class AudioService extends MediaBrowserServiceCompat {
|
||||
queue = Collections.emptyList();
|
||||
controls.clear();
|
||||
artBitmapCache.evictAll();
|
||||
artCopies.clear();
|
||||
compactActionIndices = null;
|
||||
releaseMediaSession();
|
||||
ServiceCompat.stopForeground(this, config.androidResumeOnClick
|
||||
@@ -688,7 +692,7 @@ public class AudioService extends MediaBrowserServiceCompat {
|
||||
if (description.getDescription() != null)
|
||||
builder.setSubText(description.getDescription());
|
||||
if (artBitmap != null)
|
||||
builder.setLargeIcon(MediaArtwork.copy(artBitmap, 256));
|
||||
builder.setLargeIcon(MediaArtwork.copy(artBitmap, 256, artCopies, NOTIFICATION_ART));
|
||||
}
|
||||
if (config.androidNotificationClickStartsActivity)
|
||||
builder.setContentIntent(mediaSession.getController().getSessionActivity());
|
||||
@@ -887,7 +891,7 @@ public class AudioService extends MediaBrowserServiceCompat {
|
||||
if (destroyed || mediaSession == null) return;
|
||||
mediaMetadata = MediaArtwork.sanitize(mediaMetadata);
|
||||
try {
|
||||
mediaSession.setMetadata(MediaArtwork.forSession(mediaMetadata));
|
||||
mediaSession.setMetadata(MediaArtwork.forSession(mediaMetadata, artCopies));
|
||||
} catch (IllegalArgumentException | IllegalStateException error) {
|
||||
Log.w("AudioService", "Artwork rejected by media session; publishing text metadata", error);
|
||||
mediaMetadata = MediaArtwork.withoutArtwork(mediaMetadata);
|
||||
@@ -899,15 +903,22 @@ public class AudioService extends MediaBrowserServiceCompat {
|
||||
this.mediaMetadata = mediaMetadata;
|
||||
artBitmap = bitmap != null && !bitmap.isRecycled() ? bitmap : null;
|
||||
PlaybackStateCompat state = mediaSession.getController().getPlaybackState();
|
||||
if (state != null) {
|
||||
String mediaId = mediaMetadata.getString(MediaMetadataCompat.METADATA_KEY_MEDIA_ID);
|
||||
// The same item again (a lock screen lyric line) leaves the state as it is.
|
||||
if (state != null && !hasMediaId(state, mediaId)) {
|
||||
Bundle extras = state.getExtras() == null ? new Bundle() : new Bundle(state.getExtras());
|
||||
extras.putString(MediaConstants.PLAYBACK_STATE_EXTRAS_KEY_MEDIA_ID,
|
||||
mediaMetadata.getString(MediaMetadataCompat.METADATA_KEY_MEDIA_ID));
|
||||
extras.putString(MediaConstants.PLAYBACK_STATE_EXTRAS_KEY_MEDIA_ID, mediaId);
|
||||
mediaSession.setPlaybackState(new PlaybackStateCompat.Builder(state).setExtras(extras).build());
|
||||
}
|
||||
updateNotification();
|
||||
}
|
||||
|
||||
private static boolean hasMediaId(PlaybackStateCompat state, String mediaId) {
|
||||
Bundle extras = state.getExtras();
|
||||
return mediaId != null && extras != null
|
||||
&& mediaId.equals(extras.getString(MediaConstants.PLAYBACK_STATE_EXTRAS_KEY_MEDIA_ID));
|
||||
}
|
||||
|
||||
private MediaMetadataCompat putArtToMetadata(MediaMetadataCompat mediaMetadata, Bitmap bitmap) {
|
||||
return new MediaMetadataCompat.Builder(mediaMetadata)
|
||||
.putBitmap(MediaMetadataCompat.METADATA_KEY_ALBUM_ART, bitmap)
|
||||
|
||||
Vendored
+21
-5
@@ -50,19 +50,33 @@ final class MediaArtwork {
|
||||
}
|
||||
|
||||
static MediaMetadataCompat sanitize(MediaMetadataCompat metadata) {
|
||||
return transform(metadata, false, false);
|
||||
return transform(metadata, false, false, null);
|
||||
}
|
||||
|
||||
static MediaMetadataCompat forSession(MediaMetadataCompat metadata) {
|
||||
return transform(metadata, true, false);
|
||||
return transform(metadata, true, false, null);
|
||||
}
|
||||
|
||||
/** Like {@link #forSession(MediaMetadataCompat)}, reusing the copies kept in copies. */
|
||||
static MediaMetadataCompat forSession(MediaMetadataCompat metadata, ArtCopies<Bitmap> copies) {
|
||||
return transform(metadata, true, false, copies);
|
||||
}
|
||||
|
||||
static MediaMetadataCompat withoutArtwork(MediaMetadataCompat metadata) {
|
||||
return transform(metadata, false, true);
|
||||
return transform(metadata, false, true, null);
|
||||
}
|
||||
|
||||
/** The cover's copy for key, kept in copies while the cover stays the same. */
|
||||
static Bitmap copy(Bitmap source, int maxDimension, ArtCopies<Bitmap> copies, String key) {
|
||||
return copies.get(source, key, bitmap -> copy(bitmap, maxDimension));
|
||||
}
|
||||
|
||||
static ArtCopies<Bitmap> newCopies() {
|
||||
return new ArtCopies<>(bitmap -> !bitmap.isRecycled());
|
||||
}
|
||||
|
||||
private static MediaMetadataCompat transform(MediaMetadataCompat metadata,
|
||||
boolean copyArtwork, boolean omit) {
|
||||
boolean copyArtwork, boolean omit, ArtCopies<Bitmap> copies) {
|
||||
MediaMetadataCompat.Builder builder = new MediaMetadataCompat.Builder(metadata);
|
||||
Bundle values = metadata.getBundle();
|
||||
for (String key : values.keySet()) {
|
||||
@@ -72,7 +86,9 @@ final class MediaArtwork {
|
||||
// Each key gets its own copy: some frameworks consume a bitmap
|
||||
// while scaling it, before visiting another key with the same art.
|
||||
builder.putBitmap(key, omit || bitmap.isRecycled() ? null
|
||||
: copyArtwork ? copy(bitmap, MAX_DIMENSION) : bitmap);
|
||||
: !copyArtwork ? bitmap
|
||||
: copies == null ? copy(bitmap, MAX_DIMENSION)
|
||||
: copy(bitmap, MAX_DIMENSION, copies, key));
|
||||
}
|
||||
return builder.build();
|
||||
}
|
||||
|
||||
Vendored
+89
@@ -0,0 +1,89 @@
|
||||
package com.ryanheise.audioservice;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
|
||||
import org.junit.Test;
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertNotSame;
|
||||
import static org.junit.Assert.assertNull;
|
||||
import static org.junit.Assert.assertSame;
|
||||
|
||||
public class ArtCopiesTest {
|
||||
/** A cover or a copy of one; recycled ones are unusable. */
|
||||
private static final class Art {
|
||||
final String name;
|
||||
boolean recycled;
|
||||
|
||||
Art(String name) {
|
||||
this.name = name;
|
||||
}
|
||||
}
|
||||
|
||||
private final List<String> copied = new ArrayList<>();
|
||||
private final ArtCopies<Art> copies = new ArtCopies<>(art -> !art.recycled);
|
||||
|
||||
private Art copy(Art source, String key) {
|
||||
return copies.get(source, key, art -> {
|
||||
copied.add(art.name + "@" + key);
|
||||
return new Art(art.name + "@" + key);
|
||||
});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void lyricLinesOverTheSameCoverCopyItOncePerKey() {
|
||||
Art cover = new Art("cover");
|
||||
Set<Art> shown = new HashSet<>();
|
||||
for (int line = 0; line < 100; line++) {
|
||||
shown.add(copy(cover, "album"));
|
||||
shown.add(copy(cover, "icon"));
|
||||
shown.add(copy(cover, "notification"));
|
||||
}
|
||||
assertEquals(3, shown.size());
|
||||
assertEquals(3, copied.size());
|
||||
assertNotSame(copy(cover, "album"), copy(cover, "icon"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void anotherCoverGetsNewCopiesAndDropsTheOldOnes() {
|
||||
Art first = new Art("first");
|
||||
Art album = copy(first, "album");
|
||||
Art second = new Art("second");
|
||||
Art next = copy(second, "album");
|
||||
assertNotSame(album, next);
|
||||
assertEquals(1, copies.size());
|
||||
assertNotSame(album, copy(first, "album"));
|
||||
assertEquals(3, copied.size());
|
||||
assertEquals(false, album.recycled);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void aRecycledCopyIsMadeAgainAndARecycledCoverHasNone() {
|
||||
Art cover = new Art("cover");
|
||||
Art album = copy(cover, "album");
|
||||
album.recycled = true;
|
||||
Art again = copy(cover, "album");
|
||||
assertNotSame(album, again);
|
||||
assertSame(again, copy(cover, "album"));
|
||||
assertEquals(2, copied.size());
|
||||
|
||||
cover.recycled = true;
|
||||
assertNull(copy(cover, "album"));
|
||||
assertNull(copies.get(null, "album", art -> art));
|
||||
assertEquals(2, copied.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void aFailedCopyIsTriedAgainAndClearForgetsEverything() {
|
||||
Art cover = new Art("cover");
|
||||
assertNull(copies.get(cover, "album", art -> null));
|
||||
assertEquals(0, copies.size());
|
||||
Art album = copy(cover, "album");
|
||||
assertSame(album, copy(cover, "album"));
|
||||
copies.clear();
|
||||
assertEquals(0, copies.size());
|
||||
assertNotSame(album, copy(cover, "album"));
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user