shakebug-react-native 2.4.9 → 2.4.10

package/android/src/main/java/com/shakebug/thread/BackgroundExecutor.java

@@ -1,18 +1,3 @@
-/**
- * Copyright (C) 2010-2016 eBusiness Information, Excilys Group
- * <p>
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- * <p>
- * http://www.apache.org/licenses/LICENSE-2.0
- * <p>
- * Unless required by applicable law or agreed To in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
 package com.shakebug.thread;
 
 import android.util.Log;
@@ -39,24 +24,9 @@ public final class BackgroundExecutor {
   private BackgroundExecutor() {
   }
 
-  /**
-   * Execute a runnable after the given delay.
-   *
-   * @param runnable the task to execute
-   * @param delay    the time from now to delay execution, in milliseconds
-   *                 <p>
-   *                 if <code>delay</code> is strictly positive and the current
-   *                 executor does not support scheduling (if
-   *                 Executor has been called with such an
-   *                 executor)
-   * @return Future associated to the running task
-   * @throws IllegalArgumentException if the current executor set by Executor
-   *                                  does not support scheduling
-   */
   private static Future<?> directExecute(Runnable runnable, long delay) {
     Future<?> future = null;
     if (delay > 0) {
-      /* no serial, but a delay: schedule the task */
       if (!(executor instanceof ScheduledExecutorService)) {
         throw new IllegalArgumentException("The executor set does not support scheduling");
       }
@@ -67,24 +37,12 @@ public final class BackgroundExecutor {
         ExecutorService executorService = (ExecutorService) executor;
         future = executorService.submit(runnable);
       } else {
-        /* non-cancellable task */
         executor.execute(runnable);
       }
     }
     return future;
   }
 
