shakebug-react-native 2.4.8 → 2.4.10

package/android/src/main/java/com/shakebug/VideoTrimModule.java

@@ -0,0 +1,387 @@
+package com.shakebug;
+
+import static com.facebook.react.bridge.UiThreadUtil.runOnUiThread;
+
+import android.app.Activity;
+import android.content.res.ColorStateList;
+import android.graphics.Color;
+import android.media.MediaMetadataRetriever;
+import android.net.Uri;
+import android.os.Build;
+import android.view.Gravity;
+import android.view.ViewGroup;
+import android.widget.LinearLayout;
+import android.widget.ProgressBar;
+import android.widget.TextView;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.appcompat.app.AlertDialog;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.LifecycleEventListener;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.shakebug.interfaces.VideoTrimListener;
+import com.shakebug.utils.StorageUtil;
+import com.shakebug.widgets.VideoTrimmerView;
+
+import java.io.IOException;
+
+@ReactModule(name = VideoTrimModule.NAME)
+public class VideoTrimModule extends ReactContextBaseJavaModule implements VideoTrimListener, LifecycleEventListener {
+  public static final String NAME = "ShakebugSDKVideoTrim";
+  private static Boolean isInit = false;
+  private VideoTrimmerView trimmerView;
+  private AlertDialog alertDialog;
+  private AlertDialog mProgressDialog;
+  private ProgressBar mProgressBar;
+  private int listenerCount = 0;
+
+  private Promise showEditorPromise;
+
+  private boolean enableCancelDialog = true;
+  private String cancelDialogTitle = "Warning!";
+  private String cancelDialogMessage = "Are you sure want to cancel?";
+  private String cancelDialogCancelText = "Close";
+  private String cancelDialogConfirmText = "Proceed";
+  private boolean enableSaveDialog = true;
+  private String saveDialogTitle = "Confirmation!";
+  private String saveDialogMessage = "Are you sure want to save?";
+  private String saveDialogCancelText = "Close";
+  private String saveDialogConfirmText  = "Proceed";
+  private String trimmingText = "Trimming video...";
+
+  public VideoTrimModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+    BaseUtils.init(reactContext);
+  }
+
+  @Override
+  @NonNull
+  public String getName() {
+    return NAME;
+  }
+
+  @ReactMethod
+  public void showEditor(String videoPath, ReadableMap config, Promise promise) {
+    showEditorPromise = promise;
+    if (trimmerView != null || alertDialog != null) {
+      return;
+    }
+
+    if (!isValidVideo(videoPath)) {
+      WritableMap map = Arguments.createMap();
+      map.putString("message", "File is not a valid video");
+      sendEvent(getReactApplicationContext(), "onError", map);
+      if (promise != null) {
+        promise.reject("INVALID_VIDEO", "File is not a valid video");
+      }
+      return;
+    }
+
+    enableCancelDialog = config.hasKey("enableCancelDialog") ? config.getBoolean("enableCancelDialog") : true;
+    cancelDialogTitle = config.hasKey("cancelDialogTitle") ? config.getString("cancelDialogTitle") : "Warning!";
+    cancelDialogMessage = config.hasKey("cancelDialogMessage") ? config.getString("cancelDialogMessage") : "Are you sure want to cancel?";
+    cancelDialogCancelText = config.hasKey("cancelDialogCancelText") ? config.getString("cancelDialogCancelText") : "Close";
+    cancelDialogConfirmText = config.hasKey("cancelDialogConfirmText") ? config.getString("cancelDialogConfirmText") : "Proceed";
+
+    enableSaveDialog = config.hasKey("enableSaveDialog") ? config.getBoolean("enableSaveDialog") : true;
+    saveDialogTitle = config.hasKey("saveDialogTitle") ? config.getString("saveDialogTitle") : "Confirmation!";
+    saveDialogMessage = config.hasKey("saveDialogMessage") ? config.getString("saveDialogMessage") : "Are you sure want to save?";
+    saveDialogCancelText = config.hasKey("saveDialogCancelText") ? config.getString("saveDialogCancelText") : "Close";
+    saveDialogConfirmText = config.hasKey("saveDialogConfirmText") ? config.getString("saveDialogConfirmText") : "Proceed";
+    trimmingText = config.hasKey("trimmingText") ? config.getString("trimmingText") : "Trimming video...";
+
+    BaseUtils.init(getReactApplicationContext());
+
+    runOnUiThread(() -> {
+      try {
+        Activity currentAct = getReactApplicationContext().getCurrentActivity();
+        if (currentAct == null || currentAct.isFinishing()) {
+          if (showEditorPromise != null) {
+            showEditorPromise.reject("NO_ACTIVITY", "Current activity is not available");
+            showEditorPromise = null;
+          }
+          return;
+        }
+
+        trimmerView = new VideoTrimmerView(currentAct, config, null);
+        trimmerView.setOnTrimVideoListener(this);
+
+        String cleanPath = videoPath.replace("file://", "");
+        Uri uri = cleanPath.startsWith("/") ? Uri.fromFile(new java.io.File(cleanPath)) : Uri.parse(videoPath);
+        trimmerView.initVideoByURI(uri);
+
+        AlertDialog.Builder builder = new AlertDialog.Builder(currentAct, android.R.style.Theme_Black_NoTitleBar_Fullscreen);
+        builder.setCancelable(false);
+        alertDialog = builder.create();
+        alertDialog.setView(trimmerView);
+        alertDialog.show();
+
+        alertDialog.setOnDismissListener(dialog -> {
+          if (trimmerView != null) {
+            trimmerView.onDestroy();
+            trimmerView = null;
+          }
+          hideDialog();
+          sendEvent(getReactApplicationContext(), "onHide", null);
+        });
+        sendEvent(getReactApplicationContext(), "onShow", null);
+      } catch (Exception e) {
+        e.printStackTrace();
+        onError(e.getMessage() != null ? e.getMessage() : "Error displaying video trimmer");
+      }
+    });
+  }
+
+  @Override
+  public void onHostResume() {
+
+  }
+
+  @Override
+  public void onHostPause() {
+    if (trimmerView != null) {
+      trimmerView.onVideoPause();
+      trimmerView.setRestoreState(true);
+    }
+  }
+
+  @Override
+  public void onHostDestroy() {
+    hideDialog();
+  }
+
+  @Override public void onStartTrim() {
+    sendEvent(getReactApplicationContext(), "onStartTrimming", null);
+    runOnUiThread(() -> {
+      buildDialog();
+    });
+  }
+
+  @Override public void onTrimmingProgress(int percentage) {
+    if (mProgressBar != null) {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+        mProgressBar.setProgress(percentage, true);
+      } else {
+        mProgressBar.setProgress(percentage);
+      }
+    }
+  }
+
+  @Override public void onFinishTrim(String in) {
+    runOnUiThread(() -> {
+      hideDialog();
+      WritableMap map = Arguments.createMap();
+      map.putString("outputPath", in);
+      sendEvent(getReactApplicationContext(), "onFinishTrimming", map);
+      if (showEditorPromise != null) {
+        showEditorPromise.resolve(in);
+        showEditorPromise = null;
+      }
+    });
+  }
+
+  @Override public void onError(String errorMessage) {
+    runOnUiThread(() -> {
+      this.hideDialog();
+      WritableMap map = Arguments.createMap();
+      map.putString("message", errorMessage);
+      sendEvent(getReactApplicationContext(), "onError", map);
+      if (showEditorPromise != null) {
+        showEditorPromise.reject("TRIM_ERROR", errorMessage);
+        showEditorPromise = null;
+      }
+    });
+  }
+
+  @Override public void onCancel() {
+    if (!enableCancelDialog) {
+      sendEvent(getReactApplicationContext(), "onCancel", null);
+      if (showEditorPromise != null) {
+        showEditorPromise.resolve(null);
+        showEditorPromise = null;
+      }
+      hideDialog();
+      return;
+    }
+
+    Activity activity = getReactApplicationContext().getCurrentActivity();
+    if (activity == null) return;
+    AlertDialog.Builder builder = new AlertDialog.Builder(activity);
+    builder.setMessage(cancelDialogMessage);
+    builder.setTitle(cancelDialogTitle);
+    builder.setCancelable(false);
+    builder.setPositiveButton(cancelDialogConfirmText, (dialog, which) -> {
+      dialog.cancel();
+      sendEvent(getReactApplicationContext(), "onCancel", null);
+      if (showEditorPromise != null) {
+        showEditorPromise.resolve(null);
+        showEditorPromise = null;
+      }
+      hideDialog();
+    });
+    builder.setNegativeButton(cancelDialogCancelText, (dialog, which) -> {
+      dialog.cancel();
+    });
+    AlertDialog d = builder.create();
+    d.show();
+  }
+
+  @Override public void onSave() {
+    if (!enableSaveDialog) {
+      if (trimmerView != null) trimmerView.onSaveClicked();
+      return;
+    }
+
+    Activity activity = getReactApplicationContext().getCurrentActivity();
+    if (activity == null) return;
+    AlertDialog.Builder builder = new AlertDialog.Builder(activity);
+    builder.setMessage(saveDialogMessage);
+    builder.setTitle(saveDialogTitle);
+    builder.setCancelable(false);
+    builder.setPositiveButton(saveDialogConfirmText, (dialog, which) -> {
+      dialog.cancel();
+      if (trimmerView != null) trimmerView.onSaveClicked();
+    });
+    builder.setNegativeButton(saveDialogCancelText, (dialog, which) -> {
+      dialog.cancel();
+    });
+    AlertDialog d = builder.create();
+    d.show();
+  }
+
+  @ReactMethod
+  public void hideDialog() {
+    if (mProgressDialog != null) {
+      if (mProgressDialog.isShowing()) mProgressDialog.dismiss();
+      mProgressBar = null;
+      mProgressDialog = null;
+    }
+
+    if (alertDialog != null) {
+      if (alertDialog.isShowing()) {
+        alertDialog.dismiss();
+      }
+      alertDialog = null;
+    }
+  }
+
+  private void buildDialog() {
+    Activity activity = getReactApplicationContext().getCurrentActivity();
+    if (activity == null) return;
+    LinearLayout layout = new LinearLayout(activity);
+    layout.setLayoutParams(new ViewGroup.LayoutParams(
+      ViewGroup.LayoutParams.WRAP_CONTENT,
+      ViewGroup.LayoutParams.WRAP_CONTENT
+    ));
+    layout.setOrientation(LinearLayout.VERTICAL);
+    layout.setGravity(Gravity.CENTER_HORIZONTAL);
+    layout.setPadding(16, 32, 16, 32);
+
+    TextView textView = new TextView(activity);
+    textView.setLayoutParams(new ViewGroup.LayoutParams(
+      ViewGroup.LayoutParams.WRAP_CONTENT,
+      ViewGroup.LayoutParams.WRAP_CONTENT
+    ));
+    textView.setText(trimmingText);
+    textView.setTextSize(18);
+    layout.addView(textView);
+
+    mProgressBar = new ProgressBar(activity, null, android.R.attr.progressBarStyleHorizontal);
+    mProgressBar.setLayoutParams(new ViewGroup.LayoutParams(
+      ViewGroup.LayoutParams.MATCH_PARENT,
+      ViewGroup.LayoutParams.WRAP_CONTENT
+    ));
+    mProgressBar.setProgressTintList(ColorStateList.valueOf(Color.parseColor("#2196F3")));
+    layout.addView(mProgressBar);
+
+    AlertDialog.Builder builder = new AlertDialog.Builder(activity);
+    builder.setCancelable(false);
+    builder.setView(layout);
+
+    mProgressDialog = builder.create();
+    mProgressDialog.show();
+  }
+
+  @ReactMethod
+  public void addListener(String eventName) {
+    listenerCount += 1;
+  }
+
+  @ReactMethod
+  public void removeListeners(Integer count) {
+    listenerCount -= count;
+  }
+
+  private void sendEvent(ReactContext reactContext, String eventName, @Nullable WritableMap params) {
+    WritableMap map = params != null ? params : Arguments.createMap();
+    map.putString("name", eventName);
+    reactContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+      .emit("VideoTrim", map);
+  }
+
+  public boolean isValidVideo(String filePath) {
+    if (filePath == null || filePath.isEmpty()) return false;
+    MediaMetadataRetriever retriever = new MediaMetadataRetriever();
+    try {
+      retriever.setDataSource(getReactApplicationContext(), Uri.parse(filePath));
+    } catch (Exception e) {
+      return false;
+    }
+    String hasVideo = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_HAS_VIDEO);
+    return "yes".equals(hasVideo);
+  }
+
+  @ReactMethod
+  public void isValidVideo(String filePath, Promise promise) {
+    promise.resolve(isValidVideo(filePath));
+  }
+
+  @ReactMethod
+  public void saveVideo(String filePath, Promise promise) {
+    try {
+      StorageUtil.saveVideoToGallery(getReactApplicationContext(), filePath);
+    } catch (IOException e) {
+      WritableMap mapE = Arguments.createMap();
+      mapE.putString("message", "Fail while copying file to Gallery");
+      sendEvent(getReactApplicationContext(), "onError", mapE);
+    }
+    this.hideDialog();
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  public void listFiles(Promise promise) {
+    String[] files = StorageUtil.listFiles(getReactApplicationContext());
+    promise.resolve(Arguments.fromArray(files));
+  }
+
+  @ReactMethod
+  public void cleanFiles(Promise promise) {
+    String[] files = StorageUtil.listFiles(getReactApplicationContext());
+    int successCount = 0;
+    for (String file : files) {
+      boolean state = StorageUtil.deleteFile(file);
+      if (state) {
+        successCount++;
+      }
+    }
+    promise.resolve(successCount);
+  }
+
+  @ReactMethod
+  public void deleteFile(String filePath, Promise promise) {
+    boolean state = StorageUtil.deleteFile(filePath);
+    promise.resolve(state);
+  }
+}

