change application id for release

app/src/main/java/com/dkanada/gramophone/dialogs/AddToPlaylistDialog.java

@@ -0,0 +1,77 @@
+package com.dkanada.gramophone.dialogs;
+
+import android.app.Dialog;
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+import androidx.fragment.app.DialogFragment;
+
+import com.afollestad.materialdialogs.MaterialDialog;
+import com.dkanada.gramophone.R;
+import com.dkanada.gramophone.interfaces.MediaCallback;
+import com.dkanada.gramophone.model.Playlist;
+import com.dkanada.gramophone.model.Song;
+import com.dkanada.gramophone.util.PlaylistUtil;
+import com.dkanada.gramophone.util.QueryUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class AddToPlaylistDialog extends DialogFragment {
+
+    @NonNull
+    public static AddToPlaylistDialog create(Song song) {
+        List<Song> list = new ArrayList<>();
+        list.add(song);
+        return create(list);
+    }
+
+    @NonNull
+    public static AddToPlaylistDialog create(List<Song> songs) {
+        AddToPlaylistDialog dialog = new AddToPlaylistDialog();
+
+        Bundle args = new Bundle();
+        args.putParcelableArrayList("songs", new ArrayList<>(songs));
+
+        dialog.setArguments(args);
+        return dialog;
+    }
+
+    @NonNull
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        List<Playlist> playlists = new ArrayList<>();
+        MaterialDialog dialog = new MaterialDialog.Builder(getActivity())
+                .title(R.string.action_add_to_playlist)
+                .items(getActivity().getResources().getString(R.string.action_new_playlist))
+                .itemsCallback((materialDialog, view, i, charSequence) -> {
+                    final List<Song> songs = getArguments().getParcelableArrayList("songs");
+                    if (songs == null) return;
+
+                    if (i == 0) {
+                        materialDialog.dismiss();
+                        CreatePlaylistDialog.create(songs).show(getActivity().getSupportFragmentManager(), "ADD_TO_PLAYLIST");
+                    } else {
+                        materialDialog.dismiss();
+                        PlaylistUtil.addItems(songs, playlists.get(i - 1).id);
+                    }
+                })
+                .build();
+
+        QueryUtil.getPlaylists(new MediaCallback() {
+            @Override
+            public void onLoadMedia(List<?> media) {
+                playlists.addAll((List<Playlist>) media);
+
+                CharSequence[] names = new CharSequence[playlists.size() + 1];
+                names[0] = getActivity().getResources().getString(R.string.action_new_playlist);
+                for (int i = 0; i < playlists.size(); i++) {
+                    names[i + 1] = playlists.get(i).name;
+                }
+
+                dialog.setItems(names);
+            }
+        });
+
+        return dialog;
+    }
+}

app/src/main/java/com/dkanada/gramophone/dialogs/CreatePlaylistDialog.java

@@ -0,0 +1,61 @@
+package com.dkanada.gramophone.dialogs;
+
+import android.app.Dialog;
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.DialogFragment;
+import android.text.InputType;
+
+import com.afollestad.materialdialogs.MaterialDialog;
+import com.dkanada.gramophone.R;
+import com.dkanada.gramophone.model.Song;
+import com.dkanada.gramophone.util.PlaylistUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class CreatePlaylistDialog extends DialogFragment {
+
+    private static final String SONGS = "songs";
+
+    @NonNull
+    public static CreatePlaylistDialog create() {
+        return create((Song) null);
+    }
+
+    @NonNull
+    public static CreatePlaylistDialog create(@Nullable Song song) {
+        List<Song> list = new ArrayList<>();
+        if (song != null) list.add(song);
+        return create(list);
+    }
+
+    @NonNull
+    public static CreatePlaylistDialog create(List<Song> songs) {
+        CreatePlaylistDialog dialog = new CreatePlaylistDialog();
+        Bundle args = new Bundle();
+        args.putParcelableArrayList(SONGS, new ArrayList<>(songs));
+        dialog.setArguments(args);
+        return dialog;
+    }
+
+    @NonNull
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        return new MaterialDialog.Builder(getActivity())
+                .title(R.string.action_new_playlist)
+                .positiveText(R.string.create_action)
+                .negativeText(android.R.string.cancel)
+                .inputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PERSON_NAME | InputType.TYPE_TEXT_FLAG_CAP_WORDS)
+                .input(R.string.playlist_name_empty, 0, false, (materialDialog, charSequence) -> {
+                    final String name = charSequence.toString().trim();
+                    if (getActivity() == null || getArguments() == null || name.isEmpty()) return;
+                    List<Song> songs = getArguments().getParcelableArrayList(SONGS);
+                    if (songs != null) {
+                        PlaylistUtil.createPlaylist(name, songs);
+                    }
+                })
+                .build();
+    }
+}

