react-native-okaycam 1.1.11 → 1.1.25

package/android/src/main/java/com/innov8tif/RNOkayCam/RNOkayCamModule.java

@@ -26,7 +26,10 @@ import com.innov8tif.okaycam.config.OkayCamBtnConfig;
 import com.innov8tif.okaycam.config.OkayCamCaptureConfig;
 import com.innov8tif.okaycam.config.OkayCamConfig;
 import com.innov8tif.okaycam.config.OkayCamFrameConfig;
+import com.innov8tif.okaycam.config.OkayCamInstruction;
+import com.innov8tif.okaycam.config.OkayCamInstructionRefImg;
 import com.innov8tif.okaycam.config.OkayCamLabelConfig;
+import com.innov8tif.okaycam.config.OkayCamPreviewConfig;
 import com.innov8tif.okaycam.config.OkayCamTimerConfig;
 import com.innov8tif.okaycam.config.OkaySelfieConfig;
 import com.innov8tif.okaycam.config.OkaySelfieLabelConfig;
@@ -46,310 +49,514 @@ import java.net.URL;
 
 public class RNOkayCamModule extends ReactContextBaseJavaModule {
 
-  private final ReactApplicationContext reactContext;
+    private final ReactApplicationContext reactContext;
 
-  public RNOkayCamModule(ReactApplicationContext reactContext) {
-    super(reactContext);
-    this.reactContext = reactContext;
-  }
+    public RNOkayCamModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+    }
+
+    @Override
+    public String getName() {
+        return "RNOkayCam";
+    }
 