package/android/src/main/java/com/shakebug/VideoTrimUtil.java

@@ -0,0 +1,133 @@
+package com.shakebug;
+
+import android.media.MediaCodec;
+import android.media.MediaExtractor;
+import android.media.MediaFormat;
+import android.media.MediaMetadataRetriever;
+import android.media.MediaMuxer;
+import android.util.Log;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.HashMap;
+
+public class VideoTrimUtil {
+    private static final String TAG = "VideoTrimUtil";
+    private static final int DEFAULT_BUFFER_SIZE = 1024 * 1024;
+
+    public static long getVideoDurationMs(String sourcePath) {
+        MediaMetadataRetriever retriever = new MediaMetadataRetriever();
+        try {
+            retriever.setDataSource(sourcePath);
+            String duration = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
+            return duration != null ? Long.parseLong(duration) : 0;
+        } catch (Exception e) {
+            Log.e(TAG, "Error reading video duration", e);
+            return 0;
+        } finally {
+            try {
+                retriever.release();
+            } catch (Exception ignored) {}
+        }
+    }
+
+    public static void trimVideo(String srcPath, String destPath, long startMs, long endMs) throws IOException {
+        MediaExtractor extractor = new MediaExtractor();
+        MediaMuxer muxer = null;
+
+        try {
+            extractor.setDataSource(srcPath);
+            int trackCount = extractor.getTrackCount();
+
+            muxer = new MediaMuxer(destPath, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4);
+            HashMap<Integer, Integer> indexMap = new HashMap<>(trackCount);
+
+            // Preserve video orientation if available
+            try {
+                MediaMetadataRetriever retriever = new MediaMetadataRetriever();
+                retriever.setDataSource(srcPath);
+                String rotationStr = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_ROTATION);
+                if (rotationStr != null) {
+                    int rotation = Integer.parseInt(rotationStr);
+                    muxer.setOrientationHint(rotation);
+                }
+                retriever.release();
+            } catch (Exception ignored) {}
+
+            int bufferSize = -1;
+            for (int i = 0; i < trackCount; i++) {
+                MediaFormat format = extractor.getTrackFormat(i);
+                String mime = format.getString(MediaFormat.KEY_MIME);
+                if (mime != null && (mime.startsWith("video/") || mime.startsWith("audio/"))) {
+                    int dstIndex = muxer.addTrack(format);
+                    indexMap.put(i, dstIndex);
+                    if (format.containsKey(MediaFormat.KEY_MAX_INPUT_SIZE)) {
+                        int newSize = format.getInteger(MediaFormat.KEY_MAX_INPUT_SIZE);
+                        bufferSize = Math.max(newSize, bufferSize);
+                    }
+                }
+            }
+
+            if (bufferSize < 0) {
+                bufferSize = DEFAULT_BUFFER_SIZE;
+            }
+
+            muxer.start();
+
+            long startUs = startMs * 1000L;
+            long endUs = endMs * 1000L;
+
+            ByteBuffer dstBuf = ByteBuffer.allocate(bufferSize);
+            MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
+
+            // Extract each track independently
+            for (int srcTrackIndex : indexMap.keySet()) {
+                // Select only the current track
+                for (int i = 0; i < trackCount; i++) {
+                    extractor.unselectTrack(i);
+                }
+                extractor.selectTrack(srcTrackIndex);
+                extractor.seekTo(startUs, MediaExtractor.SEEK_TO_CLOSEST_SYNC);
+
+                int dstTrackIndex = indexMap.get(srcTrackIndex);
+
+                while (true) {
+                    bufferInfo.offset = 0;
+                    bufferInfo.size = extractor.readSampleData(dstBuf, 0);
+
+                    if (bufferInfo.size < 0) {
+                        break;
+                    }
+
+                    long presentationTimeUs = extractor.getSampleTime();
+                    if (presentationTimeUs > endUs) {
+                        break;
+                    }
+
+                    if (presentationTimeUs >= startUs) {
+                        bufferInfo.presentationTimeUs = presentationTimeUs - startUs;
+                        bufferInfo.flags = extractor.getSampleFlags();
+                        muxer.writeSampleData(dstTrackIndex, dstBuf, bufferInfo);
+                    }
+
+                    if (!extractor.advance()) {
+                        break;
+                    }
+                }
+            }
+
+        } finally {
+            try {
+                if (muxer != null) {
+                    muxer.stop();
+                    muxer.release();
+                }
+            } catch (Exception e) {
+                Log.e(TAG, "Error releasing muxer", e);
+            }
+            try {
+                extractor.release();
+            } catch (Exception ignored) {}
+        }
+    }
+}

