shakebug-react-native 2.4.9 → 2.4.11

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

@@ -0,0 +1,317 @@
+package com.shakebug.widgets;
+
+import android.content.Context;
+import android.content.pm.ActivityInfo;
+import android.media.MediaPlayer;
+import android.net.Uri;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.AttributeSet;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+import android.widget.ImageView;
+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.R;
+import com.shakebug.interfaces.VideoPlayerListner;
+
+import java.util.Locale;
+import java.util.concurrent.TimeUnit;
+
+public class VideoPlayerView extends FrameLayout {
+
+    private static final String TAG = VideoPlayerView.class.getSimpleName();
+
+    private Context mContext;
+    private RelativeLayout mLinearVideo;
+    private ZVideoView mVideoView;
+    private ImageView mPlayView;
+    private SeekBar mSeekBar;
+    private TextView mTvCurrentTime;
+    private TextView mTvDuration;
+    private ImageView mCancelBtn;
+    private ImageView mMuteBtn;
+    private MediaPlayer mMediaPlayer;
+    private boolean mIsMuted = false;
+
+    private Uri mSourceUri;
+    private VideoPlayerListner mOnVideoPlayerListener;
+    private int mDuration = 0;
+    private boolean mIsPrepared = false;
+    private final Handler mAnimationHandler = new Handler(Looper.getMainLooper());
+
+    public VideoPlayerView(Context context) {
+        super(context);
+        init(context, null);
+    }
+
+    public VideoPlayerView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init(context, null);
+    }
+
+    public VideoPlayerView(Context context, ReadableMap config, AttributeSet attrs) {
+        super(context, attrs);
+        init(context, config);
+    }
+
+    private void init(Context context, ReadableMap config) {
+        this.mContext = context;
+
+        LayoutInflater.from(context).inflate(R.layout.shakebug_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);
+        mTvCurrentTime = findViewById(R.id.textViewCurrentTime);
+        mTvDuration = findViewById(R.id.textViewDuration);
+        mCancelBtn = findViewById(R.id.cancelBtn);
+        mMuteBtn = findViewById(R.id.muteBtn);
+
+        setUpListeners();
+        setUpSeekBar();
+    }
+
+    public void initVideoByURI(final Uri videoURI) {
+        this.mSourceUri = videoURI;
+        mIsPrepared = false;
+        try {
+            mVideoView.setVideoURI(videoURI);
+            mVideoView.requestFocus();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void setUpListeners() {
+        mVideoView.setOnPreparedListener(mp -> {
+            try {
+                mMediaPlayer = mp;
+                mIsPrepared = true;
+                mDuration = mVideoView.getDuration();
+                if (mDuration > 0) {
+                    mSeekBar.setMax(mDuration);
+                    updateDurationText(mDuration);
+                }
+                
+                if (mIsMuted) {
+                    mMediaPlayer.setVolume(0f, 0f);
+                } else {
+                    mMediaPlayer.setVolume(1f, 1f);
+                }
+
+                // Adjust aspect ratio
+                adjustVideoAspectRatio(mp);
+
+                setPlayPauseViewIcon(true);
+                mVideoView.start();
+                mAnimationHandler.post(mUpdateSeekBarTask);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        });
+
+        mVideoView.setOnCompletionListener(mp -> {
+            try {
+                mVideoView.seekTo(0);
+                mSeekBar.setProgress(0);
+                updateCurrentDurationText(0);
+                setPlayPauseViewIcon(false);
+                mAnimationHandler.removeCallbacks(mUpdateSeekBarTask);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        });
+
+        mVideoView.setOnErrorListener((mp, what, extra) -> {
+            setPlayPauseViewIcon(false);
+            return true;
+        });
+
+        if (mCancelBtn != null) {
+            mCancelBtn.setOnClickListener(view -> {
+                onVideoPause();
+                if (mOnVideoPlayerListener != null) {
+                    mOnVideoPlayerListener.onCancel();
+                }
+            });
+        }
+
+        if (mMuteBtn != null) {
+            mMuteBtn.setOnClickListener(view -> {
+                mIsMuted = !mIsMuted;
+                if (mMediaPlayer != null) {
+                    if (mIsMuted) {
+                        mMediaPlayer.setVolume(0f, 0f);
+                        mMuteBtn.setImageResource(R.drawable.ic_volume_off);
+                    } else {
+                        mMediaPlayer.setVolume(1f, 1f);
+                        mMuteBtn.setImageResource(R.drawable.ic_volume_on);
+                    }
+                }
+            });
+        }
+
+        if (mPlayView != null) {
+            mPlayView.setOnClickListener(view -> playVideoOrPause());
+        }
+    }
+
+    private void adjustVideoAspectRatio(MediaPlayer mp) {
+        try {
+            int videoWidth = mp.getVideoWidth();
+            int videoHeight = mp.getVideoHeight();
+            if (videoWidth == 0 || videoHeight == 0) return;
+
+            int containerWidth = mLinearVideo.getWidth();
+            int containerHeight = mLinearVideo.getHeight();
+            if (containerWidth == 0 || containerHeight == 0) return;
+
+            ViewGroup.LayoutParams lp = mVideoView.getLayoutParams();
+            float videoAspect = (float) videoWidth / (float) videoHeight;
+            float containerAspect = (float) containerWidth / (float) containerHeight;
+
+            if (videoAspect > containerAspect) {
+                lp.width = containerWidth;
+                lp.height = (int) (containerWidth / videoAspect);
+            } else {
+                lp.height = containerHeight;
+                lp.width = (int) (containerHeight * videoAspect);
+            }
+            mVideoView.setLayoutParams(lp);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void setUpSeekBar() {
+        if (mSeekBar == null) return;
+        mSeekBar.setOnSeekBarChangeListener(new OnSeekBarChangeListener() {
+            @Override
+            public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
+                if (fromUser && mIsPrepared) {
+                    try {
+                        // Only update UI text while dragging, don't overwhelm MediaPlayer with seekTo
+                        updateCurrentDurationText(progress);
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+
+            @Override
+            public void onStartTrackingTouch(SeekBar seekBar) {
+                if (mIsPrepared) {
+                    mVideoView.pause();
+                    mAnimationHandler.removeCallbacks(mUpdateSeekBarTask);
+                    setPlayPauseViewIcon(false);
+                }
+            }
+
+            @Override
+            public void onStopTrackingTouch(SeekBar seekBar) {
+                if (mIsPrepared) {
+                    // Perform the actual seek only when the user releases the thumb
+                    mVideoView.seekTo(seekBar.getProgress());
+                    // Force start playing from the new position
+                    mVideoView.start();
+                    mAnimationHandler.post(mUpdateSeekBarTask);
+                    setPlayPauseViewIcon(true);
+                }
+            }
+        });
+    }
+
+    private final Runnable mUpdateSeekBarTask = new Runnable() {
+        @Override
+        public void run() {
+            try {
+                if (mVideoView != null && mVideoView.isPlaying()) {
+                    int currentPos = mVideoView.getCurrentPosition();
+                    if (mSeekBar != null) {
+                        mSeekBar.setProgress(currentPos);
+                    }
+                    updateCurrentDurationText(currentPos);
+                    mAnimationHandler.postDelayed(this, 100);
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    };
+
+    private void playVideoOrPause() {
+        try {
+            if (mVideoView.isPlaying()) {
+                mVideoView.pause();
+                mAnimationHandler.removeCallbacks(mUpdateSeekBarTask);
+                setPlayPauseViewIcon(false);
+            } else {
+                mVideoView.start();
+                mAnimationHandler.post(mUpdateSeekBarTask);
+                setPlayPauseViewIcon(true);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void onVideoPause() {
+        try {
+            if (mVideoView != null && mVideoView.isPlaying()) {
+                mVideoView.pause();
+                setPlayPauseViewIcon(false);
+                mAnimationHandler.removeCallbacks(mUpdateSeekBarTask);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void setPlayPauseViewIcon(boolean isPlaying) {
+        if (mPlayView != null) {
+            mPlayView.setImageResource(isPlaying ? R.drawable.ic_video_pause_black : R.drawable.ic_video_play_black);
+        }
+    }
+
+    public static String formatTime(long durationMs) {
+        long minutes = TimeUnit.MILLISECONDS.toMinutes(durationMs) % 60;
+        long seconds = TimeUnit.MILLISECONDS.toSeconds(durationMs) % 60;
+        return String.format(Locale.getDefault(), "%02d:%02d", minutes, seconds);
+    }
+
+    private void updateDurationText(long duration) {
+        if (mTvDuration != null) {
+            mTvDuration.setText(formatTime(duration));
+        }
+    }
+
+    private void updateCurrentDurationText(int progress) {
+        if (mTvCurrentTime != null) {
+            mTvCurrentTime.setText(formatTime(progress));
+        }
+    }
+
+    public void setOnTrimVideoListener(VideoPlayerListner onVideoPlayerListener) {
+        this.mOnVideoPlayerListener = onVideoPlayerListener;
+    }
+
+    public void onDestroy() {
+        try {
+            mAnimationHandler.removeCallbacks(mUpdateSeekBarTask);
+            if (mVideoView != null) {
+                mVideoView.stopPlayback();
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}