app/src/main/java/com/dkanada/gramophone/dialogs/DeletePlaylistDialog.java

@@ -0,0 +1,61 @@
+package com.dkanada.gramophone.dialogs;
+
+import android.app.Dialog;
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+import androidx.fragment.app.DialogFragment;
+import android.text.Html;
+
+import com.afollestad.materialdialogs.MaterialDialog;
+import com.dkanada.gramophone.R;
+import com.dkanada.gramophone.model.Playlist;
+import com.dkanada.gramophone.util.PlaylistUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class DeletePlaylistDialog extends DialogFragment {
+
+    @NonNull
+    public static DeletePlaylistDialog create(Playlist playlist) {
+        List<Playlist> list = new ArrayList<>();
+        list.add(playlist);
+        return create(list);
+    }
+
+    @NonNull
+    public static DeletePlaylistDialog create(List<Playlist> playlists) {
+        DeletePlaylistDialog dialog = new DeletePlaylistDialog();
+        Bundle args = new Bundle();
+        args.putParcelableArrayList("playlists", new ArrayList<>(playlists));
+        dialog.setArguments(args);
+        return dialog;
+    }
+
+    @NonNull
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        final List<Playlist> playlists = getArguments().getParcelableArrayList("playlists");
+        int title;
+        CharSequence content;
+        // noinspection ConstantConditions
+        if (playlists.size() > 1) {
+            title = R.string.delete_playlists_title;
+            content = Html.fromHtml(getString(R.string.delete_x_playlists, playlists.size()));
+        } else {
+            title = R.string.delete_playlist_title;
+            content = Html.fromHtml(getString(R.string.delete_playlist_x, playlists.get(0).name));
+        }
+
+        return new MaterialDialog.Builder(getActivity())
+                .title(title)
+                .content(content)
+                .positiveText(R.string.delete_action)
+                .negativeText(android.R.string.cancel)
+                .onPositive((dialog, which) -> {
+                    if (getActivity() == null) return;
+                    PlaylistUtil.deletePlaylist(playlists);
+                })
+                .build();
+    }
+}

app/src/main/java/com/dkanada/gramophone/dialogs/RemoveFromPlaylistDialog.java

@@ -0,0 +1,66 @@
+package com.dkanada.gramophone.dialogs;
+
+import android.app.Dialog;
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+import androidx.fragment.app.DialogFragment;
+import android.text.Html;
+
+import com.afollestad.materialdialogs.MaterialDialog;
+import com.dkanada.gramophone.R;
+import com.dkanada.gramophone.model.PlaylistSong;
+import com.dkanada.gramophone.model.Song;
+import com.dkanada.gramophone.util.PlaylistUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class RemoveFromPlaylistDialog extends DialogFragment {
+
+    @NonNull
+    public static RemoveFromPlaylistDialog create(Song song) {
+        List<Song> list = new ArrayList<>();
+        list.add(song);
+        return create(list);
+    }
+
+    @NonNull
+    public static RemoveFromPlaylistDialog create(List<Song> songs) {
+        RemoveFromPlaylistDialog dialog = new RemoveFromPlaylistDialog();
+
+        Bundle args = new Bundle();
+        args.putParcelableArrayList("songs", new ArrayList<>(songs));
+
+        dialog.setArguments(args);
+        return dialog;
+    }
+
+    @NonNull
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        final List<PlaylistSong> songs = getArguments().getParcelableArrayList("songs");
+
+        int title;
+        CharSequence content;
+        if (songs.size() > 1) {
+            title = R.string.remove_songs_from_playlist_title;
+            content = Html.fromHtml(getString(R.string.remove_x_songs_from_playlist, songs.size()));
+        } else {
+            title = R.string.remove_song_from_playlist_title;
+            content = Html.fromHtml(getString(R.string.remove_song_x_from_playlist, songs.get(0).title));
+        }
+
+        return new MaterialDialog.Builder(getActivity())
+                .title(title)
+                .content(content)
+                .positiveText(R.string.remove_action)
+                .negativeText(android.R.string.cancel)
+                .onPositive((dialog, which) -> {
+                    if (getActivity() == null) return;
+
+                    PlaylistSong song = songs.get(0);
+                    PlaylistUtil.deleteItems(songs, song.playlistId);
+                })
+                .build();
+    }
+}