package/android/src/main/java/com/shakebug/ViewShot.java

@@ -351,10 +351,13 @@ public class ViewShot implements UIBlock {
 
         // evaluate real height
         if (snapshotContentContainer) {
-            h = 0;
+            int evaluatedHeight = 0;
             ScrollView scrollView = (ScrollView) view;
             for (int i = 0; i < scrollView.getChildCount(); i++) {
-                h += scrollView.getChildAt(i).getHeight();
+                evaluatedHeight += scrollView.getChildAt(i).getHeight();
+            }
+            if (evaluatedHeight > 0) {
+                h = evaluatedHeight;
             }
         }
 

package/android/src/main/java/com/shakebug/adapters/VideoTrimmerAdapter.java

@@ -0,0 +1,53 @@
+package com.shakebug.adapters;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import androidx.annotation.NonNull;
+import androidx.recyclerview.widget.RecyclerView;
+import com.shakebug.R;
+import com.shakebug.utils.VideoTrimmerUtil;
+import java.util.ArrayList;
+import java.util.List;
+
+public class VideoTrimmerAdapter extends RecyclerView.Adapter {
+  private final List<Bitmap> mBitmaps = new ArrayList<>();
+  private final LayoutInflater mInflater;
+
+  public VideoTrimmerAdapter(Context context) {
+    this.mInflater = LayoutInflater.from(context);
+  }
+
+  @NonNull @Override public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
+    return new TrimmerViewHolder(mInflater.inflate(R.layout.shakebug_video_thumb_item_layout, parent, false));
+  }
+
+  @Override public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
+    ((TrimmerViewHolder) holder).thumbImageView.setImageBitmap(mBitmaps.get(position));
+  }
+
+  @Override public int getItemCount() {
+    return mBitmaps.size();
+  }
+
+  public void addBitmaps(Bitmap bitmap) {
+    mBitmaps.add(bitmap);
+    notifyItemInserted(mBitmaps.size() - 1);
+  }
+
+  private static final class TrimmerViewHolder extends RecyclerView.ViewHolder {
+    ImageView thumbImageView;
+
+    TrimmerViewHolder(View itemView) {
+      super(itemView);
+      thumbImageView = itemView.findViewById(R.id.thumb);
+      LinearLayout.LayoutParams layoutParams = (LinearLayout.LayoutParams) thumbImageView.getLayoutParams();
+      layoutParams.width = VideoTrimmerUtil.VIDEO_FRAMES_WIDTH / VideoTrimmerUtil.MAX_COUNT_RANGE;
+      thumbImageView.setLayoutParams(layoutParams);
+    }
+  }
+}

package/android/src/main/java/com/shakebug/callback/SingleCallback.java

@@ -1,11 +1,5 @@
 package com.shakebug.callback;
 
-/**
- * Author：J.Chou
- * Date：  2016.07.20 19:01.
- * Email： who_know_me@163.com
- * Describe:
- */
 public interface SingleCallback<T,V> {
   void onSingleCallback(T t,V v);
 }