279 lines
14 KiB
Java
279 lines
14 KiB
Java
/*
|
|
This file is part of Subsonic.
|
|
Subsonic is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
Subsonic is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
You should have received a copy of the GNU General Public License
|
|
along with Subsonic. If not, see <http://www.gnu.org/licenses/>.
|
|
Copyright 2014 (C) Scott Jackson
|
|
*/
|
|
|
|
package net.nullsum.audinaut.util;
|
|
|
|
import android.app.Notification;
|
|
import android.app.NotificationChannel;
|
|
import android.app.NotificationManager;
|
|
import android.app.PendingIntent;
|
|
import android.content.ComponentName;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.graphics.Bitmap;
|
|
import android.graphics.BitmapFactory;
|
|
import android.os.Build;
|
|
import android.os.Handler;
|
|
import android.util.Log;
|
|
import android.view.KeyEvent;
|
|
|
|
import androidx.core.app.NotificationCompat;
|
|
import androidx.media.app.NotificationCompat.MediaStyle;
|
|
import android.support.v4.media.session.MediaSessionCompat;
|
|
import android.support.v4.media.MediaMetadataCompat;
|
|
|
|
import net.nullsum.audinaut.R;
|
|
import net.nullsum.audinaut.activity.SubsonicActivity;
|
|
import net.nullsum.audinaut.activity.SubsonicFragmentActivity;
|
|
import net.nullsum.audinaut.domain.MusicDirectory;
|
|
import net.nullsum.audinaut.domain.PlayerState;
|
|
import net.nullsum.audinaut.provider.AudinautWidgetProvider;
|
|
import net.nullsum.audinaut.service.DownloadFile;
|
|
import net.nullsum.audinaut.service.DownloadService;
|
|
|
|
import static android.content.Context.NOTIFICATION_SERVICE;
|
|
|
|
public final class Notifications {
|
|
private static final int NOTIFICATION_ID_PLAYING = 100;
|
|
private static final int NOTIFICATION_ID_DOWNLOADING = 102;
|
|
private static final String CHANNEL_PLAYING_ID = "playback_controls";
|
|
private static final String CHANNEL_DOWNLOADING_ID = "media_download";
|
|
private static final String TAG = Notifications.class.getSimpleName();
|
|
private static boolean playShowing = false;
|
|
private static boolean downloadShowing = false;
|
|
private static boolean downloadForeground = false;
|
|
private static boolean persistentPlayingShowing = false;
|
|
|
|
public static void showPlayingNotification(final Context context, final DownloadService downloadService, final Handler handler, MusicDirectory.Entry song) {
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
|
|
int importance = NotificationManager.IMPORTANCE_LOW;
|
|
|
|
NotificationChannel mChannel = new NotificationChannel(
|
|
CHANNEL_PLAYING_ID, context.getString(R.string.channel_playing_name), importance);
|
|
mChannel.setDescription(context.getString(R.string.channel_playing_description));
|
|
NotificationManager notificationManager = (NotificationManager) context.getSystemService(
|
|
NOTIFICATION_SERVICE);
|
|
notificationManager.createNotificationChannel(mChannel);
|
|
}
|
|
|
|
final boolean playing = downloadService.getPlayerState() == PlayerState.STARTED;
|
|
Intent notificationIntent = new Intent(context, SubsonicFragmentActivity.class);
|
|
notificationIntent.putExtra(Constants.INTENT_EXTRA_NAME_DOWNLOAD, true);
|
|
notificationIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
|
|
|
|
Intent cancelIntent = new Intent("KEYCODE_MEDIA_STOP")
|
|
.setComponent(new ComponentName(context, DownloadService.class))
|
|
.putExtra(Intent.EXTRA_KEY_EVENT, new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_MEDIA_STOP));
|
|
int[] compactActions = new int[]{0, 1, 2};
|
|
|
|
MediaSessionCompat mediaSession = new MediaSessionCompat(context, "Audinaut");
|
|
MediaSessionCompat.Token mediaToken = mediaSession.getSessionToken();
|
|
MediaMetadataCompat.Builder metadataBuilder = new MediaMetadataCompat.Builder();
|
|
|
|
mediaSession.setMetadata(metadataBuilder
|
|
.putLong(MediaMetadataCompat.METADATA_KEY_DURATION, -1)
|
|
.putBitmap(MediaMetadataCompat.METADATA_KEY_ALBUM_ART, getAlbumArt(context, song))
|
|
//.putBitmap(MediaMetadataCompat.METADATA_KEY_DISPLAY_ICON, R.drawable.notification_logo)
|
|
.putString(MediaMetadataCompat.METADATA_KEY_TITLE, song.getTitle())
|
|
.putString(MediaMetadataCompat.METADATA_KEY_ARTIST, song.getArtist())
|
|
.build() );
|
|
|
|
MediaStyle mediaStyle = new MediaStyle()
|
|
.setShowActionsInCompactView(compactActions)
|
|
.setShowCancelButton(true)
|
|
.setCancelButtonIntent(PendingIntent.getService(context, 0, cancelIntent, 0))
|
|
.setMediaSession(mediaToken);
|
|
|
|
NotificationCompat.Builder builder = new NotificationCompat.Builder(context, CHANNEL_PLAYING_ID)
|
|
.setChannelId(CHANNEL_PLAYING_ID)
|
|
.setContentTitle(song.getTitle())
|
|
.setContentText(song.getArtist())
|
|
.setSubText(song.getAlbum())
|
|
.setTicker(song.getTitle())
|
|
.setOngoing(playing)
|
|
.setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
|
|
.setShowWhen(false)
|
|
.setLargeIcon(getAlbumArt(context, song))
|
|
.setSmallIcon(R.drawable.notification_logo)
|
|
.setStyle(mediaStyle)
|
|
.setContentIntent(PendingIntent.getActivity(context, 0, notificationIntent, 0));
|
|
addActions(context, builder, playing);
|
|
final Notification notification = builder.build();
|
|
|
|
if(playing) {
|
|
notification.flags |= Notification.FLAG_NO_CLEAR | Notification.FLAG_ONGOING_EVENT;
|
|
}
|
|
|
|
playShowing = true;
|
|
if (downloadForeground && downloadShowing) {
|
|
downloadForeground = false;
|
|
handler.post(() -> {
|
|
downloadService.stopForeground(true);
|
|
showDownloadingNotification(context, downloadService, handler, downloadService.getCurrentDownloading(), downloadService.getBackgroundDownloads().size());
|
|
downloadService.startForeground(NOTIFICATION_ID_PLAYING, notification);
|
|
});
|
|
} else {
|
|
handler.post(() -> {
|
|
if (playing) {
|
|
downloadService.startForeground(NOTIFICATION_ID_PLAYING, notification);
|
|
} else {
|
|
playShowing = false;
|
|
persistentPlayingShowing = true;
|
|
NotificationManager notificationManager = (NotificationManager) context.getSystemService(NOTIFICATION_SERVICE);
|
|
downloadService.stopForeground(false);
|
|
notificationManager.notify(NOTIFICATION_ID_PLAYING, notification);
|
|
}
|
|
});
|
|
}
|
|
|
|
// Update widget
|
|
AudinautWidgetProvider.notifyInstances(context, downloadService, playing);
|
|
}
|
|
|
|
private static Bitmap getAlbumArt(Context context, MusicDirectory.Entry song) {
|
|
try {
|
|
ImageLoader imageLoader = SubsonicActivity.getStaticImageLoader(context);
|
|
Bitmap bitmap = null;
|
|
if (imageLoader != null) {
|
|
bitmap = imageLoader.getCachedImage(context, song, false);
|
|
}
|
|
if (bitmap == null) {
|
|
// set default album art
|
|
return BitmapFactory.decodeResource(context.getResources(), R.drawable.unknown_album);
|
|
} else {
|
|
return bitmap;
|
|
}
|
|
} catch (Exception x) {
|
|
Log.w(TAG, "Failed to get notification cover art", x);
|
|
return BitmapFactory.decodeResource(context.getResources(), R.drawable.unknown_album);
|
|
}
|
|
}
|
|
|
|
private static void addActions(final Context context, final NotificationCompat.Builder builder, final boolean playing) {
|
|
PendingIntent pendingIntent;
|
|
|
|
Intent prevIntent = new Intent("KEYCODE_MEDIA_PREVIOUS");
|
|
prevIntent.setComponent(new ComponentName(context, DownloadService.class));
|
|
prevIntent.putExtra(Intent.EXTRA_KEY_EVENT, new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_MEDIA_PREVIOUS));
|
|
pendingIntent = PendingIntent.getService(context, 0, prevIntent, 0);
|
|
builder.addAction(R.drawable.notification_media_backward, "Previous", pendingIntent);
|
|
if (playing) {
|
|
Intent pauseIntent = new Intent("KEYCODE_MEDIA_PLAY_PAUSE");
|
|
pauseIntent.setComponent(new ComponentName(context, DownloadService.class));
|
|
pauseIntent.putExtra(Intent.EXTRA_KEY_EVENT, new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE));
|
|
pendingIntent = PendingIntent.getService(context, 0, pauseIntent, 0);
|
|
builder.addAction(R.drawable.notification_media_pause, "Pause", pendingIntent);
|
|
} else {
|
|
Intent playIntent = new Intent("KEYCODE_MEDIA_PLAY");
|
|
playIntent.setComponent(new ComponentName(context, DownloadService.class));
|
|
playIntent.putExtra(Intent.EXTRA_KEY_EVENT, new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_MEDIA_PLAY));
|
|
pendingIntent = PendingIntent.getService(context, 0, playIntent, 0);
|
|
builder.addAction(R.drawable.notification_media_start, "Play", pendingIntent);
|
|
}
|
|
Intent nextIntent = new Intent("KEYCODE_MEDIA_NEXT");
|
|
nextIntent.setComponent(new ComponentName(context, DownloadService.class));
|
|
nextIntent.putExtra(Intent.EXTRA_KEY_EVENT, new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_MEDIA_NEXT));
|
|
pendingIntent = PendingIntent.getService(context, 0, nextIntent, 0);
|
|
builder.addAction(R.drawable.notification_media_forward, "Next", pendingIntent);
|
|
}
|
|
|
|
public static void hidePlayingNotification(final Context context, final DownloadService downloadService, Handler handler) {
|
|
playShowing = false;
|
|
|
|
// Remove notification and remove the service from the foreground
|
|
handler.post(() -> {
|
|
downloadService.stopForeground(true);
|
|
|
|
if (persistentPlayingShowing) {
|
|
NotificationManager notificationManager = (NotificationManager) context.getSystemService(NOTIFICATION_SERVICE);
|
|
notificationManager.cancel(NOTIFICATION_ID_PLAYING);
|
|
persistentPlayingShowing = false;
|
|
}
|
|
});
|
|
|
|
// Get downloadNotification in foreground if playing
|
|
if (downloadShowing) {
|
|
showDownloadingNotification(context, downloadService, handler, downloadService.getCurrentDownloading(), downloadService.getBackgroundDownloads().size());
|
|
}
|
|
|
|
// Update widget
|
|
AudinautWidgetProvider.notifyInstances(context, downloadService, false);
|
|
}
|
|
|
|
public static void showDownloadingNotification(final Context context, final DownloadService downloadService, Handler handler, DownloadFile file, int size) {
|
|
Intent cancelIntent = new Intent(context, DownloadService.class);
|
|
cancelIntent.setAction(DownloadService.CANCEL_DOWNLOADS);
|
|
PendingIntent cancelPI = PendingIntent.getService(context, 0, cancelIntent, 0);
|
|
|
|
String currentDownloading, currentSize;
|
|
if (file != null) {
|
|
currentDownloading = file.getSong().getTitle();
|
|
currentSize = Util.formatLocalizedBytes(file.getEstimatedSize(), context);
|
|
} else {
|
|
currentDownloading = "none";
|
|
currentSize = "0";
|
|
}
|
|
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
|
|
int importance = NotificationManager.IMPORTANCE_LOW;
|
|
NotificationChannel mChannel = new NotificationChannel(
|
|
CHANNEL_DOWNLOADING_ID, context.getString(R.string.channel_download_name), importance);
|
|
mChannel.setDescription(context.getString(R.string.channel_download_description));
|
|
NotificationManager notificationManager = (NotificationManager) context.getSystemService(
|
|
NOTIFICATION_SERVICE);
|
|
notificationManager.createNotificationChannel(mChannel);
|
|
}
|
|
|
|
Intent notificationIntent = new Intent(context, SubsonicFragmentActivity.class);
|
|
notificationIntent.putExtra(Constants.INTENT_EXTRA_NAME_DOWNLOAD_VIEW, true);
|
|
notificationIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
|
|
|
|
final Notification notification = new NotificationCompat.Builder(context, CHANNEL_DOWNLOADING_ID)
|
|
.setChannelId(CHANNEL_DOWNLOADING_ID)
|
|
.setSmallIcon(android.R.drawable.stat_sys_download)
|
|
.setContentTitle(context.getResources().getString(R.string.download_downloading_title, size))
|
|
.setContentText(context.getResources().getString(R.string.download_downloading_summary, currentDownloading))
|
|
.setOngoing(true)
|
|
.addAction(R.drawable.notification_close,
|
|
context.getResources().getString(R.string.common_cancel),
|
|
cancelPI)
|
|
.setContentIntent(PendingIntent.getActivity(context, 2, notificationIntent, 0))
|
|
.setStyle(new NotificationCompat.BigTextStyle()
|
|
.bigText(context.getResources().getString(R.string.download_downloading_summary_expanded, currentDownloading, currentSize)))
|
|
.setProgress(10, 5, true).build();
|
|
|
|
downloadShowing = true;
|
|
if (playShowing) {
|
|
NotificationManager notificationManager = (NotificationManager) context.getSystemService(NOTIFICATION_SERVICE);
|
|
notificationManager.notify(NOTIFICATION_ID_DOWNLOADING, notification);
|
|
} else {
|
|
downloadForeground = true;
|
|
handler.post(() -> downloadService.startForeground(NOTIFICATION_ID_DOWNLOADING, notification));
|
|
}
|
|
|
|
}
|
|
|
|
public static void hideDownloadingNotification(final Context context, final DownloadService downloadService, Handler handler) {
|
|
downloadShowing = false;
|
|
if (playShowing) {
|
|
NotificationManager notificationManager = (NotificationManager) context.getSystemService(NOTIFICATION_SERVICE);
|
|
notificationManager.cancel(NOTIFICATION_ID_DOWNLOADING);
|
|
} else {
|
|
downloadForeground = false;
|
|
handler.post(() -> downloadService.stopForeground(true));
|
|
}
|
|
}
|
|
}
|