shakebug-react-native 1.0.14

package/android/src/main/java/com/shakebug/widgets/VideoPlayerView.java

@@ -0,0 +1,429 @@
+package com.shakebug.widgets;
+
+import static com.shakebug.utils.VideoTrimmerUtil.RECYCLER_VIEW_PADDING;
+import static com.shakebug.utils.VideoTrimmerUtil.VIDEO_FRAMES_WIDTH;
+
+import android.animation.ValueAnimator;
+import android.content.Context;
+import android.content.pm.ActivityInfo;
+import android.content.res.Configuration;
+import android.graphics.Bitmap;
+import android.media.MediaMetadataRetriever;
+import android.media.MediaPlayer;
+import android.net.Uri;
+import android.os.Handler;
+import android.util.AttributeSet;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.Window;
+import android.view.WindowManager;
+import android.view.animation.LinearInterpolator;
+import android.widget.FrameLayout;
+import android.widget.ImageView;
+import android.widget.MediaController;
+import android.widget.RelativeLayout;
+import android.widget.SeekBar;
+import android.widget.SeekBar.OnSeekBarChangeListener;
+import android.widget.TextView;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableMap;
+import com.shakebug.DeviceUtil;
+import com.shakebug.R;
+import com.shakebug.adapters.VideoTrimmerAdapter;
+import com.shakebug.interfaces.IVideoTrimmerView;
+import com.shakebug.interfaces.VideoPlayerListner;
+import com.shakebug.thread.BackgroundExecutor;
+import com.shakebug.thread.UiThreadExecutor;
+import com.shakebug.utils.VideoTrimmerUtil;
+
+import java.util.Locale;
+import java.util.concurrent.TimeUnit;
+/**
+ * Author：Kenil
+ * Date：  2024.08.01 2:23 PM
+ * Email： who_know_me@163.com
+ * Describe:
+ */
+public class VideoPlayerView extends FrameLayout implements IVideoTrimmerView {
+
+    private static final String TAG = VideoPlayerView.class.getSimpleName();
+
+    private int mMaxWidth = VIDEO_FRAMES_WIDTH;
+    private ReactApplicationContext mContext;
+    private RelativeLayout mLinearVideo;
+    private ImageView mPlayView;
+    private ZVideoView mVideoView;
+//    private ImageView mPlayView;
+    private ImageView mRedProgressIcon;
+    private float mAverageMsPx;//每毫秒所占的px
+    private float averagePxMs;//每px所占用的ms毫秒
+    private Uri mSourceUri;
+    private VideoPlayerListner mOnTrimVideoListener;
+    private int mDuration = 0;
+    private VideoTrimmerAdapter mVideoThumbAdapter;
+    private boolean isFromRestore = false;
+    //new
+    private long mLeftProgressPos, mRightProgressPos;
+    private long mRedProgressBarPos = 0;
+    private long scrollPos = 0;
+    private int mScaledTouchSlop;
+    private int lastScrollX;
+    private boolean isSeeking;
+    private boolean isOverScaledTouchSlop;
+    private int mThumbsTotalCount;
+    private ValueAnimator mRedProgressAnimator;
+    private Handler mAnimationHandler = new Handler();
+    private Boolean mIsPrepared = false;
+    private int mMaxDuration = 0;
+
+    private MediaController mMediaController;
+
+    private SeekBar mSeekBar;
+
+    public VideoPlayerView(ReactApplicationContext context, AttributeSet attrs) {
+        this(context, attrs, 0, null);
+    }
+    public VideoPlayerView(ReactApplicationContext context, ReadableMap config, AttributeSet attrs) {
+        this(context, attrs, 0, config);
+    }
+
+    public VideoPlayerView(ReactApplicationContext context, AttributeSet attrs, int defStyleAttr, ReadableMap config) {
+        super(context, attrs, defStyleAttr);
+        init(context, config);
+    }
+
+    private void init(ReactApplicationContext context, ReadableMap config) {
+        this.mContext = context;
+
+        // listen to onConfigurationChanged doesn't work for this, it runs too soon
+        context.getCurrentActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
+        LayoutInflater.from(context).inflate(R.layout.video_player_view, this, true);
+
+        mLinearVideo = findViewById(R.id.layout_surface_view);
+        mVideoView = findViewById(R.id.video_loader);
+        mPlayView = findViewById(R.id.icon_video_play);
+        mSeekBar = findViewById(R.id.videoSeekBar);
+        mMediaController = new MediaController(context);
+        mVideoThumbAdapter = new VideoTrimmerAdapter(mContext);
+
+        configure(config);
+        setUpListeners();
+        setUpSeekBar();
+//
+//        setStatusBarColorBlack(context);
+    }
+
+
+    private void setStatusBarColorBlack(ReactApplicationContext context) {
+        Window window = context.getCurrentActivity().getWindow();
+        if (window != null) {
+            window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
+            window.setStatusBarColor(context.getResources().getColor(android.R.color.black)); // or any other color you prefer
+        }
+    }
+
+    public void initVideoByURI(final Uri videoURI) {
+        mSourceUri = videoURI;
+        mVideoView.setVideoURI(videoURI);
+        mVideoView.requestFocus();
+    }
+
+         private void setUpListeners() {
+         mVideoView.setOnPreparedListener(mp -> {
+             if (mIsPrepared) return;
+             mIsPrepared = true;
+             mDuration = mVideoView.getDuration();
+             mSeekBar.setMax(mDuration);
+             mMediaController.setMediaPlayer(mVideoView);
+             mMediaController.setAnchorView(mLinearVideo);
+             mMediaController.setEnabled(true);
+             setPlayPauseViewIcon(true);
+             mVideoView.start(); // Autoplay video
+             mAnimationHandler.post(mUpdateSeekBarTask);
+             updateDurationText(mDuration);
+         });
+
+         mVideoView.setOnCompletionListener(mp -> {
+             mVideoView.seekTo((int) mLeftProgressPos);
+             mSeekBar.setProgress(mSeekBar.getMax());
+             setPlayPauseViewIcon(false);
+         });
+
+         findViewById(R.id.cancelBtn).setOnClickListener(view -> {
+             mOnTrimVideoListener.onCancel();
+         });
+
+         mPlayView.setOnClickListener(view -> {
+             playVideoOrPause();
+         });
+     }
+
+
+    private void setUpSeekBar() {
+        mSeekBar.setOnSeekBarChangeListener(new OnSeekBarChangeListener() {
+            public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
+                if (fromUser) {
+                    // This part remains the same as your current implementation
+                    mVideoView.seekTo(progress);
+                    updateCurrentDurationText(progress);
+                }
+            }
+
+            public void onStartTrackingTouch(SeekBar seekBar) {
+                // Optional: Implement what happens when user starts touching the seek bar
+            }
+
+            public void onStopTrackingTouch(SeekBar seekBar) {
+                // Handle seek bar release point behavior here
+                if (mVideoView.isPlaying()) {
+                    mVideoView.pause();
+                    mAnimationHandler.removeCallbacks(mUpdateSeekBarTask);
+                    // Resume playing from the release point
+                    mVideoView.start();
+                    mAnimationHandler.post(mUpdateSeekBarTask);
+                }
+            }
+        });
+    }
+
+    private Runnable mUpdateSeekBarTask = new Runnable() {
+        public void run() {
+            if (mVideoView.isPlaying()) {
+                mSeekBar.setProgress(mVideoView.getCurrentPosition());
+                updateCurrentDurationText(mVideoView.getCurrentPosition());
+                mAnimationHandler.postDelayed(this, 100);  // Update every 100 milliseconds
+            }
+        }
+    };
+    private void startShootVideoThumbs(final Context context, final Uri videoUri, int totalThumbsCount, long startPosition, long endPosition) {
+        VideoTrimmerUtil.shootVideoThumbInBackground(context, videoUri, totalThumbsCount, startPosition, endPosition,
+                (bitmap, interval) -> {
+                    if (bitmap != null) {
+                        UiThreadExecutor.runTask("", () -> mVideoThumbAdapter.addBitmaps(bitmap), 0L);
+                    }
+                });
+    }
+
+    public static String formatTime(long duration) {
+        long hours = TimeUnit.MILLISECONDS.toHours(duration);
+        long minutes = TimeUnit.MILLISECONDS.toMinutes(duration) % 60;
+        long seconds = TimeUnit.MILLISECONDS.toSeconds(duration) % 60;
+        return String.format(Locale.getDefault(), "%02d:%02d:%02d", hours, minutes, seconds);
+    }
+
+    private void updateDurationText(long duration) {
+        String durationFormatted = formatTime(duration);
+        TextView textViewDuration = findViewById(R.id.textViewDuration);
+        textViewDuration.setText(durationFormatted);
+    }
+
+    private void updateCurrentDurationText(int progress) {
+        String currentDurationFormatted = formatTime(progress);
+        TextView textViewCurrentDuration = findViewById(R.id.textViewCurrentTime);
+        textViewCurrentDuration.setText(currentDurationFormatted);
+    }
+    private void videoPrepared(MediaPlayer mp) {
+        ViewGroup.LayoutParams lp = mVideoView.getLayoutParams();
+        int videoWidth = mp.getVideoWidth();
+        int videoHeight = mp.getVideoHeight();
+
+        float videoProportion = (float) videoWidth / (float) videoHeight;
+        int screenWidth = mLinearVideo.getWidth();
+        int screenHeight = mLinearVideo.getHeight();
+
+        if (videoHeight > videoWidth) {
+            lp.width = screenWidth;
+            lp.height = screenHeight;
+        } else {
+            lp.width = screenWidth;
+            float r = videoHeight / (float) videoWidth;
+            lp.height = (int) (lp.width * r);
+        }
+        mVideoView.setLayoutParams(lp);
+        mDuration = mVideoView.getDuration();
+
+        VideoTrimmerUtil.maxShootDuration = mMaxDuration > 0 ? Math.min(mMaxDuration * 1000L, mDuration) : mDuration;
+
+        MediaMetadataRetriever mediaMetadataRetriever = new MediaMetadataRetriever();
+        mediaMetadataRetriever.setDataSource(mContext, mSourceUri);
+        // take first frame
+        Bitmap bitmap = mediaMetadataRetriever.getFrameAtTime(0, MediaMetadataRetriever.OPTION_CLOSEST_SYNC);
+        int width = VideoTrimmerUtil.THUMB_HEIGHT * bitmap.getWidth() / bitmap.getHeight();
+        VideoTrimmerUtil.mThumbWidth = width;
+
+        if (!getRestoreState()) {
+            seekTo((int) mRedProgressBarPos);
+        } else {
+            setRestoreState(false);
+            seekTo((int) mRedProgressBarPos);
+        }
+        startShootVideoThumbs(mContext, mSourceUri, mThumbsTotalCount, 0, mDuration);
+    }
+
+    private void videoCompleted() {
+        seekTo(mLeftProgressPos);
+        setPlayPauseViewIcon(false);
+    }
+
+    private void onVideoReset() {
+        mVideoView.pause();
+        setPlayPauseViewIcon(false);
+    }
+
+    private void playVideoOrPause() {
+//        mRedProgressBarPos = mVideoView.getCurrentPosition();
+        if (mVideoView.isPlaying()) {
+            mVideoView.pause();
+            mAnimationHandler.removeCallbacks(mUpdateSeekBarTask);
+//            pauseRedProgressAnimation();
+        } else {
+            mVideoView.start();
+            mAnimationHandler.post(mUpdateSeekBarTask);
+//            playingRedProgressAnimation();
+        }
+        setPlayPauseViewIcon(mVideoView.isPlaying());
+    }
+
+    public void onVideoPause() {
+        if (mVideoView.isPlaying()) {
+            seekTo(mLeftProgressPos);//复位
+            mVideoView.pause();
+            setPlayPauseViewIcon(false);
+//            mRedProgressIcon.setVisibility(GONE);
+        }
+    }
+
+    public void setOnTrimVideoListener(VideoPlayerListner onTrimVideoListener) {
+        mOnTrimVideoListener = onTrimVideoListener;
+    }
+
+//    private void setUpListeners() {
+//
+//        mVideoView.setOnPreparedListener(mp -> {
+//            if (mIsPrepared) return;
+//            mIsPrepared = true;
+//            mDuration = mVideoView.getDuration();
+//            mMediaController.setMediaPlayer(mVideoView);
+//            mMediaController.setAnchorView(mLinearVideo);
+//            mMediaController.setEnabled(true);
+////            mVideoView.start(); // Autoplay video
+//        });
+//
+//        mVideoView.setOnCompletionListener(mp -> {
+//            mVideoView.seekTo((int) mLeftProgressPos);
+//        });
+//
+//        findViewById(R.id.cancelBtn).setOnClickListener(view -> {
+//            mOnTrimVideoListener.onCancel();
+//        });
+//
+//         mPlayView.setOnClickListener(view -> {
+//             playVideoOrPause();
+//         });
+//    }
+
+    private void seekTo(long msec) {
+        mVideoView.seekTo((int) msec);
+    }
+
+    private boolean getRestoreState() {
+        return isFromRestore;
+    }
+
+    public void setRestoreState(boolean fromRestore) {
+        isFromRestore = fromRestore;
+    }
+
+    private void setPlayPauseViewIcon(boolean isPlaying) {
+        mPlayView.setImageResource(isPlaying ? R.drawable.ic_video_pause_black : R.drawable.ic_video_play_black);
+    }
+
+    private void playingRedProgressAnimation() {
+        pauseRedProgressAnimation();
+//        playingAnimation();
+        mAnimationHandler.post(mAnimationRunnable);
+    }
+
+    private void playingAnimation() {
+        if (mRedProgressIcon.getVisibility() == View.GONE) {
+            mRedProgressIcon.setVisibility(View.VISIBLE);
+        }
+        final LayoutParams params = (LayoutParams) mRedProgressIcon.getLayoutParams();
+        int start = (int) (RECYCLER_VIEW_PADDING + (mRedProgressBarPos - scrollPos) * averagePxMs);
+        int end = (int) (RECYCLER_VIEW_PADDING + (mRightProgressPos - scrollPos) * averagePxMs);
+        mRedProgressAnimator = ValueAnimator.ofInt(start, end).setDuration((mRightProgressPos - scrollPos) - (mRedProgressBarPos - scrollPos));
+        mRedProgressAnimator.setInterpolator(new LinearInterpolator());
+        mRedProgressAnimator.addUpdateListener(animation -> {
+            params.leftMargin = (int) animation.getAnimatedValue();
+            mRedProgressIcon.setLayoutParams(params);
+        });
+        mRedProgressAnimator.start();
+    }
+
+    private void pauseRedProgressAnimation() {
+//        mRedProgressIcon.clearAnimation();
+        if (mRedProgressAnimator != null && mRedProgressAnimator.isRunning()) {
+            mAnimationHandler.removeCallbacks(mAnimationRunnable);
+            mRedProgressAnimator.cancel();
+        }
+    }
+
+    private Runnable mAnimationRunnable = () -> updateVideoProgress();
+
+    private void updateVideoProgress() {
+        long currentPosition = mVideoView.getCurrentPosition();
+        if (currentPosition >= mRightProgressPos) {
+            mRedProgressBarPos = mLeftProgressPos;
+            pauseRedProgressAnimation();
+            onVideoPause();
+            // Set SeekBar progress to max when video ends
+            mSeekBar.setProgress(mSeekBar.getMax());
+        } else {
+            mAnimationHandler.post(mAnimationRunnable);
+        }
+    }
+
+    @Override
+    protected void onDetachedFromWindow() {
+        super.onDetachedFromWindow();
+        mContext.getCurrentActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
+    }
+
+    /**
+     * Cancel trim thread execute action when finish
+     */
+    @Override public void onDestroy() {
+        BackgroundExecutor.cancelAll("", true);
+        UiThreadExecutor.cancelAll("");
+        mContext.getCurrentActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
+    }
+
+    private int getScreenWidthInPortraitMode() {
+        int screenWidth = DeviceUtil.getDeviceWidth();
+        int screenHeight = DeviceUtil.getDeviceHeight();
+
+        // Check the current orientation
+        int currentOrientation = getResources().getConfiguration().orientation;
+
+        // Swap width and height if the current orientation is landscape
+        if (currentOrientation == Configuration.ORIENTATION_LANDSCAPE) {
+            return screenHeight;
+        }
+
+        return screenWidth;
+    }
+
+    private void configure(ReadableMap config) {
+        if (config.hasKey("maxDuration")) {
+            this.mMaxDuration = config.getInt("maxDuration");
+        }
+
+        if (config.hasKey("cancelButtonText")) {
+            ImageView tv = findViewById(R.id.cancelBtn);
+//            tv.setText(config.getString("cancelButtonText"));
+        }
+
+    }
+}