app/src/main/java/com/dkanada/gramophone/dialogs/RenamePlaylistDialog.java

@@ -0,0 +1,49 @@
+package com.dkanada.gramophone.dialogs;
+
+import android.app.Dialog;
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+import androidx.fragment.app.DialogFragment;
+import android.text.InputType;
+
+import com.afollestad.materialdialogs.MaterialDialog;
+import com.dkanada.gramophone.R;
+import com.dkanada.gramophone.model.Playlist;
+import com.dkanada.gramophone.util.PlaylistUtil;
+
+public class RenamePlaylistDialog extends DialogFragment {
+
+    private static final String PLAYLIST_ID = "playlist_id";
+
+    @NonNull
+    public static RenamePlaylistDialog create(Playlist playlist) {
+        RenamePlaylistDialog dialog = new RenamePlaylistDialog();
+
+        Bundle args = new Bundle();
+        args.putString(PLAYLIST_ID, playlist.id);
+
+        dialog.setArguments(args);
+        return dialog;
+    }
+
+    @NonNull
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        String playlistId = getArguments().getString(PLAYLIST_ID);
+        return new MaterialDialog.Builder(getActivity())
+                .title(R.string.rename_playlist_title)
+                .positiveText(R.string.rename_action)
+                .negativeText(android.R.string.cancel)
+                .inputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PERSON_NAME | InputType.TYPE_TEXT_FLAG_CAP_WORDS)
+                .input(getString(R.string.playlist_name_empty), "", false,
+                        (materialDialog, charSequence) -> {
+                            final String name = charSequence.toString().trim();
+
+                            if (!name.isEmpty()) {
+                                String id = getArguments().getString(PLAYLIST_ID);
+                                PlaylistUtil.renamePlaylist(id, name);
+                            }
+                        })
+                .build();
+    }
+}

app/src/main/java/com/dkanada/gramophone/dialogs/SleepTimerDialog.java