-  /**
-   * Execute a task after (at least) its delay <strong>and</strong> after all
-   * tasks added with the same non-null <code>serial</code> (if any) have
-   * completed execution.
-   *
-   * @param task the task to execute
-   * @throws IllegalArgumentException if <code>task.delay</code> is strictly positive and the
-   *                                  current executor does not support scheduling (if
-   *                                  Executor has been called with such an
-   *                                  executor)
-   */
   public static synchronized void execute(Task task) {
     Future<?> future = null;
     if (task.serial == null || !hasSerialRunning(task.serial)) {
@@ -92,20 +50,11 @@ public final class BackgroundExecutor {
       future = directExecute(task, task.remainingDelay);
     }
     if ((task.id != null || task.serial != null) && !task.managed.get()) {
-      /* keep task */
       task.future = future;
       TASKS.add(task);
     }
   }
 
-  /**
-   * Indicates whether a task with the specified <code>serial</code> has been
-   * submitted to the executor.
-   *
-   * @param serial the serial queue
-   * @return <code>true</code> if such a task has been submitted,
-   * <code>false</code> otherwise
-   */
   private static boolean hasSerialRunning(String serial) {
     for (Task task : TASKS) {
       if (task.executionAsked && serial.equals(task.serial)) {
@@ -115,13 +64,6 @@ public final class BackgroundExecutor {
     return false;
   }
 
-  /**
-   * Retrieve and remove the first task having the specified
-   * <code>serial</code> (if any).
-   *
-   * @param serial the serial queue
-   * @return task if found, <code>null</code> otherwise
-   */
   private static Task take(String serial) {
     int len = TASKS.size();
     for (int i = 0; i < len; i++) {
@@ -132,14 +74,6 @@ public final class BackgroundExecutor {
     return null;
   }
 
-  /**
-   * Cancel all tasks having the specified <code>id</code>.
-   *
-   * @param id                    the cancellation identifier
-   * @param mayInterruptIfRunning <code>true</code> if the thread executing this task should be
-   *                              interrupted; otherwise, in-progress tasks are allowed to
-   *                              complete
-   */
   public static synchronized void cancelAll(String id, boolean mayInterruptIfRunning) {
     for (int i = TASKS.size() - 1; i >= 0; i--) {
       Task task = TASKS.get(i);
@@ -147,17 +81,11 @@ public final class BackgroundExecutor {
         if (task.future != null) {
           task.future.cancel(mayInterruptIfRunning);
           if (!task.managed.getAndSet(true)) {
-            /*
-             * the task has been submitted to the executor, but its
-             * execution has not started yet, so that its run()
-             * method will never call postExecute()
-             */
             task.postExecute();
           }
         } else if (task.executionAsked) {
           Log.w(TAG, "A task with id " + task.id + " cannot be cancelled (the executor set does not support it)");
         } else {
-          /* this task has not been submitted to the executor */
           TASKS.remove(i);
         }
       }
@@ -168,23 +96,10 @@ public final class BackgroundExecutor {
 
     private String id;
     private long remainingDelay;
-    private long targetTimeMillis; /* since epoch */
+    private long targetTimeMillis;
     private String serial;
     private boolean executionAsked;
     private Future<?> future;
-
-    /*
-     * A task can be cancelled after it has been submitted to the executor
-     * but before its run() method is called. In that case, run() will never
-     * be called, hence neither will postExecute(): the tasks with the same
-     * serial identifier (if any) will never be submitted.
-     *
-     * Therefore, cancelAll() *must* call postExecute() if run() is not
-     * started.
-     *
-     * This flag guarantees that either cancelAll() or run() manages this
-     * task post execution, but not both.
-     */
     private AtomicBoolean managed = new AtomicBoolean();
 
     public Task(String id, long delay, String serial) {
@@ -203,7 +118,6 @@ public final class BackgroundExecutor {
     @Override
     public void run() {
       if (managed.getAndSet(true)) {
-        /* cancelled and postExecute() already called */
         return;
       }
 
@@ -211,7 +125,6 @@ public final class BackgroundExecutor {
         CURRENT_SERIAL.set(serial);
         execute();
       } finally {
-        /* handle next tasks */
         postExecute();
       }
     }
@@ -220,22 +133,18 @@ public final class BackgroundExecutor {
 
     private void postExecute() {
       if (id == null && serial == null) {
-        /* nothing to do */
         return;
       }
       CURRENT_SERIAL.set(null);
       synchronized (BackgroundExecutor.class) {
-        /* execution complete */
         TASKS.remove(this);
 
         if (serial != null) {
           Task next = take(serial);
           if (next != null) {
             if (next.remainingDelay != 0) {
-              /* the delay may not have elapsed yet */
               next.remainingDelay = Math.max(0L, targetTimeMillis - System.currentTimeMillis());
             }
-            /* a task having the same serial was queued, execute it */
             BackgroundExecutor.execute(next);
           }
         }
@@ -243,4 +152,3 @@ public final class BackgroundExecutor {
     }
   }
 }
-

package/android/src/main/java/com/shakebug/thread/UiThreadExecutor.java

@@ -1,18 +1,3 @@
-/**
- * Copyright (C) 2010-2016 eBusiness Information, Excilys Group
- * <p>
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- * <p>
- * http://www.apache.org/licenses/LICENSE-2.0
- * <p>
- * Unless required by applicable law or agreed To in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
- */
 package com.shakebug.thread;
 
 import android.os.Handler;
@@ -23,10 +8,6 @@ import android.os.SystemClock;
 import java.util.HashMap;
 import java.util.Map;
 
-/**
- * This class provide operations for
- * UiThread tasks.
- */
 public final class UiThreadExecutor {
 
   private static final Handler HANDLER = new Handler(Looper.getMainLooper()) {
@@ -45,17 +26,8 @@ public final class UiThreadExecutor {
   private static final Map<String, Token> TOKENS = new HashMap<>();
 
   private UiThreadExecutor() {
-    // should not be instantiated
   }
 
-  /**
-   * Store a new task in the map for providing cancellation. This method is
-   * used by AndroidAnnotations and not intended to be called by clients.
-   *
-   * @param id    the identifier of the task
-   * @param task  the task itself
-   * @param delay the delay or zero to run immediately
-   */
   public static void runTask(String id, Runnable task, long delay) {
     if ("".equals(id)) {
       HANDLER.postDelayed(task, delay);
@@ -83,26 +55,18 @@ public final class UiThreadExecutor {
         String id = token.id;
         Token old = TOKENS.remove(id);
         if (old != token) {
-          // a runnable finished after cancelling, we just removed a
-          // wrong token, lets put it back
           TOKENS.put(id, old);
         }
       }
     }
   }
 
-  /**
-   * Cancel all tasks having the specified <code>id</code>.
-   *
-   * @param id the cancellation identifier
-   */
   public static void cancelAll(String id) {
     Token token;
     synchronized (TOKENS) {
       token = TOKENS.remove(id);
     }
     if (token == null) {
-      // nothing to cancel
       return;
     }
     HANDLER.removeCallbacksAndMessages(token);
@@ -116,5 +80,4 @@ public final class UiThreadExecutor {
       this.id = id;
     }
   }
-
 }

package/android/src/main/java/com/shakebug/utils/StorageUtil.java

@@ -0,0 +1,135 @@
+package com.shakebug.utils;
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.media.MediaScannerConnection;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Environment;
+import android.provider.MediaStore;
+import android.text.TextUtils;
+import com.facebook.react.bridge.ReactApplicationContext;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.List;
+
+public class StorageUtil {
+  public static String getOutputPath(Context context) {
+    long timestamp = System.currentTimeMillis() / 1000;
+    File file = new File(context.getFilesDir(), VideoTrimmerUtil.FILE_PREFIX + "_" + timestamp + ".mp4");
+    return file.getAbsolutePath();
+  }
+
+  public static String[] listFiles(Context context) {
+    File filesDir = context.getFilesDir();
+    File[] files = filesDir.listFiles((dir, name) -> name.startsWith(VideoTrimmerUtil.FILE_PREFIX));
+
+    List<String> fileUrls = new ArrayList<>();
+    if (files != null) {
+      for (File file : files) {
+        fileUrls.add(file.getAbsolutePath());
+      }
+    }
+
+    return fileUrls.toArray(new String[0]);
+  }
+
+  public static boolean deleteFile(String path) {
+    if (TextUtils.isEmpty(path)) return true;
+    return deleteFile(new File(path));
+  }
+
+  public static boolean deleteFile(File file) {
+    if (file == null || !file.exists()) return true;
+
+    if (file.isFile()) {
+      return file.delete();
+    }
+
+    if (!file.isDirectory()) {
+      return false;
+    }
+
+    for (File f : file.listFiles()) {
+      if (f.isFile()) {
+        f.delete();
+      } else if (f.isDirectory()) {
+        deleteFile(f);
+      }
+    }
+    return file.delete();
+  }
+
+  public static void saveVideoToGallery(ReactApplicationContext context, String videoFilePath) throws IOException {
+    File videoFile = new File(videoFilePath);
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+      saveVideoUsingMediaStore(context, videoFile);
+    } else {
+      try {
+        saveVideoUsingTraditionalStorage(context, videoFile);
+      } catch (IOException e) {
+        throw new RuntimeException(e);
+      }
+    }
+  }
+
+  private static void saveVideoUsingMediaStore(Context context, File videoFile) {
+    ContentValues values = new ContentValues();
+    values.put(MediaStore.Video.Media.TITLE, "My Video Title");
+    values.put(MediaStore.Video.Media.MIME_TYPE, "video/mp4");
+    values.put(MediaStore.Video.Media.RELATIVE_PATH, Environment.DIRECTORY_DCIM);
+    Uri uri = context.getContentResolver().insert(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, values);
+
+    if (uri != null) {
+      try {
+        OutputStream outputStream = context.getContentResolver().openOutputStream(uri);
+        copyFile(videoFile, outputStream);
+        MediaScannerConnection.scanFile(context, new String[]{uri.toString()}, new String[]{"video/*"}, null);
+      } catch (IOException e) {
+        e.printStackTrace();
+      }
+    }
+  }
+
+  private static void saveVideoUsingTraditionalStorage(Context context, File videoFile) throws IOException {
+    File galleryDirectory = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM);
+    File destinationFile = new File(galleryDirectory, videoFile.getName());
+    copyFile(videoFile, destinationFile);
+    MediaScannerConnection.scanFile(context, new String[]{destinationFile.getAbsolutePath()}, new String[]{"video/*"}, null);
+  }
+
+  private static void copyFile(File sourceFile, OutputStream outputStream) throws IOException {
+    InputStream inputStream = new FileInputStream(sourceFile);
+    copyFile(inputStream, outputStream);
+  }
+
+  private static void copyFile(File sourceFile, File destFile) throws IOException {
+    InputStream inputStream = new FileInputStream(sourceFile);
+    OutputStream outputStream = new FileOutputStream(destFile);
+    copyFile(inputStream, outputStream);
+  }
+
+  private static void copyFile(InputStream inputStream, OutputStream outputStream) throws IOException {
+    try {
+      byte[] buffer = new byte[1024];
+      int length;
+      while ((length = inputStream.read(buffer)) > 0) {
+        outputStream.write(buffer, 0, length);
+      }
+
+    } finally {
+      if (inputStream != null) {
+        inputStream.close();
+      }
+      if (outputStream != null) {
+        outputStream.close();
+      }
+    }
+  }
+}

package/android/src/main/java/com/shakebug/utils/VideoTrimmerUtil.java

@@ -0,0 +1,70 @@
+package com.shakebug.utils;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.media.MediaMetadataRetriever;
+import android.net.Uri;
+import com.shakebug.DeviceUtil;
+import com.shakebug.UnitConverter;
+import com.shakebug.VideoTrimUtil;
+import com.shakebug.callback.SingleCallback;
+import com.shakebug.interfaces.VideoTrimListener;
+import com.shakebug.thread.BackgroundExecutor;
+
+public class VideoTrimmerUtil {
+
+  private static final String TAG = VideoTrimmerUtil.class.getSimpleName();
+  public static final String FILE_PREFIX = "trimmedVideo";
+  public static final long MIN_SHOOT_DURATION = 1000L;// min 1 second for trimming
+  public static long maxShootDuration = 10 * 1000L;
+  public static int MAX_COUNT_RANGE = 10;  // how many images in the highlight range of seek bar
+  public static int SCREEN_WIDTH_FULL = DeviceUtil.getDeviceWidth();
+  public static final int RECYCLER_VIEW_PADDING = UnitConverter.dpToPx(35);
+  public static int VIDEO_FRAMES_WIDTH = SCREEN_WIDTH_FULL - RECYCLER_VIEW_PADDING * 2;
+  public static int mThumbWidth = 0; // make it automatic
+  public static final int THUMB_HEIGHT = UnitConverter.dpToPx(50); // x2 for better resolution
+  private static final int THUMB_RESOLUTION_RES = 2; // double thumb resolution for better quality
+
+  public static void trim(String inputFile, String outputFile, int videoDuration, long startMs, long endMs, final VideoTrimListener callback) {
+    callback.onStartTrim();
+    BackgroundExecutor.execute(new BackgroundExecutor.Task("", 0L, "") {
+      @Override
+      public void execute() {
+        try {
+          VideoTrimUtil.trimVideo(inputFile, outputFile, startMs, endMs);
+          callback.onTrimmingProgress(100);
+          callback.onFinishTrim(outputFile);
+        } catch (Exception e) {
+          callback.onError(e.getMessage() != null ? e.getMessage() : "Video trim failed");
+        }
+      }
+    });
+  }
+
+  public static void shootVideoThumbInBackground(final Context context, final Uri videoUri, final int totalThumbsCount, final long startPosition,
+                                                 final long endPosition, final SingleCallback<Bitmap, Integer> callback) {
+    BackgroundExecutor.execute(new BackgroundExecutor.Task("", 0L, "") {
+      @Override public void execute() {
+        try {
+          MediaMetadataRetriever mediaMetadataRetriever = new MediaMetadataRetriever();
+          mediaMetadataRetriever.setDataSource(context, videoUri);
+          long interval = (endPosition - startPosition) / Math.max(1, (totalThumbsCount - 1));
+          for (long i = 0; i < totalThumbsCount; ++i) {
+            long frameTime = startPosition + interval * i;
+            Bitmap bitmap = mediaMetadataRetriever.getFrameAtTime(frameTime * 1000, MediaMetadataRetriever.OPTION_CLOSEST_SYNC);
+            if(bitmap == null) continue;
+            try {
+              bitmap = Bitmap.createScaledBitmap(bitmap, mThumbWidth * THUMB_RESOLUTION_RES, THUMB_HEIGHT * THUMB_RESOLUTION_RES, false);
+            } catch (final Throwable t) {
+              t.printStackTrace();
+            }
+            callback.onSingleCallback(bitmap, (int) interval);
+          }
+          mediaMetadataRetriever.release();
+        } catch (final Throwable e) {
+          Thread.getDefaultUncaughtExceptionHandler().uncaughtException(Thread.currentThread(), e);
+        }
+      }
+    });
+  }
+}