@phucprime/react-native-image-editor 1.0.0

package/android/src/main/java/com/ahmedadeltito/photoeditor/TranslationService.java

@@ -0,0 +1,31 @@
+package com.ahmedadeltito.photoeditor;
+
+import java.util.HashMap;
+
+/**
+ * Created by Thien PV on 11/24/23.
+ */
+public class TranslationService {
+
+    private static TranslationService instance = null;
+    private HashMap<String, String> translations;
+
+    private TranslationService() {
+        translations = new HashMap<>();
+    }
+
+    public static TranslationService getInstance() {
+        if (instance == null) {
+            instance = new TranslationService();
+        }
+        return instance;
+    }
+
+    public void init(HashMap translations) {
+        this.translations = translations;
+    }
+
+    public String getTranslation(String key) {
+        return translations.get(key);
+    }
+}

package/android/src/main/java/com/ahmedadeltito/photoeditor/UtilFunctions.java

@@ -0,0 +1,176 @@
+package com.ahmedadeltito.photoeditor;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.os.Build;
+import android.text.Html;
+import android.util.Base64;
+import android.view.View;
+import android.view.animation.AlphaAnimation;
+import android.view.inputmethod.InputMethodManager;
+
+import java.io.ByteArrayOutputStream;
+import java.util.ArrayList;
+import java.util.StringTokenizer;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+public class UtilFunctions {
+
+    // private static final String pattern =
+    // "\\s*([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,4})\\s*";
+    // private static final String pattern =
+    // "[a-zA-Z0-9\\+\\.\\_\\%\\-\\+]{1,256}\\@[a-zA-Z0-9][a-zA-Z0-9\\-]{0,64}\\.[a-zA-Z0-9][a-zA-Z0-9\\-]{0,25})+";
+
+    private static final AlphaAnimation enableAnim = new AlphaAnimation(0.6f,
+            1.0f);
+
+    private static final AlphaAnimation disableAnim = new AlphaAnimation(1.0f,
+            0.6f);
+
+    public static boolean stringIsEmpty(String string) {
+
+        if (string != null) {
+            if (!string.trim().equals("")) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static boolean stringIsNotEmpty(String string) {
+        if (string != null && !string.equals("null")) {
+            if (!string.trim().equals("")) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static String[] stringTokenizer(String string) {
+
+        StringTokenizer tokens = new StringTokenizer(string, ",");
+        String[] result = new String[tokens.countTokens()];
+
+        for (int i = 0; i < tokens.countTokens(); i++) {
+            result[i] = tokens.nextToken();
+        }
+
+        return result;
+    }
+
+    public static String ArrayToString(ArrayList<String> string) {
+
+        String result = "";
+        StringBuilder builder = new StringBuilder();
+        int len = string.size() - 1;
+        if (string.size() > 0) {
+            for (int i = 0; i < len; i++) {
+                result += string.get(i) + ", ";
+                builder.append(string.get(i));
+                builder.append(", ");
+            }
+            result += string.get(len);
+            builder.append(string.get(len));
+        }
+
+        return builder.toString();
+    }
+
+    public static boolean isValidEmail(String s) {
+
+        // return Pattern.matches(pattern, s);
+        try {
+            return android.util.Patterns.EMAIL_ADDRESS.matcher(s).matches();
+        } catch (NullPointerException exception) {
+            return false;
+        }
+    }
+
+    public static void enableView(View v) {
+        if (Build.VERSION.SDK_INT >= 11) {
+            try {
+                v.setAlpha(1.0f);
+                return;
+            } catch (Exception e) {
+            }
+        } else {
+            enableAnim.setDuration(100);
+            enableAnim.setFillAfter(true);
+            v.startAnimation(enableAnim);
+        }
+    }
+
+    public static void disableView(View v) {
+        if (Build.VERSION.SDK_INT >= 11) {
+            try {
+                v.setAlpha(0.6f);
+                return;
+            } catch (Exception e) {
+            }
+        } else {
+            disableAnim.setDuration(100);
+            disableAnim.setFillAfter(true);
+            v.startAnimation(disableAnim);
+        }
+
+    }
+
+    public static String stripHtml(String html) {
+        String s = Html.fromHtml(html).toString();
+        s = s.replaceAll("[\n\r\t]", " ");
+        return s;
+    }
+
+    public static boolean containSpace(String s) {
+        Pattern pattern = Pattern.compile("\\s");
+        Matcher matcher = pattern.matcher(s);
+        return matcher.find();
+    }
+
+    public static String getYoutubeVideoId(String youtubeUrl) {
+        String video_id = "";
+        if (youtubeUrl != null && youtubeUrl.trim().length() > 0
+                && youtubeUrl.startsWith("http")) {
+            String expression = "^.*((youtu.be"
+                    + "\\/)"
+                    + "|(v\\/)|(\\/u\\/w\\/)|(embed\\/)|(watch\\?))\\??v?=?([^#\\&\\?]*).*";
+            CharSequence input = youtubeUrl;
+            Pattern pattern = Pattern.compile(expression,
+                    Pattern.CASE_INSENSITIVE);
+            Matcher matcher = pattern.matcher(input);
+            if (matcher.matches()) {
+                String groupIndex1 = matcher.group(7);
+                if (groupIndex1 != null && groupIndex1.length() == 11)
+                    video_id = groupIndex1;
+            }
+        }
+        return video_id;
+    }
+
+    public static String encodeImage(Bitmap bitmap) {
+        String encodedImage = "";
+        try {
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos);
+            byte[] b = baos.toByteArray();
+            baos.close();
+            baos = null;
+            encodedImage = Base64.encodeToString(b,
+                    Base64.NO_WRAP);
+        } catch (Exception e) {
+
+        }
+        return encodedImage;
+    }
+
+    public static void hideKeyboardFrom(Activity activity) {
+        InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
+        imm.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
+    }
+
+    public static void showKeyboardAt(Activity activity) {
+        InputMethodManager imm = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
+        imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
+    }
+}

package/android/src/main/java/com/ahmedadeltito/photoeditor/widget/RealtimeBlurView.java

@@ -0,0 +1,359 @@
+package com.ahmedadeltito.photoeditor.widget;
+
+/**
+ * Created by Ahmed Adel on 5/7/17.
+ */
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.content.pm.ApplicationInfo;
+import android.content.res.TypedArray;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Rect;
+import android.renderscript.Allocation;
+import android.renderscript.Element;
+import android.renderscript.RSRuntimeException;
+import android.renderscript.RenderScript;
+import android.renderscript.ScriptIntrinsicBlur;
+import android.util.AttributeSet;
+import android.util.TypedValue;
+import android.view.View;
+import android.view.ViewTreeObserver;
+
+import ui.photoeditor.R;
+
+/**
+ * A realtime blurring overlay (like iOS UIVisualEffectView). Just put it above
+ * the view you want to blur and it doesn't have to be in the same ViewGroup
+ * <ul>
+ * <li>realtimeBlurRadius (10dp)</li>
+ * <li>realtimeDownsampleFactor (4)</li>
+ * <li>realtimeOverlayColor (#aaffffff)</li>
+ * </ul>
+ */
+public class RealtimeBlurView extends View {
+
+    private float mDownsampleFactor; // default 4
+    private int mOverlayColor; // default #aaffffff
+    private float mBlurRadius; // default 10dp (0 < r <= 25)
+
+    private boolean mDirty;
+    private Bitmap mBitmapToBlur, mBlurredBitmap;
+    private Canvas mBlurringCanvas;
+    private RenderScript mRenderScript;
+    private ScriptIntrinsicBlur mBlurScript;
+    private Allocation mBlurInput, mBlurOutput;
+    private boolean mIsRendering;
+    private final Rect mRectSrc = new Rect(), mRectDst = new Rect();
+    // mDecorView should be the root view of the activity (even if you are on a different window like a dialog)
+    private View mDecorView;
+    // If the view is on different root view (usually means we are on a PopupWindow),
+    // we need to manually call invalidate() in onPreDraw(), otherwise we will not be able to see the changes
+    private boolean mDifferentRoot;
+    private static int RENDERING_COUNT;
+
+    public RealtimeBlurView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+
+        TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.RealtimeBlurView);
+        mBlurRadius = a.getDimension(R.styleable.RealtimeBlurView_realtimeBlurRadius,
+                TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 10, context.getResources().getDisplayMetrics()));
+        mDownsampleFactor = a.getFloat(R.styleable.RealtimeBlurView_realtimeDownsampleFactor, 4);
+        mOverlayColor = a.getColor(R.styleable.RealtimeBlurView_realtimeOverlayColor, 0xAAFFFFFF);
+        a.recycle();
+    }
+
+    public void setBlurRadius(float radius) {
+        if (mBlurRadius != radius) {
+            mBlurRadius = radius;
+            mDirty = true;
+            invalidate();
+        }
+    }
+
+    public void setDownsampleFactor(float factor) {
+        if (factor <= 0) {
+            throw new IllegalArgumentException("Downsample factor must be greater than 0.");
+        }
+
+        if (mDownsampleFactor != factor) {
+            mDownsampleFactor = factor;
+            mDirty = true; // may also change blur radius
+            releaseBitmap();
+            invalidate();
+        }
+    }
+
+    public void setOverlayColor(int color) {
+        if (mOverlayColor != color) {
+            mOverlayColor = color;
+            invalidate();
+        }
+    }
+
+    private void releaseBitmap() {
+        if (mBlurInput != null) {
+            mBlurInput.destroy();
+            mBlurInput = null;
+        }
+        if (mBlurOutput != null) {
+            mBlurOutput.destroy();
+            mBlurOutput = null;
+        }
+        if (mBitmapToBlur != null) {
+            mBitmapToBlur.recycle();
+            mBitmapToBlur = null;
+        }
+        if (mBlurredBitmap != null) {
+            mBlurredBitmap.recycle();
+            mBlurredBitmap = null;
+        }
+    }
+
+    private void releaseScript() {
+        if (mRenderScript != null) {
+            mRenderScript.destroy();
+            mRenderScript = null;
+        }
+        if (mBlurScript != null) {
+            mBlurScript.destroy();
+            mBlurScript = null;
+        }
+    }
+
+    protected void release() {
+        releaseBitmap();
+        releaseScript();
+    }
+
+    protected boolean prepare() {
+        if (mBlurRadius == 0) {
+            release();
+            return false;
+        }
+
+        float downsampleFactor = mDownsampleFactor;
+
+        if (mDirty || mRenderScript == null) {
+            if (mRenderScript == null) {
+                try {
+                    mRenderScript = RenderScript.create(getContext());
+                    mBlurScript = ScriptIntrinsicBlur.create(mRenderScript, Element.U8_4(mRenderScript));
+                } catch (RSRuntimeException e) {
+                    if (isDebug(getContext())) {
+                        if (e.getMessage() != null && e.getMessage().startsWith("Error loading RS jni library: java.lang.UnsatisfiedLinkError:")) {
+                            throw new RuntimeException("Error loading RS jni library, Upgrade buildToolsVersion=\"24.0.2\" or higher may solve this issue");
+                        } else {
+                            throw e;
+                        }
+                    } else {
+                        // In release mode, just ignore
+                        releaseScript();
+                        return false;
+                    }
+                }
+            }
+
+            mDirty = false;
+            float radius = mBlurRadius / downsampleFactor;
+            if (radius > 25) {
+                downsampleFactor = downsampleFactor * radius / 25;
+                radius = 25;
+            }
+            mBlurScript.setRadius(radius);
+        }
+
+        final int width = getWidth();
+        final int height = getHeight();
+
+        int scaledWidth = Math.max(1, (int) (width / downsampleFactor));
+        int scaledHeight = Math.max(1, (int) (height / downsampleFactor));
+
+        if (mBlurringCanvas == null || mBlurredBitmap == null
+                || mBlurredBitmap.getWidth() != scaledWidth
+                || mBlurredBitmap.getHeight() != scaledHeight) {
+            releaseBitmap();
+
+            boolean r = false;
+            try {
+                mBitmapToBlur = Bitmap.createBitmap(scaledWidth, scaledHeight, Bitmap.Config.ARGB_8888);
+                if (mBitmapToBlur == null) {
+                    return false;
+                }
+                mBlurringCanvas = new Canvas(mBitmapToBlur);
+
+                mBlurInput = Allocation.createFromBitmap(mRenderScript, mBitmapToBlur,
+                        Allocation.MipmapControl.MIPMAP_NONE, Allocation.USAGE_SCRIPT);
+                mBlurOutput = Allocation.createTyped(mRenderScript, mBlurInput.getType());
+
+                mBlurredBitmap = Bitmap.createBitmap(scaledWidth, scaledHeight, Bitmap.Config.ARGB_8888);
+                if (mBlurredBitmap == null) {
+                    return false;
+                }
+
+                r = true;
+            } catch (OutOfMemoryError e) {
+                // Bitmap.createBitmap() may cause OOM error
+                // Simply ignore and fallback
+            } finally {
+                if (!r) {
+                    releaseBitmap();
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    protected void blur(Bitmap bitmapToBlur, Bitmap blurredBitmap) {
+        mBlurInput.copyFrom(bitmapToBlur);
+        mBlurScript.setInput(mBlurInput);
+        mBlurScript.forEach(mBlurOutput);
+        mBlurOutput.copyTo(blurredBitmap);
+    }
+
+    private final ViewTreeObserver.OnPreDrawListener preDrawListener = new ViewTreeObserver.OnPreDrawListener() {
+        @Override
+        public boolean onPreDraw() {
+            final int[] locations = new int[2];
+            Bitmap oldBmp = mBlurredBitmap;
+            View decor = mDecorView;
+            if (decor != null && isShown() && prepare()) {
+                boolean redrawBitmap = mBlurredBitmap != oldBmp;
+                oldBmp = null;
+                decor.getLocationOnScreen(locations);
+                int x = -locations[0];
+                int y = -locations[1];
+
+                getLocationOnScreen(locations);
+                x += locations[0];
+                y += locations[1];
+
+                // just erase transparent
+                mBitmapToBlur.eraseColor(mOverlayColor & 0xffffff);
+
+                int rc = mBlurringCanvas.save();
+                mIsRendering = true;
+                RENDERING_COUNT++;
+                try {
+                    mBlurringCanvas.scale(1.f * mBitmapToBlur.getWidth() / getWidth(), 1.f * mBitmapToBlur.getHeight() / getHeight());
+                    mBlurringCanvas.translate(-x, -y);
+                    if (decor.getBackground() != null) {
+                        decor.getBackground().draw(mBlurringCanvas);
+                    }
+                    decor.draw(mBlurringCanvas);
+                } catch (StopException e) {
+                } finally {
+                    mIsRendering = false;
+                    RENDERING_COUNT--;
+                    mBlurringCanvas.restoreToCount(rc);
+                }
+
+                blur(mBitmapToBlur, mBlurredBitmap);
+
+                if (redrawBitmap || mDifferentRoot) {
+                    invalidate();
+                }
+            }
+
+            return true;
+        }
+    };
+
+    protected View getActivityDecorView() {
+        Context ctx = getContext();
+        for (int i = 0; i < 4 && ctx != null && !(ctx instanceof Activity) && ctx instanceof ContextWrapper; i++) {
+            ctx = ((ContextWrapper) ctx).getBaseContext();
+        }
+        if (ctx instanceof Activity) {
+            return ((Activity) ctx).getWindow().getDecorView();
+        } else {
+            return null;
+        }
+    }
+
+    @Override
+    protected void onAttachedToWindow() {
+        super.onAttachedToWindow();
+        mDecorView = getActivityDecorView();
+        if (mDecorView != null) {
+            mDecorView.getViewTreeObserver().addOnPreDrawListener(preDrawListener);
+            mDifferentRoot = mDecorView.getRootView() != getRootView();
+            if (mDifferentRoot) {
+                mDecorView.postInvalidate();
+            }
+        } else {
+            mDifferentRoot = false;
+        }
+    }
+
+    @Override
+    protected void onDetachedFromWindow() {
+        if (mDecorView != null) {
+            mDecorView.getViewTreeObserver().removeOnPreDrawListener(preDrawListener);
+        }
+        release();
+        super.onDetachedFromWindow();
+    }
+
+    @Override
+    public void draw(Canvas canvas) {
+        if (mIsRendering) {
+            // Quit here, don't draw views above me
+            throw STOP_EXCEPTION;
+        } else if (RENDERING_COUNT > 0) {
+            // Doesn't support blurview overlap on another blurview
+        } else {
+            super.draw(canvas);
+        }
+    }
+
+    @Override
+    protected void onDraw(Canvas canvas) {
+        super.onDraw(canvas);
+        drawBlurredBitmap(canvas, mBlurredBitmap, mOverlayColor);
+    }
+
+    /**
+     * Custom draw the blurred bitmap and color to define your own shape
+     *
+     * @param canvas
+     * @param blurredBitmap
+     * @param overlayColor
+     */
+    protected void drawBlurredBitmap(Canvas canvas, Bitmap blurredBitmap, int overlayColor) {
+        if (blurredBitmap != null) {
+            mRectSrc.right = blurredBitmap.getWidth();
+            mRectSrc.bottom = blurredBitmap.getHeight();
+            mRectDst.right = getWidth();
+            mRectDst.bottom = getHeight();
+            canvas.drawBitmap(blurredBitmap, mRectSrc, mRectDst, null);
+        }
+        canvas.drawColor(overlayColor);
+    }
+
+    private static class StopException extends RuntimeException {
+    }
+
+    private static StopException STOP_EXCEPTION = new StopException();
+
+    static {
+        try {
+            RealtimeBlurView.class.getClassLoader().loadClass("android.renderscript.RenderScript");
+        } catch (ClassNotFoundException e) {
+            throw new RuntimeException("RenderScript support not enabled. Add \"android { defaultConfig { renderscriptSupportModeEnabled true }}\" in your build.gradle");
+        }
+    }
+
+    // android:debuggable="true" in AndroidManifest.xml (auto set by build tool)
+    static Boolean DEBUG = null;
+
+    static boolean isDebug(Context ctx) {
+        if (DEBUG == null && ctx != null) {
+            DEBUG = (ctx.getApplicationInfo().flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0;
+        }
+        return DEBUG == Boolean.TRUE;
+    }
+}