@@ -0,0 +1,196 @@
+package com.dkanada.gramophone.dialogs;
+
+import android.app.AlarmManager;
+import android.app.Dialog;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.CountDownTimer;
+import android.os.SystemClock;
+import androidx.annotation.NonNull;
+import androidx.fragment.app.DialogFragment;
+import android.widget.CheckBox;
+import android.widget.FrameLayout;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import com.afollestad.materialdialogs.DialogAction;
+import com.afollestad.materialdialogs.MaterialDialog;
+import com.afollestad.materialdialogs.internal.ThemeSingleton;
+import com.dkanada.gramophone.R;
+import com.dkanada.gramophone.helper.MusicPlayerRemote;
+import com.dkanada.gramophone.service.MusicService;
+import com.dkanada.gramophone.util.MusicUtil;
+import com.dkanada.gramophone.util.PreferenceUtil;
+import com.triggertrap.seekarc.SeekArc;
+
+import butterknife.BindView;
+import butterknife.ButterKnife;
+
+public class SleepTimerDialog extends DialogFragment {
+    @BindView(R.id.seek_arc)
+    SeekArc seekArc;
+
+    @BindView(R.id.timer_display)
+    TextView timerDisplay;
+
+    @BindView(R.id.should_finish_last_song)
+    CheckBox shouldFinishLastSong;
+
+    private int seekArcProgress;
+    private MaterialDialog materialDialog;
+    private TimerUpdater timerUpdater;
+
+    @Override
+    public void onDismiss(DialogInterface dialog) {
+        super.onDismiss(dialog);
+        timerUpdater.cancel();
+    }
+
+    @NonNull
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        timerUpdater = new TimerUpdater();
+        materialDialog = new MaterialDialog.Builder(getActivity())
+                .title(getActivity().getResources().getString(R.string.action_sleep_timer))
+                .positiveText(R.string.action_set)
+                .onPositive((dialog, which) -> {
+                    if (getActivity() == null) {
+                        return;
+                    }
+
+                    PreferenceUtil.getInstance(getActivity()).setSleepTimerFinishMusic(shouldFinishLastSong.isChecked());
+
+                    final int minutes = seekArcProgress;
+
+                    PendingIntent pi = makeTimerPendingIntent(PendingIntent.FLAG_CANCEL_CURRENT);
+
+                    final long nextSleepTimerElapsedTime = SystemClock.elapsedRealtime() + minutes * 60 * 1000;
+                    PreferenceUtil.getInstance(getActivity()).setNextSleepTimerElapsedRealtime(nextSleepTimerElapsedTime);
+                    AlarmManager am = (AlarmManager) getActivity().getSystemService(Context.ALARM_SERVICE);
+                    am.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, nextSleepTimerElapsedTime, pi);
+
+                    Toast.makeText(getActivity(), getActivity().getResources().getString(R.string.sleep_timer_set, minutes), Toast.LENGTH_SHORT).show();
+                })
+                .onNeutral((dialog, which) -> {
+                    if (getActivity() == null) {
+                        return;
+                    }
+
+                    final PendingIntent previous = makeTimerPendingIntent(PendingIntent.FLAG_NO_CREATE);
+                    if (previous != null) {
+                        AlarmManager am = (AlarmManager) getActivity().getSystemService(Context.ALARM_SERVICE);
+                        am.cancel(previous);
+                        previous.cancel();
+                        Toast.makeText(getActivity(), getActivity().getResources().getString(R.string.sleep_timer_canceled), Toast.LENGTH_SHORT).show();
+                    }
+
+                    MusicService musicService = MusicPlayerRemote.musicService;
+                    if (musicService != null && musicService.pendingQuit) {
+                        musicService.pendingQuit = false;
+                        Toast.makeText(getActivity(), getActivity().getResources().getString(R.string.sleep_timer_canceled), Toast.LENGTH_SHORT).show();
+                    }
+                })
+                .showListener(dialog -> {
+                    if (makeTimerPendingIntent(PendingIntent.FLAG_NO_CREATE) != null) {
+                        timerUpdater.start();
+                    }
+                })
+                .customView(R.layout.dialog_sleep_timer, false)
+                .build();
+
+        if (getActivity() == null || materialDialog.getCustomView() == null) {
+            return materialDialog;
+        }
+
+        ButterKnife.bind(this, materialDialog.getCustomView());
+
+        boolean finishMusic = PreferenceUtil.getInstance(getActivity()).getSleepTimerFinishMusic();
+        shouldFinishLastSong.setChecked(finishMusic);
+
+        seekArc.setProgressColor(ThemeSingleton.get().positiveColor.getDefaultColor());
+        seekArc.setThumbColor(ThemeSingleton.get().positiveColor.getDefaultColor());
+
+        seekArc.post(() -> {
+            int width = seekArc.getWidth();
+            int height = seekArc.getHeight();
+            int small = Math.min(width, height);
+
+            FrameLayout.LayoutParams layoutParams = new FrameLayout.LayoutParams(seekArc.getLayoutParams());
+            layoutParams.height = small;
+            seekArc.setLayoutParams(layoutParams);
+        });
+
+        seekArcProgress = PreferenceUtil.getInstance(getActivity()).getLastSleepTimerValue();
+        updateTimeDisplayTime();
+        seekArc.setProgress(seekArcProgress);
+
+        seekArc.setOnSeekArcChangeListener(new SeekArc.OnSeekArcChangeListener() {
+            @Override
+            public void onProgressChanged(@NonNull SeekArc seekArc, int i, boolean b) {
+                if (i < 1) {
+                    seekArc.setProgress(1);
+                    return;
+                }
+
+                seekArcProgress = i;
+                updateTimeDisplayTime();
+            }
+
+            @Override
+            public void onStartTrackingTouch(SeekArc seekArc) {
+            }
+
+            @Override
+            public void onStopTrackingTouch(SeekArc seekArc) {
+                PreferenceUtil.getInstance(getActivity()).setLastSleepTimerValue(seekArcProgress);
+            }
+        });
+
+        return materialDialog;
+    }
+
+    private void updateTimeDisplayTime() {
+        timerDisplay.setText(seekArcProgress + " min");
+    }
+
+    private PendingIntent makeTimerPendingIntent(int flag) {
+        return PendingIntent.getService(getActivity(), 0, makeTimerIntent(), flag);
+    }
+
+    private Intent makeTimerIntent() {
+        Intent intent = new Intent(getActivity(), MusicService.class);
+        if (shouldFinishLastSong.isChecked()) {
+            return intent.setAction(MusicService.ACTION_PENDING_QUIT);
+        }
+
+        return intent.setAction(MusicService.ACTION_QUIT);
+    }
+
+    private void updateCancelButton() {
+        MusicService musicService = MusicPlayerRemote.musicService;
+        if (musicService != null && musicService.pendingQuit) {
+            materialDialog.setActionButton(DialogAction.NEUTRAL, materialDialog.getContext().getString(R.string.cancel_current_timer));
+        } else {
+            materialDialog.setActionButton(DialogAction.NEUTRAL, null);
+        }
+    }
+
+    private class TimerUpdater extends CountDownTimer {
+        public TimerUpdater() {
+            super(PreferenceUtil.getInstance(getActivity()).getNextSleepTimerElapsedRealTime() - SystemClock.elapsedRealtime(), 1000);
+        }
+
+        @Override
+        public void onTick(long millisUntilFinished) {
+            materialDialog.setActionButton(DialogAction.NEUTRAL, materialDialog.getContext().getString(R.string.cancel_current_timer) + " (" + MusicUtil.getReadableDurationString(millisUntilFinished) + ")");
+        }
+
+        @Override
+        public void onFinish() {
+            updateCancelButton();
+        }
+    }
+}

