Add playback speed function and UI

app/src/main/java/com/tubitv/media/demo/di/FSMModuleReal.java

@@ -23,6 +23,8 @@
 import com.tubitv.media.models.CuePointsRetriever;
 import com.tubitv.media.models.MediaModel;
 import com.tubitv.media.models.VpaidClient;
+import com.tubitv.media.utilities.PlaybackSettingMenu;
+
 import dagger.Module;
 import dagger.Provides;
 import java.util.ArrayList;
@@ -206,4 +208,10 @@ public void run() {
     VpaidClient provideVpaidClient(FsmPlayer player) {
         return new TubiVPAID(webView, new Handler(Looper.getMainLooper()), player);
     }
+
+    @ActicityScope
+    @Provides
+    PlaybackSettingMenu providePlaybackSettingMenu() {
+        return new PlaybackSettingMenu();
+    }
 }

lib/src/main/java/com/tubitv/media/activities/DoubleViewTubiPlayerActivity.java

@@ -40,6 +40,7 @@
 import com.tubitv.media.models.MediaModel;
 import com.tubitv.media.models.VpaidClient;
 import com.tubitv.media.utilities.ExoPlayerLogger;
+import com.tubitv.media.utilities.PlaybackSettingMenu;
 import com.tubitv.media.utilities.PlayerDeviceUtils;
 import com.tubitv.media.utilities.Utils;
 import com.tubitv.media.views.UIControllerView;
@@ -71,6 +72,9 @@ public class DoubleViewTubiPlayerActivity extends TubiPlayerActivity implements
     PlayerAdLogicController playerComponentController;
     @Inject
     VpaidClient vpaidClient;
+    @Inject
+    PlaybackSettingMenu playbackSettingMenu;
+
     private DefaultTrackSelector trackSelector_ad;
 
     protected AdRetriever getAdRetriever() {
@@ -239,6 +243,10 @@ public void prepareFSM() {
         } else {
             fsmPlayer.transit(Input.INITIALIZE);
         }
+
+        playbackSettingMenu.setContentPlayer(mMoviePlayer);
+        playbackSettingMenu.setActivity(this);
+        playbackSettingMenu.buildSettingMenuOptions();
     }
 
     @Override
@@ -332,6 +340,11 @@ public void onPlayToggle(@Nullable MediaModel mediaModel, boolean playing) {
         //        ExoPlayerLogger.v(TAG, mediaModel.getMediaName() + ": " + mediaModel.toString() + " onPlayToggle :");
     }
 
+    @Override
+    public void onPlaybackSettingClick() {
+        playbackSettingMenu.show();
+    }
+
     @Override
     public void onLearnMoreClick(@NonNull MediaModel mediaModel) {
         //        ExoPlayerLogger.v(TAG, mediaModel.getMediaName() + ": " + mediaModel.toString() + " onLearnMoreClick :" + mediaModel.getClickThroughUrl());

lib/src/main/java/com/tubitv/media/bindings/UserController.java

@@ -332,6 +332,16 @@ public void clickCurrentAd() {
         mPlaybackActionCallback.onLearnMoreClick(mMediaModel);
     }
 
+    @Override
+    public void clickPlaybackSetting() {
+        if (mPlaybackActionCallback == null) {
+            ExoPlayerLogger.w(TAG, "clickPlaybackSetting params is null");
+            return;
+        }
+
+        mPlaybackActionCallback.onPlaybackSettingClick();
+    }
+
     @Override
     public String getCurrentVideoName() {
         return videoName.get();

lib/src/main/java/com/tubitv/media/di/PlayerModuleDefault.java

@@ -18,6 +18,8 @@
 import com.tubitv.media.models.CuePointsRetriever;
 import com.tubitv.media.models.MediaModel;
 import com.tubitv.media.models.VpaidClient;
+import com.tubitv.media.utilities.PlaybackSettingMenu;
+
 import dagger.Module;
 import dagger.Provides;
 import java.util.ArrayList;
@@ -160,4 +162,10 @@ public String getVastXml() {
             }
         };
     }
+
+    @ActicityScope
+    @Provides
+    PlaybackSettingMenu providePlaybackSettingMenu() {
+        return new PlaybackSettingMenu();
+    }
 }

lib/src/main/java/com/tubitv/media/interfaces/PlaybackActionCallback.java