-  @Override
-  public String getName() {
-    return "RNOkayCam";
-  }
+    @ReactMethod
+    public void captureDocument(ReadableMap configs, Promise promise) {
+        String LICENSE_KEY = configs.getString("license");
 
-  @ReactMethod
-  public void captureDocument(ReadableMap configs, Promise promise) {
-    String LICENSE_KEY = configs.getString("license");
+        Boolean base64 = configs.getBoolean("base64");
 
-    Boolean base64 = configs.getBoolean("base64");
+        ReadableMap userConfig = configs.getMap("config");
+        ReadableMap topLabel = userConfig.getMap("topLabel");
+        ReadableMap bottomLabel = userConfig.getMap("bottomLabel");
+        ReadableMap frame = userConfig.getMap("frame");
+        ReadableMap timer = userConfig.getMap("timer");
+        ReadableMap confirmBtnConfig = userConfig.getMap("confirmBtnConfig");
+        ReadableMap retakeBtnConfig = userConfig.getMap("retakeBtnConfig");
+        ReadableMap captureConfigPair = userConfig.getMap("captureConfigPair");
+        ReadableMap firstPhoto = captureConfigPair.getMap("firstPhoto");
+        ReadableMap secondPhoto = captureConfigPair.getMap("secondPhoto");
+        ReadableMap preview = userConfig.getMap("preview");
+        ReadableMap instruction = userConfig.getMap("instruction");
 
-    ReadableMap userConfig = configs.getMap("config");
-    ReadableMap topLabel = userConfig.getMap("topLabel");
-    ReadableMap bottomLabel = userConfig.getMap("bottomLabel");
-    ReadableMap frame = userConfig.getMap("frame");
-    ReadableMap timer = userConfig.getMap("timer");
-    ReadableMap confirmBtnConfig = userConfig.getMap("confirmBtnConfig");
-    ReadableMap retakeBtnConfig = userConfig.getMap("retakeBtnConfig");
-    ReadableMap captureConfigPair = userConfig.getMap("captureConfigPair");
-    ReadableMap firstPhoto = captureConfigPair.getMap("firstPhoto");
-    ReadableMap secondPhoto = captureConfigPair.getMap("secondPhoto");
 
-    OkayCamConfig okayCamConfig = OkayCamConfig.init(this.getCurrentActivity());
+        OkayCamConfig okayCamConfig = OkayCamConfig.init(this.getCurrentActivity());
 
-    okayCamConfig.setShowOverlay(userConfig.getBoolean("showOverlay"));
+        okayCamConfig.setShowOverlay(userConfig.getBoolean("showOverlay"));
 
-    okayCamConfig.setTorchBtnEnabled(userConfig.getBoolean("torchBtnEnabled"));
-    okayCamConfig.setCrop(userConfig.getBoolean("crop"));
+        okayCamConfig.setTorchBtnEnabled(userConfig.getBoolean("torchBtnEnabled"));
+        okayCamConfig.setCrop(userConfig.getBoolean("crop"));
+
+        if (userConfig.getInt("width") != -1) {
+            okayCamConfig.setWidth(userConfig.getInt("width"));
+        }
 
-    if (userConfig.getInt("width") != -1) {
-        okayCamConfig.setWidth(userConfig.getInt("width"));
+        okayCamConfig.setImageQuality((float) userConfig.getDouble("imageQuality"));
+
+        okayCamConfig.setTopLabel(new OkayCamLabelConfig(
+                topLabel.getString("text"),
+                Color.parseColor(topLabel.getString("color")),
+                topLabel.getInt("size")
+        ));
+        okayCamConfig.setBottomLabel(new OkayCamLabelConfig(
+                bottomLabel.getString("text"),
+                Color.parseColor(bottomLabel.getString("color")),
+                bottomLabel.getInt("size")
+        ));
+
+        OkayCamFrameConfig frameConfig = getFrameConfig(frame);
+        okayCamConfig.setFrame(frameConfig);
+
+        okayCamConfig.setCaptureBtnColor(Color.parseColor(userConfig.getString("captureBtnColor")));
+        okayCamConfig.setTimer(new OkayCamTimerConfig(
+                Color.parseColor(timer.getString("backgroundColor")),
+                Color.parseColor(timer.getString("textColor"))
+        ));
+
+        okayCamConfig.setConfirmBtnConfig(new OkayCamBtnConfig(
+                Color.parseColor(confirmBtnConfig.getString("backgroundColor")),
+                Color.parseColor(confirmBtnConfig.getString("contentColor"))
+        ));
+
+        okayCamConfig.setRetakeBtnConfig(new OkayCamBtnConfig(
+                Color.parseColor(retakeBtnConfig.getString("backgroundColor")),
+                Color.parseColor(retakeBtnConfig.getString("contentColor"))
+        ));
+
+        okayCamConfig.setCaptureConfig(new CaptureConfigPair(
+                firstPhoto != null ? new OkayCamCaptureConfig(
+                        firstPhoto.getInt("delay"),
+                        firstPhoto.getBoolean("onFlash"),
+                        firstPhoto.getString("outputPath")
+                ) : null,
+                secondPhoto != null ? new OkayCamCaptureConfig(
+                        secondPhoto.getInt("delay"),
+                        secondPhoto.getBoolean("onFlash"),
+                        secondPhoto.getString("outputPath")
+                ) : null
+        ));
+
+
+        okayCamConfig.setPreview(getPreviewConfig(preview, frameConfig));
+        okayCamConfig.setInstruction(getInstructionConfig(instruction, frameConfig));
+
+        OkayCamDoc.start(this.getCurrentActivity(), LICENSE_KEY, okayCamConfig, (success, images, exception) -> {
+
+            if (success) {
+                JSONObject results = new JSONObject();
+                try {
+
+                    results.put("fullDocumentImage", convertImgToBase64(base64, images.get(0)));
+
+                    if (images.size() > 1) {
+                        results.put("fullDocumentImage2", convertImgToBase64(base64, images.get(1)));
+                    }
+
+                    if (images.size() > 2) {
+                        results.put("fullDocumentImage3", convertImgToBase64(base64, images.get(2)));
+                    }
+
+                    if (images.size() > 3) {
+                        results.put("fullDocumentImage4", convertImgToBase64(base64, images.get(3)));
+                    }
+
+                    promise.resolve(results.toString());
+                } catch (JSONException e) {
+                    // TODO Auto-generated catch block
+                    e.printStackTrace();
+                    promise.reject(this.getError(e.getMessage()));
+                }
+            } else {
+                promise.reject(this.getError(exception.getMessage()));
+            }
+            return null;
+        });
     }
 
-    okayCamConfig.setImageQuality((float) userConfig.getDouble("imageQuality"));
-    
-    okayCamConfig.setTopLabel(new OkayCamLabelConfig(
-            topLabel.getString("text"),
-            Color.parseColor(topLabel.getString("color")),
-            topLabel.getInt("size")
-    ));
-    okayCamConfig.setBottomLabel(new OkayCamLabelConfig(
-            bottomLabel.getString("text"),
-            Color.parseColor(bottomLabel.getString("color")),
-            bottomLabel.getInt("size")
-    ));
-
-    okayCamConfig.setFrame(getFrameConfig(frame));
-
-    okayCamConfig.setCaptureBtnColor(Color.parseColor(userConfig.getString("captureBtnColor")));
-    okayCamConfig.setTimer(new OkayCamTimerConfig(
-            Color.parseColor(timer.getString("backgroundColor")),
-            Color.parseColor(timer.getString("textColor"))
-    ));
-
-    okayCamConfig.setConfirmBtnConfig(new OkayCamBtnConfig(
-            Color.parseColor(confirmBtnConfig.getString("backgroundColor")),
-            Color.parseColor(confirmBtnConfig.getString("contentColor"))
-    ));
-
-    okayCamConfig.setRetakeBtnConfig(new OkayCamBtnConfig(
-            Color.parseColor(retakeBtnConfig.getString("backgroundColor")),
-            Color.parseColor(retakeBtnConfig.getString("contentColor"))
-    ));
-
-    okayCamConfig.setCaptureConfig(new CaptureConfigPair(
-            firstPhoto != null ? new OkayCamCaptureConfig(
-                    firstPhoto.getInt("delay"),
-                    firstPhoto.getBoolean("onFlash"),
-                    firstPhoto.getString("outputPath")
-            ) : null,
-            secondPhoto != null ? new OkayCamCaptureConfig(
-                    secondPhoto.getInt("delay"),
-                    secondPhoto.getBoolean("onFlash"),
-                    secondPhoto.getString("outputPath")
-            ) : null
-    ));
-
-    OkayCamDoc.start(this.getCurrentActivity(), LICENSE_KEY, okayCamConfig, (success, images, exception) -> {
-
-      if (success) {
-        JSONObject results = new JSONObject();
+    private OkayCamInstruction getInstructionConfig(ReadableMap instruction, OkayCamFrameConfig frameConfig) {
+        if (instruction == null) return null;
+        OkayCamLabelConfig title = mapToLabelConfig(instruction.getMap("title"));
+
+        ReadableMap refMap1 = instruction.getMap("refImage1");
+        OkayCamInstructionRefImg ref1 = mapToRef(refMap1, frameConfig, "instr1");
+
+        ReadableMap refMap2 = instruction.getMap("refImage2");
+        OkayCamInstructionRefImg ref2 = mapToRef(refMap2, frameConfig, "instr2");
+
+
+        return new OkayCamInstruction(
+                title,
+                ref1,
+                ref2
+        );
+    }
+
+    private OkayCamInstructionRefImg mapToRef(ReadableMap refMap, OkayCamFrameConfig frameConfig, String fileName) {
+        if (refMap == null) return null;
+        OkayCamLabelConfig title = mapToLabelConfig(refMap.getMap("title"));
+        String img1 = getImageFromJs(refMap.getString("img"), frameConfig, fileName);
+
+        return new OkayCamInstructionRefImg(title, img1);
+    }
+
+    private String getImageFromJs(String refImage, OkayCamFrameConfig frameConfig, String fileName) {
+
+
+        Size size = frameConfig.getSize();
+        int frameWidth = size.getWidth();
+        int frameHeight = size.getHeight();
+
+        Bitmap contentBmp = null;
         try {
+            if (refImage != null) {
+
+                // In debug, the image is returned as URL
+                if (BuildConfig.DEBUG) {
+                    InputStream inputStream = new URL(refImage).openStream();
+
+                    if (refImage.contains("svg")) {
+
+                        SVG svg = SVG.getFromInputStream(inputStream);
+
+                        svg.setDocumentWidth(frameWidth);
+                        svg.setDocumentHeight(frameHeight);
+
+                        if (svg.getDocumentWidth() != -1) {
+                            contentBmp = Bitmap.createBitmap((int) Math.ceil(svg.getDocumentWidth()),
+                                    (int) Math.ceil(svg.getDocumentHeight()),
+                                    Bitmap.Config.ARGB_8888);
+
+                            Canvas bmcanvas = new Canvas(contentBmp);
 
-          results.put("fullDocumentImage", convertImgToBase64(base64, images.get(0)));
+                            // Render our document onto our canvas
+                            svg.renderToCanvas(bmcanvas, new RenderOptions().preserveAspectRatio(PreserveAspectRatio.FULLSCREEN));
+                        }
+                    } else {
+                        contentBmp = BitmapFactory.decodeStream(inputStream);
+                    }
+                } else {
+                    // In release, the image is returned as raw (svg) or drawable (png, jpeg and etc)
+                    int resourceId = this.getCurrentActivity().getResources().getIdentifier(refImage, "raw", this.getCurrentActivity().getPackageName());
 
-          if (images.size() > 1) {
-            results.put("fullDocumentImage2", convertImgToBase64(base64, images.get(1)));
-          }
+                    if (resourceId != 0) {
+                        SVG svg = SVG.getFromResource(getReactApplicationContext(), resourceId);
 
-          promise.resolve(results.toString());
-        } catch (JSONException e) {
-          // TODO Auto-generated catch block
-          e.printStackTrace();
-          promise.reject(this.getError(e.getMessage()));
+                        svg.setDocumentWidth(frameWidth);
+                        svg.setDocumentHeight(frameHeight);
+
+                        if (svg.getDocumentWidth() != -1) {
+                            contentBmp = Bitmap.createBitmap((int) Math.ceil(svg.getDocumentWidth()),
+                                    (int) Math.ceil(svg.getDocumentHeight()),
+                                    Bitmap.Config.ARGB_8888);
+
+                            Canvas bmcanvas = new Canvas(contentBmp);
+
+                            // Render our document onto our canvas
+                            svg.renderToCanvas(bmcanvas, new RenderOptions().preserveAspectRatio(PreserveAspectRatio.FULLSCREEN));
+                        }
+                    } else {
+                        resourceId = this.getCurrentActivity().getResources().getIdentifier(refImage, "drawable", this.getCurrentActivity().getPackageName());
+                        contentBmp = BitmapFactory.decodeResource(getReactApplicationContext().getResources(), resourceId);
+                    }
+                }
+            }
+        } catch (SVGParseException | MalformedURLException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            e.printStackTrace();
         }
-      }
-      else {
-        promise.reject(this.getError(exception.getMessage()));
-      }
-      return null;
-    });
-  }
-
-  private OkayCamFrameConfig getFrameConfig(ReadableMap frameConfig) {
-    ReadableMap frameSizeMap = frameConfig.getMap("size");
-    String frameColor = frameConfig.getString("color");
-    String frameContent = frameConfig.getString("content");
-
-    int frameWidth = frameSizeMap.getInt("width");
-    int frameHeight = frameSizeMap.getInt("height");
-    Size frameSize = new Size(frameWidth, frameHeight);
-
-    try {
-      if (frameContent != null) {
+
+        return generateFile(contentBmp, fileName);
+    }
+
+    private OkayCamPreviewConfig getPreviewConfig(ReadableMap preview, OkayCamFrameConfig frameConfig) {
+        if (preview == null) return null;
+        OkayCamLabelConfig title = mapToLabelConfig(preview.getMap("title"));
+        OkayCamLabelConfig instr1 = mapToLabelConfig(preview.getMap("instruction1"));
+        OkayCamLabelConfig instr2 = mapToLabelConfig(preview.getMap("instruction2"));
+        OkayCamLabelConfig instr3 = mapToLabelConfig(preview.getMap("instruction3"));
+
+        int bgColor = Color.parseColor(preview.getString("backgroundColor"));
+
+        String refImage = preview.getString("refImage");
+
+        Size size = frameConfig.getSize();
+        int frameWidth = size.getWidth();
+        int frameHeight = size.getHeight();
+
         Bitmap contentBmp = null;
+        try {
+            if (refImage != null) {
 
-        // In debug, the image is returned as URL
-        if (BuildConfig.DEBUG) {
-            InputStream inputStream = new URL(frameContent).openStream();
+                // In debug, the image is returned as URL
+                if (BuildConfig.DEBUG) {
+                    InputStream inputStream = new URL(refImage).openStream();
 
-            if (frameContent.contains("svg")) {
+                    if (refImage.contains("svg")) {
 
-              SVG svg = SVG.getFromInputStream(inputStream);
+                        SVG svg = SVG.getFromInputStream(inputStream);
 
-              svg.setDocumentWidth(frameWidth);
-              svg.setDocumentHeight(frameHeight);
+                        svg.setDocumentWidth(frameWidth);
+                        svg.setDocumentHeight(frameHeight);
 
-              if (svg.getDocumentWidth() != -1) {
-                contentBmp = Bitmap.createBitmap((int) Math.ceil(svg.getDocumentWidth()),
-                        (int) Math.ceil(svg.getDocumentHeight()),
-                        Bitmap.Config.ARGB_8888);
+                        if (svg.getDocumentWidth() != -1) {
+                            contentBmp = Bitmap.createBitmap((int) Math.ceil(svg.getDocumentWidth()),
+                                    (int) Math.ceil(svg.getDocumentHeight()),
+                                    Bitmap.Config.ARGB_8888);
 
-                Canvas bmcanvas = new Canvas(contentBmp);
+                            Canvas bmcanvas = new Canvas(contentBmp);
 
-                // Render our document onto our canvas
-                svg.renderToCanvas(bmcanvas, new RenderOptions().preserveAspectRatio(PreserveAspectRatio.FULLSCREEN));
-              }
-            } else {
-              contentBmp = BitmapFactory.decodeStream(inputStream);
-            }
-        } else {
-          // In release, the image is returned as raw (svg) or drawable (png, jpeg and etc)
-            int resourceId = this.getCurrentActivity().getResources().getIdentifier(frameContent, "raw", this.getCurrentActivity().getPackageName());
+                            // Render our document onto our canvas
+                            svg.renderToCanvas(bmcanvas, new RenderOptions().preserveAspectRatio(PreserveAspectRatio.FULLSCREEN));
+                        }
+                    } else {
+                        contentBmp = BitmapFactory.decodeStream(inputStream);
+                    }
+                } else {
+                    // In release, the image is returned as raw (svg) or drawable (png, jpeg and etc)
+                    int resourceId = this.getCurrentActivity().getResources().getIdentifier(refImage, "raw", this.getCurrentActivity().getPackageName());
 
-            if (resourceId != 0) {
-              SVG svg = SVG.getFromResource(getReactApplicationContext(), resourceId);
+                    if (resourceId != 0) {
+                        SVG svg = SVG.getFromResource(getReactApplicationContext(), resourceId);
 
-              svg.setDocumentWidth(frameWidth);
-              svg.setDocumentHeight(frameHeight);
+                        svg.setDocumentWidth(frameWidth);
+                        svg.setDocumentHeight(frameHeight);
 
-              if (svg.getDocumentWidth() != -1) {
-                contentBmp = Bitmap.createBitmap((int) Math.ceil(svg.getDocumentWidth()),
-                        (int) Math.ceil(svg.getDocumentHeight()),
-                        Bitmap.Config.ARGB_8888);
+                        if (svg.getDocumentWidth() != -1) {
+                            contentBmp = Bitmap.createBitmap((int) Math.ceil(svg.getDocumentWidth()),
+                                    (int) Math.ceil(svg.getDocumentHeight()),
+                                    Bitmap.Config.ARGB_8888);
 
-                Canvas bmcanvas = new Canvas(contentBmp);
+                            Canvas bmcanvas = new Canvas(contentBmp);
 
-                // Render our document onto our canvas
-                svg.renderToCanvas(bmcanvas, new RenderOptions().preserveAspectRatio(PreserveAspectRatio.FULLSCREEN));
-              }
+                            // Render our document onto our canvas
+                            svg.renderToCanvas(bmcanvas, new RenderOptions().preserveAspectRatio(PreserveAspectRatio.FULLSCREEN));
+                        }
+                    } else {
+                        resourceId = this.getCurrentActivity().getResources().getIdentifier(refImage, "drawable", this.getCurrentActivity().getPackageName());
+                        contentBmp = BitmapFactory.decodeResource(getReactApplicationContext().getResources(), resourceId);
+                    }
+                }
             }
-            else {
-              resourceId = this.getCurrentActivity().getResources().getIdentifier(frameContent, "drawable", this.getCurrentActivity().getPackageName());
-              contentBmp = BitmapFactory.decodeResource(getReactApplicationContext().getResources(), resourceId);
+        } catch (SVGParseException | MalformedURLException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+
+        return new OkayCamPreviewConfig(
+                title,
+                generateFile(contentBmp, "ref.png"),
+                instr1,
+                instr2,
+                instr3,
+                bgColor
+        );
+
+    }
+
+    private OkayCamLabelConfig mapToLabelConfig(ReadableMap map) {
+        return new OkayCamLabelConfig(
+                map.getString("text"),
+                Color.parseColor(map.getString("color")),
+                map.getInt("size")
+        );
+
+    }
+
+    private OkayCamFrameConfig getFrameConfig(ReadableMap frameConfig) {
+        ReadableMap frameSizeMap = frameConfig.getMap("size");
+        String frameColor = frameConfig.getString("color");
+        String frameContent = frameConfig.getString("content");
+
+        int frameWidth = frameSizeMap.getInt("width");
+        int frameHeight = frameSizeMap.getInt("height");
+        Size frameSize = new Size(frameWidth, frameHeight);
+
+        try {
+            if (frameContent != null) {
+                Bitmap contentBmp = null;
+
+                // In debug, the image is returned as URL
+                if (BuildConfig.DEBUG) {
+                    InputStream inputStream = new URL(frameContent).openStream();
+
+                    if (frameContent.contains("svg")) {
+
+                        SVG svg = SVG.getFromInputStream(inputStream);
+
+                        svg.setDocumentWidth(frameWidth);
+                        svg.setDocumentHeight(frameHeight);
+
+                        if (svg.getDocumentWidth() != -1) {
+                            contentBmp = Bitmap.createBitmap((int) Math.ceil(svg.getDocumentWidth()),
+                                    (int) Math.ceil(svg.getDocumentHeight()),
+                                    Bitmap.Config.ARGB_8888);
+
+                            Canvas bmcanvas = new Canvas(contentBmp);
+
+                            // Render our document onto our canvas
+                            svg.renderToCanvas(bmcanvas, new RenderOptions().preserveAspectRatio(PreserveAspectRatio.FULLSCREEN));
+                        }
+                    } else {
+                        contentBmp = BitmapFactory.decodeStream(inputStream);
+                    }
+                } else {
+                    // In release, the image is returned as raw (svg) or drawable (png, jpeg and etc)
+                    int resourceId = this.getCurrentActivity().getResources().getIdentifier(frameContent, "raw", this.getCurrentActivity().getPackageName());
+
+                    if (resourceId != 0) {
+                        SVG svg = SVG.getFromResource(getReactApplicationContext(), resourceId);
+
+                        svg.setDocumentWidth(frameWidth);
+                        svg.setDocumentHeight(frameHeight);
+
+                        if (svg.getDocumentWidth() != -1) {
+                            contentBmp = Bitmap.createBitmap((int) Math.ceil(svg.getDocumentWidth()),
+                                    (int) Math.ceil(svg.getDocumentHeight()),
+                                    Bitmap.Config.ARGB_8888);
+
+                            Canvas bmcanvas = new Canvas(contentBmp);
+
+                            // Render our document onto our canvas
+                            svg.renderToCanvas(bmcanvas, new RenderOptions().preserveAspectRatio(PreserveAspectRatio.FULLSCREEN));
+                        }
+                    } else {
+                        resourceId = this.getCurrentActivity().getResources().getIdentifier(frameContent, "drawable", this.getCurrentActivity().getPackageName());
+                        contentBmp = BitmapFactory.decodeResource(getReactApplicationContext().getResources(), resourceId);
+                    }
+                }
+                return new OkayCamFrameConfig(frameSize, Color.parseColor(frameColor), generateFile(contentBmp, "content.png"));
             }
+        } catch (SVGParseException | MalformedURLException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            e.printStackTrace();
         }
-        return new OkayCamFrameConfig(frameSize, Color.parseColor(frameColor), generateFile(contentBmp));
-      }
-    } catch (SVGParseException | MalformedURLException e) {
-      e.printStackTrace();
-    } catch (IOException e) {
-      e.printStackTrace();
+
+        return new OkayCamFrameConfig(frameSize, Color.parseColor(frameColor), null);
     }
 
-    return new OkayCamFrameConfig(frameSize, Color.parseColor(frameColor), null);
-  }
+    public String generateFile(Bitmap bitmap, String filename) {
+        try {
+            String resultedFolder = ".private";
+            File privateFolder = this.getReactApplicationContext().getExternalFilesDir(resultedFolder);
 
-  public String generateFile(Bitmap bitmap) {
-    try {
-      String resultedFolder = ".private";
-      File privateFolder = this.getReactApplicationContext().getExternalFilesDir(resultedFolder);
+            if (!privateFolder.exists()) {
+                privateFolder.mkdir();
+            }
 
-      if (!privateFolder.exists()) {
-        privateFolder.mkdir();
-      }
+            File file = new File(privateFolder, filename);
+            file.createNewFile();
 
-      File file = new File(privateFolder, "content.png");
-      file.createNewFile();
+            FileOutputStream fos = new FileOutputStream(file.getAbsolutePath());
+            bitmap.compress(Bitmap.CompressFormat.PNG, 100, fos);
 
-      FileOutputStream fos = new FileOutputStream(file.getAbsolutePath());
-      bitmap.compress(Bitmap.CompressFormat.PNG, 100, fos);
+            return file.getAbsolutePath();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
 
-      return file.getAbsolutePath();
-    } catch (IOException e) {
-      e.printStackTrace();
+        return null;
     }
 
-    return null;
-  }
+    @ReactMethod
+    public void captureSelfie(ReadableMap configs, Promise promise) {
+        String LICENSE_KEY = configs.getString("license");
 
-  @ReactMethod
-  public void captureSelfie(ReadableMap configs, Promise promise) {
-    String LICENSE_KEY = configs.getString("license");
+        Boolean base64 = configs.getBoolean("base64");
 
-    Boolean base64 = configs.getBoolean("base64");
+        ReadableMap userConfig = configs.getMap("config");
+        ReadableMap topLabel = userConfig.getMap("topLabel");
+        ReadableMap switchBtnConfig = userConfig.getMap("switchBtnConfig");
+        ReadableMap confirmBtnConfig = userConfig.getMap("confirmBtnConfig");
+        ReadableMap retakeBtnConfig = userConfig.getMap("retakeBtnConfig");
 
-    ReadableMap userConfig = configs.getMap("config");
-    ReadableMap topLabel = userConfig.getMap("topLabel");
-    ReadableMap switchBtnConfig = userConfig.getMap("switchBtnConfig");
-    ReadableMap confirmBtnConfig = userConfig.getMap("confirmBtnConfig");
-    ReadableMap retakeBtnConfig = userConfig.getMap("retakeBtnConfig");
+        OkaySelfieConfig okaySelfieConfig = OkaySelfieConfig.init(this.getCurrentActivity());
 
-    OkaySelfieConfig okaySelfieConfig = OkaySelfieConfig.init(this.getCurrentActivity());
+        okaySelfieConfig.setTopLabel(new OkaySelfieLabelConfig(
+                topLabel.getString("text"),
+                Color.parseColor(topLabel.getString("color")),
+                topLabel.getInt("size")
+        ));
+        okaySelfieConfig.setBottomFrameColor(Color.parseColor(userConfig.getString("bottomFrameColor")));
 
-    okaySelfieConfig.setTopLabel(new OkaySelfieLabelConfig(
-            topLabel.getString("text"),
-            Color.parseColor(topLabel.getString("color")),
-            topLabel.getInt("size")
-    ));
-    okaySelfieConfig.setBottomFrameColor(Color.parseColor(userConfig.getString("bottomFrameColor")));
+        okaySelfieConfig.setCaptureBtnColor(Color.parseColor(userConfig.getString("captureBtnColor")));
 
-    okaySelfieConfig.setCaptureBtnColor(Color.parseColor(userConfig.getString("captureBtnColor")));
+        okaySelfieConfig.setSwitchBtnConfig(new OkaySelfieSwichBtnConfig(
+                Color.parseColor(switchBtnConfig.getString("color")),
+                switchBtnConfig.getBoolean("show")
+        ));
 
-    okaySelfieConfig.setSwitchBtnConfig(new OkaySelfieSwichBtnConfig(
-            Color.parseColor(switchBtnConfig.getString("color")),
-            switchBtnConfig.getBoolean("show")
-    ));
+        okaySelfieConfig.setConfirmBtnConfig(new OkayCamBtnConfig(
+                Color.parseColor(confirmBtnConfig.getString("backgroundColor")),
+                Color.parseColor(confirmBtnConfig.getString("contentColor"))
+        ));
 
-    okaySelfieConfig.setConfirmBtnConfig(new OkayCamBtnConfig(
-            Color.parseColor(confirmBtnConfig.getString("backgroundColor")),
-            Color.parseColor(confirmBtnConfig.getString("contentColor"))
-    ));
+        okaySelfieConfig.setRetakeBtnConfig(new OkayCamBtnConfig(
+                Color.parseColor(retakeBtnConfig.getString("backgroundColor")),
+                Color.parseColor(retakeBtnConfig.getString("contentColor"))
+        ));
 
-    okaySelfieConfig.setRetakeBtnConfig(new OkayCamBtnConfig(
-            Color.parseColor(retakeBtnConfig.getString("backgroundColor")),
-            Color.parseColor(retakeBtnConfig.getString("contentColor"))
-    ));
+        if (userConfig.getString("defaultCameraFacing").equals("front")) {
+            okaySelfieConfig.setDefaultCameraFacing(CameraFacing.FRONT);
+        } else if (userConfig.getString("defaultCameraFacing").equals("back")) {
+            okaySelfieConfig.setDefaultCameraFacing(CameraFacing.BACK);
+        }
 
-    if (userConfig.getString("defaultCameraFacing").equals("front")) {
-      okaySelfieConfig.setDefaultCameraFacing(CameraFacing.FRONT);
-    }
-    else if (userConfig.getString("defaultCameraFacing").equals("back")) {
-      okaySelfieConfig.setDefaultCameraFacing(CameraFacing.BACK);
-    }
+        if (userConfig.getInt("width") != -1) {
+            okaySelfieConfig.setWidth(userConfig.getInt("width"));
+        }
 
-    if (userConfig.getInt("width") != -1) {
-        okaySelfieConfig.setWidth(userConfig.getInt("width"));
-    }
+        okaySelfieConfig.setImageQuality((float) userConfig.getDouble("imageQuality"));
+
+        OkayCamSelfie.start(this.getCurrentActivity(), LICENSE_KEY, okaySelfieConfig, (success, image, exception) -> {
 
-    okaySelfieConfig.setImageQuality((float) userConfig.getDouble("imageQuality"));
+            if (success) {
 
-    OkayCamSelfie.start(this.getCurrentActivity(), LICENSE_KEY, okaySelfieConfig, (success, image, exception) -> {
+                JSONObject results = new JSONObject();
+                try {
+                    results.put("selfieImage", convertImgToBase64(base64, image));
+                    promise.resolve(results.toString());
+                } catch (JSONException e) {
+                    // TODO Auto-generated catch block
+                    e.printStackTrace();
+                    promise.reject(this.getError(e.getMessage()));
+                }
+            } else {
+                promise.reject(this.getError(exception.getMessage()));
+            }
+            return null;
+        });
+    }
 
-      if (success) {
+    public String convertImgToBase64(Boolean base64, String image) {
+        String result = "file://" + image;
 
-        JSONObject results = new JSONObject();
-        try {
-          results.put("selfieImage", convertImgToBase64(base64, image));
-          promise.resolve(results.toString());
-        } catch (JSONException e) {
-          // TODO Auto-generated catch block
-          e.printStackTrace();
-          promise.reject(this.getError(e.getMessage()));
+        if (base64) {
+            result = BitmapUtils.INSTANCE.convertToBase64(image);
         }
-      }
-      else {
-        promise.reject(this.getError(exception.getMessage()));
-      }
-      return null;
-    });
-  }
-
-  public String convertImgToBase64(Boolean base64, String image) {
-    String result = "file://" + image;
-
-    if (base64) {
-      result = BitmapUtils.INSTANCE.convertToBase64(image);
+
+        return result;
     }
 
-    return result;
-  }
-
-  private Exception getError(String error) {
-    String errorString = "";
-    switch (error) {
-      case "Invalid license key":
-        errorString = "invalid license";
-        break;
-      case "User refused to grant permission.":
-        errorString = "camera permission denied";
-        break;
-      case "User cancelled the activity.":
-        errorString = "cancel";
-        break;
-      default:
-        errorString = "failed";
+    private Exception getError(String error) {
+        String errorString = "";
+        switch (error) {
+            case "Invalid license key":
+                errorString = "invalid license";
+                break;
+            case "User refused to grant permission.":
+                errorString = "camera permission denied";
+                break;
+            case "User cancelled the activity.":
+                errorString = "cancel";
+                break;
+            default:
+                errorString = "failed";
+        }
+        return new Exception(errorString);
     }
-    return new Exception(errorString);
-  }
 }