app/src/main/java/com/dkanada/gramophone/dialogs/SongDetailDialog.java

@@ -0,0 +1,75 @@
+package com.dkanada.gramophone.dialogs;
+
+import android.app.Activity;
+import android.app.Dialog;
+import android.content.Context;
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+import androidx.fragment.app.DialogFragment;
+import android.text.Html;
+import android.text.Spanned;
+import android.view.View;
+import android.widget.TextView;
+
+import com.afollestad.materialdialogs.MaterialDialog;
+import com.dkanada.gramophone.R;
+import com.dkanada.gramophone.model.Song;
+import com.dkanada.gramophone.util.MusicUtil;
+
+public class SongDetailDialog extends DialogFragment {
+    @NonNull
+    public static SongDetailDialog create(Song song) {
+        SongDetailDialog dialog = new SongDetailDialog();
+        Bundle args = new Bundle();
+        args.putParcelable("song", song);
+        dialog.setArguments(args);
+        return dialog;
+    }
+
+    private static Spanned makeTextWithTitle(@NonNull Context context, int titleResId, String text) {
+        return Html.fromHtml("<b>" + context.getResources().getString(titleResId) + ": " + "</b>" + text);
+    }
+
+    private static String getFileSizeString(long sizeInBytes) {
+        long fileSizeInKB = sizeInBytes / 1024;
+        long fileSizeInMB = fileSizeInKB / 1024;
+        return fileSizeInMB + " MB";
+    }
+
+    @NonNull
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        final Activity context = getActivity();
+        final Song song = getArguments().getParcelable("song");
+
+        MaterialDialog dialog = new MaterialDialog.Builder(context)
+                .customView(R.layout.dialog_file_details, true)
+                .title(context.getResources().getString(R.string.label_details))
+                .positiveText(android.R.string.ok)
+                .build();
+
+        View dialogView = dialog.getCustomView();
+        final TextView fileName = dialogView.findViewById(R.id.file_name);
+        final TextView filePath = dialogView.findViewById(R.id.file_path);
+        final TextView fileSize = dialogView.findViewById(R.id.file_size);
+        final TextView fileFormat = dialogView.findViewById(R.id.file_format);
+        final TextView trackLength = dialogView.findViewById(R.id.track_length);
+        final TextView bitRate = dialogView.findViewById(R.id.bitrate);
+        final TextView samplingRate = dialogView.findViewById(R.id.sampling_rate);
+
+        fileName.setText(makeTextWithTitle(context, R.string.label_file_name, "-"));
+        filePath.setText(makeTextWithTitle(context, R.string.label_file_path, "-"));
+        fileSize.setText(makeTextWithTitle(context, R.string.label_file_size, "-"));
+        fileFormat.setText(makeTextWithTitle(context, R.string.label_file_format, "-"));
+        trackLength.setText(makeTextWithTitle(context, R.string.label_track_length, "-"));
+        bitRate.setText(makeTextWithTitle(context, R.string.label_bit_rate, "-"));
+        samplingRate.setText(makeTextWithTitle(context, R.string.label_sampling_rate, "-"));
+
+        if (song != null) {
+            fileName.setText(makeTextWithTitle(context, R.string.label_file_name, song.title));
+            trackLength.setText(makeTextWithTitle(context, R.string.label_track_length, MusicUtil.getReadableDurationString(song.duration)));
+        }
+
+        return dialog;
+    }
+}