@@ -20,6 +20,8 @@ public interface PlaybackActionCallback {
 
     void onLearnMoreClick(@NonNull MediaModel mediaModel);
 
+    void onPlaybackSettingClick();
+
     void onSubtitles(@Nullable MediaModel mediaModel, boolean enabled);
 
     void onQuality(@Nullable MediaModel mediaModel);

lib/src/main/java/com/tubitv/media/interfaces/TubiPlaybackControlInterface.java

@@ -16,6 +16,8 @@ public interface TubiPlaybackControlInterface {
 
     void clickCurrentAd();
 
+    void clickPlaybackSetting();
+
     //display control
     String getCurrentVideoName();
 

lib/src/main/java/com/tubitv/media/models/PlaybackSpeed.java

@@ -0,0 +1,69 @@
+package com.tubitv.media.models;
+
+import android.content.Context;
+import android.support.annotation.NonNull;
+
+import com.tubitv.media.R;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+/**
+ * Playback Speed in percent.
+ * e.g.
+ * 1.0f = normal speed
+ * 0.75f = three-quarter of normal speed
+ * 2.0f = double normal speed
+ */
+public enum PlaybackSpeed {
+
+    // Ordering here will effect ordering in UI
+    A_QUARTER(R.string.playback_speed_a_quarter, 0.25f),
+    A_HALF(R.string.playback_speed_a_half, 0.5f),
+    THREE_QUARTER(R.string.playback_speed_three_quarter, 0.75f),
+    NORMAL(R.string.playback_speed_normal, 1f),
+    ONE_AND_A_QUARTER(R.string.playback_speed_one_and_a_quarter, 1.25f),
+    ONE_AND_A_HALF(R.string.playback_speed_one_and_a_half, 1.5f),
+    ONE_AND_THREE_QUARTER(R.string.playback_speed_one_and_three_quarter, 1.75f),
+    TWO(R.string.playback_speed_two, 2f);
+
+    private static final float EPSILON = 0.01f;
+
+    private final int stringResourceId;
+    private final float speedValue;
+
+    PlaybackSpeed(int stringResourceId, float speedValue) {
+        this.stringResourceId = stringResourceId;
+        this.speedValue = speedValue;
+    }
+
+    public int getStringResourceId() {
+        return stringResourceId;
+    }
+
+    public String getText(Context context) {
+        return context.getString(stringResourceId);
+    }
+
+    public static PlaybackSpeed getPlaybackSpeedBySpeedValue(Float speedValue) {
+        for (PlaybackSpeed playbackSpeed : PlaybackSpeed.getAllPlaybackSpeedEnums()) {
+            if(Math.abs(playbackSpeed.speedValue - speedValue) < EPSILON) {
+                return playbackSpeed;
+            }
+        }
+        return null;
+    }
+
+    public static int getPlaybackSpeedPositionBySpeedValue(Float speedValue) {
+        PlaybackSpeed targetPlaybackSpeed = getPlaybackSpeedBySpeedValue(speedValue);
+        return getAllPlaybackSpeedEnums().indexOf(targetPlaybackSpeed);
+    }
+
+    public float getSpeedValue() {
+        return speedValue;
+    }
+
+    public static ArrayList<PlaybackSpeed> getAllPlaybackSpeedEnums() {
+        return new ArrayList<>(Arrays.asList(PlaybackSpeed.class.getEnumConstants()));
+    }
+}

lib/src/main/java/com/tubitv/media/utilities/PlaybackSettingMenu.java

@@ -0,0 +1,185 @@
+package com.tubitv.media.utilities;
+
+import android.content.DialogInterface;
+import android.support.annotation.NonNull;
+import android.support.v7.app.AlertDialog;
+import android.view.Gravity;
+import android.view.Window;
+import android.view.WindowManager;
+import com.google.android.exoplayer2.PlaybackParameters;
+import com.google.android.exoplayer2.SimpleExoPlayer;
+import com.tubitv.media.R;
+import com.tubitv.media.activities.TubiPlayerActivity;
+import com.tubitv.media.models.PlaybackSpeed;
+
+import java.util.ArrayList;
+
+/**
+ * A nested playback setting menu using AlertDialog.
+ */
+public class PlaybackSettingMenu {
+
+    private SimpleExoPlayer contentPlayer;
+
+    private TubiPlayerActivity activity;
+
+    private AlertDialog mainDialog;
+
+    private ArrayList<MenuOption> menuOptions;
+
+    public PlaybackSettingMenu() {
+    }
+
+    public PlaybackSettingMenu(@NonNull SimpleExoPlayer contentPlayer, @NonNull TubiPlayerActivity playerActivity) {
+        this.contentPlayer = contentPlayer;
+        this.activity = playerActivity;
+    }
+
+    public void setContentPlayer(@NonNull SimpleExoPlayer contentPlayer) {
+        this.contentPlayer = contentPlayer;
+    }
+
+    public void setActivity(@NonNull TubiPlayerActivity activity) {
+        this.activity = activity;
+    }
+
+    public void buildSettingMenuOptions() {
+        menuOptions = new ArrayList<>();
+
+        // Option can be separately injected from root activity if needed.
+        // It requires dependencies: activityContext & contentSimpleExoPlayer.
+        MenuOption playbackSpeedOption = new MenuOption(activity.getString(
+                R.string.playback_setting_speed_title), new MenuOptionCallback() {
+            @Override
+            public void onClick() {
+                ArrayList<String> playbackSpeedTexts = new ArrayList<>();
+                ArrayList<Float> playbackSpeedValues = new ArrayList<>();
+
+                for (PlaybackSpeed playbackSpeed : PlaybackSpeed.getAllPlaybackSpeedEnums()) {
+                    playbackSpeedTexts.add(playbackSpeed.getText(activity));
+                    playbackSpeedValues.add(playbackSpeed.getSpeedValue());
+                }
+
+                String[] speedOptionTextArray = playbackSpeedTexts.toArray(new String[0]);
+                int currentSpeedPosition = PlaybackSpeed.getPlaybackSpeedPositionBySpeedValue(
+                        contentPlayer.getPlaybackParameters().speed);
+
+                AlertDialog.Builder builder = new AlertDialog.Builder(activity);
+                builder.setSingleChoiceItems(
+                        speedOptionTextArray,
+                        currentSpeedPosition,   // When is -1, none will be selected.
+                        new DialogInterface.OnClickListener() {
+                            @Override
+                            public void onClick(DialogInterface dialog, int i) {
+                                PlaybackParameters originParameters = contentPlayer.getPlaybackParameters();
+                                PlaybackParameters updatedSpeedParameters = new PlaybackParameters(
+                                        playbackSpeedValues.get(i),
+                                        originParameters.pitch, // Keeping old values
+                                        originParameters.skipSilence
+                                );
+
+                                contentPlayer.setPlaybackParameters(updatedSpeedParameters);
+                                dialog.dismiss();
+                            }
+                        });
+
+                AlertDialog chooseSpeedDialog = builder.create();
+                setAlertDialogGravityBottomCenter(chooseSpeedDialog);
+                alertDialogImmersiveShow(chooseSpeedDialog);
+            }
+
+            @Override
+            public String getTitle(String defaultTitle) {
+                // Dynamic title
+                Float currentSpeedValue = contentPlayer.getPlaybackParameters().speed;
+                PlaybackSpeed currentPlaybackSpeed = PlaybackSpeed.getPlaybackSpeedBySpeedValue(currentSpeedValue);
+                if (currentPlaybackSpeed != null) {
+                    defaultTitle = defaultTitle + " - " + currentPlaybackSpeed.getText(activity);
+                }
+                return defaultTitle;
+            }
+        });
+
+        menuOptions.add(playbackSpeedOption);
+    }
+
+    public void show() {
+        AlertDialog.Builder builder = new AlertDialog.Builder(activity);
+        builder.setTitle(activity.getString(R.string.playback_setting_title));
+
+        String[] settingOptionTitles = new String[menuOptions.size()];
+        for (int i = 0; i < menuOptions.size(); i++) {
+            settingOptionTitles[i] = menuOptions.get(i).getTitle();
+        }
+
+        builder.setItems(settingOptionTitles, new DialogInterface.OnClickListener() {
+            @Override
+            public void onClick(DialogInterface dialog, int i) {
+                menuOptions.get(i).onClick();
+                dialog.dismiss();
+            }
+        });
+
+        mainDialog = builder.create();
+        setAlertDialogGravityBottomCenter(mainDialog);
+        alertDialogImmersiveShow(mainDialog);
+    }
+
+    public void dismiss() {
+        if (mainDialog != null) {
+            mainDialog.dismiss();
+        }
+    }
+
+    private void setAlertDialogGravityBottomCenter(AlertDialog alertDialog) {
+        alertDialog.requestWindowFeature(Window.FEATURE_NO_TITLE);
+        WindowManager.LayoutParams layoutParams = alertDialog.getWindow().getAttributes();
+        if (layoutParams != null) {
+            layoutParams.gravity = Gravity.BOTTOM | Gravity.CENTER;
+        }
+    }
+
+    /*
+     * This method is to keep the system navigation bar not appearing after dialog calling .show().
+     *
+     * More on this problem:
+     * https://stackoverflow.com/questions/22794049/how-do-i-maintain-the-immersive-mode-in-dialogs
+     */
+    private void alertDialogImmersiveShow(AlertDialog alertDialog) {
+        // Set dialog not-focusable, to avoid popping the nav bar.
+        alertDialog.getWindow().setFlags(
+                WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE,
+                WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE);
+
+        alertDialog.show();
+
+        // Copy the hosted activity systemUI setting.
+        alertDialog.getWindow().getDecorView().setSystemUiVisibility(
+                activity.getWindow().getDecorView().getSystemUiVisibility());
+        // Clear the not-focusable, which let the dialog re-gain focus.
+        alertDialog.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE);
+    }
+
+    interface MenuOptionCallback {
+        void onClick();
+        String getTitle(String defaultTitle);
+    }
+
+    class MenuOption {
+        private String title;
+        private MenuOptionCallback callback;
+
+        MenuOption(String title, MenuOptionCallback callback) {
+            this.title = title;
+            this.callback = callback;
+        }
+
+        void onClick() {
+            callback.onClick();
+        }
+
+        String getTitle() {
+            return callback.getTitle(title);
+        }
+    }
+}