app/src/main/java/com/dkanada/gramophone/dialogs/SongShareDialog.java

@@ -0,0 +1,53 @@
+package com.dkanada.gramophone.dialogs;
+
+import android.app.Dialog;
+import android.content.Intent;
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.fragment.app.DialogFragment;
+
+import com.afollestad.materialdialogs.MaterialDialog;
+import com.dkanada.gramophone.R;
+import com.dkanada.gramophone.model.Song;
+import com.dkanada.gramophone.util.MusicUtil;
+
+public class SongShareDialog extends DialogFragment {
+    @NonNull
+    public static SongShareDialog create(final Song song) {
+        final SongShareDialog dialog = new SongShareDialog();
+        final Bundle args = new Bundle();
+        args.putParcelable("song", song);
+        dialog.setArguments(args);
+        return dialog;
+    }
+
+    @NonNull
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        final Song song = getArguments().getParcelable("song");
+        final String currentlyListening = getString(R.string.currently_listening_to_x_by_x, song.title, song.artistName);
+        return new MaterialDialog.Builder(getActivity())
+                .title(R.string.what_do_you_want_to_share)
+                .items(getString(R.string.the_audio_file), "\u201C" + currentlyListening + "\u201D")
+                .itemsCallback((materialDialog, view, i, charSequence) -> {
+                    switch (i) {
+                        case 0:
+                            startActivity(Intent.createChooser(MusicUtil.createShareSongFileIntent(song, getContext()), null));
+                            break;
+                        case 1:
+                            getActivity().startActivity(
+                                    Intent.createChooser(
+                                            new Intent()
+                                                    .setAction(Intent.ACTION_SEND)
+                                                    .putExtra(Intent.EXTRA_TEXT, currentlyListening)
+                                                    .setType("text/plain"),
+                                            null
+                                    )
+                            );
+                            break;
+                    }
+                })
+                .build();
+    }
+}