@regulaforensics/cordova-plugin-document-reader-api 5.4.0 → 5.8.0

package/src/android/DocumentReader.java

@@ -1,5 +1,6 @@
 package cordova.plugin.documentreader;
 
+import android.annotation.SuppressLint;
 import android.app.Activity;
 import android.app.PendingIntent;
 import android.content.Context;
@@ -8,16 +9,25 @@ import android.content.IntentFilter;
 import android.graphics.Bitmap;
 import android.nfc.NfcAdapter;
 import android.nfc.tech.IsoDep;
+import android.support.annotation.NonNull;
 import android.util.Base64;
 
 import com.regula.documentreader.api.completions.IDocumentReaderCompletion;
 import com.regula.documentreader.api.completions.IDocumentReaderInitCompletion;
 import com.regula.documentreader.api.completions.IDocumentReaderPrepareCompletion;
+import com.regula.documentreader.api.completions.IRfidNotificationCompletion;
+import com.regula.documentreader.api.completions.IRfidPKDCertificateCompletion;
+import com.regula.documentreader.api.completions.IRfidReaderRequest;
+import com.regula.documentreader.api.completions.IRfidTASignatureCompletion;
 import com.regula.documentreader.api.enums.DocReaderAction;
+import com.regula.documentreader.api.errors.DocumentReaderException;
+import com.regula.documentreader.api.params.DocReaderConfig;
 import com.regula.documentreader.api.params.ImageInputParam;
 import com.regula.documentreader.api.params.rfid.PKDCertificate;
+import com.regula.documentreader.api.params.rfid.authorization.PAResourcesIssuer;
+import com.regula.documentreader.api.params.rfid.authorization.TAChallenge;
 import com.regula.documentreader.api.results.DocumentReaderResults;
-import com.regula.documentreader.api.errors.DocumentReaderException;
+import com.regula.documentreader.api.parser.DocReaderResultsJsonParser;
 
 import org.apache.cordova.CallbackContext;
 import org.apache.cordova.CordovaPlugin;
@@ -26,6 +36,9 @@ import org.json.JSONArray;
 import org.json.JSONObject;
 import org.json.JSONException;
 
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -37,6 +50,13 @@ public class DocumentReader extends CordovaPlugin {
     private boolean backgroundRFIDEnabled = false;
     private Activity activity;
     JSONArray data;
+    private IRfidPKDCertificateCompletion paCertificateCompletion;
+    private IRfidPKDCertificateCompletion taCertificateCompletion;
+    private IRfidTASignatureCompletion taSignatureCompletion;
+    private final static String rfidNotificationCompletionEvent = "rfidNotificationCompletionEvent";
+    private final static String paCertificateCompletionEvent = "paCertificateCompletionEvent";
+    private final static String taCertificateCompletionEvent = "taCertificateCompletionEvent";
+    private final static String taSignatureCompletionEvent = "taSignatureCompletionEvent";
     private static int databaseDownloadProgress = 0;
 
     private Context getContext() {
@@ -82,12 +102,42 @@ public class DocumentReader extends CordovaPlugin {
         callbackContext.sendPluginResult(pluginResult);
     }
 
-    private void sendCompletion(int action, DocumentReaderResults results, Throwable error) {
+    private void sendCompletion(int action, DocumentReaderResults results, DocumentReaderException error) {
         PluginResult pluginResult = new PluginResult(PluginResult.Status.OK, JSONConstructor.generateCompletion(action, results, error, getContext()).toString());
         pluginResult.setKeepCallback(true);
         callbackContext.sendPluginResult(pluginResult);
     }
 
+    private void sendVideoEncoderCompletion(String sessionId, File file) {
+        PluginResult pluginResult = new PluginResult(PluginResult.Status.OK, JSONConstructor.generateVideoEncoderCompletion(sessionId, file).toString());
+        pluginResult.setKeepCallback(true);
+        callbackContext.sendPluginResult(pluginResult);
+    }
+
+    private void sendIRfidNotificationCompletion(int notification) {
+        PluginResult pluginResult = new PluginResult(PluginResult.Status.OK, rfidNotificationCompletionEvent + notification);
+        pluginResult.setKeepCallback(true);
+        callbackContext.sendPluginResult(pluginResult);
+    }
+
+    private void sendPACertificateCompletion(byte[] serialNumber, PAResourcesIssuer issuer) {
+        PluginResult pluginResult = new PluginResult(PluginResult.Status.OK, paCertificateCompletionEvent + JSONConstructor.generatePACertificateCompletion(serialNumber, issuer).toString());
+        pluginResult.setKeepCallback(true);
+        callbackContext.sendPluginResult(pluginResult);
+    }
+
+    private void sendTACertificateCompletion(String keyCAR) {
+        PluginResult pluginResult = new PluginResult(PluginResult.Status.OK, taCertificateCompletionEvent + keyCAR);
+        pluginResult.setKeepCallback(true);
+        callbackContext.sendPluginResult(pluginResult);
+    }
+    private void sendTASignatureCompletion(TAChallenge challenge) {
+        PluginResult pluginResult = new PluginResult(PluginResult.Status.OK, taSignatureCompletionEvent + JSONConstructor.generateTAChallenge(challenge).toString());
+        pluginResult.setKeepCallback(true);
+        callbackContext.sendPluginResult(pluginResult);
+    }
+
+
     @Override
     public boolean execute(String action, JSONArray args, CallbackContext callbackContext) {
         this.callbackContext = callbackContext;
@@ -112,6 +162,9 @@ public class DocumentReader extends CordovaPlugin {
         };
         try {
             switch (action) {
+                case "initializeReaderAutomatically":
+                    initializeReaderAutomatically(callback);
+                    break;
                 case "getAPIVersion":
                     getAPIVersion(callback);
                     break;
@@ -217,6 +270,9 @@ public class DocumentReader extends CordovaPlugin {
                 case "getRfidSessionStatus":
                     getRfidSessionStatus(callback);
                     break;
+                case "setRfidDelegate":
+                    setRfidDelegate(callback, args(0));
+                    break;
                 case "setEnableCoreLogs":
                     setEnableCoreLogs(callback, args(0));
                     break;
@@ -256,9 +312,24 @@ public class DocumentReader extends CordovaPlugin {
                 case "setRfidSessionStatus":
                     setRfidSessionStatus(callback, args(0));
                     break;
+                case "providePACertificates":
+                    providePACertificates(callback, args(0));
+                    break;
+                case "provideTACertificates":
+                    provideTACertificates(callback, args(0));
+                    break;
+                case "provideTASignature":
+                    provideTASignature(callback, args(0));
+                    break;
+                case "parseCoreResults":
+                    parseCoreResults(callback, args(0));
+                    break;
                 case "initializeReaderWithDatabasePath":
                     initializeReaderWithDatabasePath(callback, args(0), args(1));
                     break;
+                case "initializeReaderWithDatabase":
+                    initializeReaderWithDatabase(callback, args(0), args(1));
+                    break;
                 case "recognizeImageFrame":
                     recognizeImageFrame(callback, args(0), args(1));
                     break;
@@ -293,6 +364,7 @@ public class DocumentReader extends CordovaPlugin {
         };
         Intent intent = new Intent(activity.getApplicationContext(), activity.getClass());
         intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
+        @SuppressLint("UnspecifiedImmutableFlag")
         PendingIntent pendingIntent = PendingIntent.getActivity(activity.getApplicationContext(), 0, intent, 0);
         NfcAdapter.getDefaultAdapter(getActivity()).enableForegroundDispatch(activity, pendingIntent, filters, techList);
     }
@@ -304,8 +376,30 @@ public class DocumentReader extends CordovaPlugin {
         backgroundRFIDEnabled = false;
     }
 
+    private void initializeReaderAutomatically(Callback callback) {
+        if (!Instance().isReady())
+            try {
+                InputStream is = getContext().getAssets().open("regula.license");
+                byte[] license = new byte[is.available()];
+                //noinspection ResultOfMethodCallIgnored
+                is.read(license);
+                Instance().initializeReader(getContext(), new DocReaderConfig(license), getInitCompletion(callback));
+                is.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+                callback.error("problem reading license(see logs)");
+            }
+        else
+            callback.success("already initialized");
+    }
+
     private void getAvailableScenarios(Callback callback) throws JSONException {
-        callback.success(JSONConstructor.generateList(Instance().availableScenarios, JSONConstructor::generateDocumentReaderScenario, getContext()).toString());
+        callback.success(JSONConstructor.generateList(Instance().availableScenarios, JSONConstructor::generateDocumentReaderScenario).toString());
+    }
+
+    private void parseCoreResults(Callback callback, String json) {
+        DocumentReaderResults results = (DocumentReaderResults) DocReaderResultsJsonParser.parseCoreResults(json).get("docReaderResults");
+        callback.success(JSONConstructor.generateDocumentReaderResults(results, getContext()).toString());
     }
 
     private void getAPIVersion(Callback callback) {
@@ -354,19 +448,19 @@ public class DocumentReader extends CordovaPlugin {
     }
 
     private void getConfig(Callback callback) throws JSONException {
-        callback.success(RegulaConfig.getConfig(Instance(), getContext()).toString());
+        callback.success(RegulaConfig.getConfig(Instance()).toString());
     }
 
     private void getRfidScenario(Callback callback) {
         callback.success(Instance().rfidScenario().toJson());
     }
 
-    private void selectedScenario(Callback callback) throws JSONException {
-        callback.success(JSONConstructor.generateDocumentReaderScenario(Instance().getScenario(Instance().processParams().getScenario())).toString());
+    private void selectedScenario(Callback callback) {
+        callback.success(JSONConstructor.generateDocumentReaderScenarioFull(Instance().getScenario(Instance().processParams().getScenario())).toString());
     }
 
-    private void getScenario(Callback callback, String scenario) throws JSONException {
-        callback.success(JSONConstructor.generateDocumentReaderScenario(Instance().getScenario(scenario)).toString());
+    private void getScenario(Callback callback, String scenario) {
+        callback.success(JSONConstructor.generateDocumentReaderScenarioFull(Instance().getScenario(scenario)).toString());
     }
 
     private void getLicenseExpiryDate(Callback callback) {
@@ -388,11 +482,11 @@ public class DocumentReader extends CordovaPlugin {
     }
 
     private void getDocumentReaderIsReady(Callback callback) {
-        callback.success(Instance().getDocumentReaderIsReady());
+        callback.success(Instance().isReady());
     }
 
     private void getDocumentReaderStatus(Callback callback) {
-        callback.success(Instance().getDocumentReaderStatus());
+        callback.success(Instance().isReady());
     }
 
     private void isRFIDAvailableForUse(Callback callback) {
@@ -400,8 +494,15 @@ public class DocumentReader extends CordovaPlugin {
     }
 
     private void initializeReader(Callback callback, Object license) {
-        if (!Instance().getDocumentReaderIsReady())
-            Instance().initializeReader(getContext(), Base64.decode(license.toString(), Base64.DEFAULT), getInitCompletion(callback));
+        if (!Instance().isReady())
+            Instance().initializeReader(getContext(), new DocReaderConfig(Base64.decode(license.toString(), Base64.DEFAULT)), getInitCompletion(callback));
+        else
+            callback.success("already initialized");
+    }
+
+    private void initializeReaderWithDatabase(Callback callback, Object license, Object db) {
+        if (!Instance().isReady())
+            Instance().initializeReader(getContext(), new DocReaderConfig(Base64.decode(license.toString(), Base64.DEFAULT), Base64.decode(db.toString(), Base64.DEFAULT)), getInitCompletion(callback));
         else
             callback.success("already initialized");
     }
@@ -417,7 +518,7 @@ public class DocumentReader extends CordovaPlugin {
     }
 
     private void recognizeImageWithImageInputParams(@SuppressWarnings("unused") Callback callback, String base64Image, final JSONObject params) throws JSONException {
-        Instance().recognizeImage(JSONConstructor.bitmapFromBase64(base64Image), new ImageInputParam(params.getInt("width"), params.getInt("height"), params.getInt("type")), getCompletion());
+        Instance().recognizeImage(Helpers.bitmapFromBase64(base64Image), new ImageInputParam(params.getInt("width"), params.getInt("height"), params.getInt("type")), getCompletion());
     }
 
     private void recognizeImageWithOpts(Callback callback, String base64Image, final JSONObject opts) throws JSONException {
@@ -427,14 +528,14 @@ public class DocumentReader extends CordovaPlugin {
 
     private void recognizeImage(@SuppressWarnings("unused") Callback callback, String base64Image) {
         stopBackgroundRFID();
-        Instance().recognizeImage(JSONConstructor.bitmapFromBase64(base64Image), getCompletion());
+        Instance().recognizeImage(Helpers.bitmapFromBase64(base64Image), getCompletion());
     }
 
     private void recognizeImages(@SuppressWarnings("unused") Callback callback, JSONArray base64Images) throws JSONException {
         stopBackgroundRFID();
         Bitmap[] images = new Bitmap[base64Images.length()];
         for (int i = 0; i < images.length; i++)
-            images[i] = JSONConstructor.bitmapFromBase64(base64Images.getString(i));
+            images[i] = Helpers.bitmapFromBase64(base64Images.getString(i));
         Instance().recognizeImages(images, getCompletion());
     }
 
@@ -472,7 +573,7 @@ public class DocumentReader extends CordovaPlugin {
     }
 
     private void recognizeImageFrame(@SuppressWarnings("unused") Callback callback, String base64Image, final JSONObject opts) throws JSONException {
-        Instance().recognizeImageFrame(JSONConstructor.bitmapFromBase64(base64Image), new ImageInputParam(opts.getInt("width"), opts.getInt("height"), opts.getInt("type")), getCompletion());
+        Instance().recognizeImageFrame(Helpers.bitmapFromBase64(base64Image), new ImageInputParam(opts.getInt("width"), opts.getInt("height"), opts.getInt("type")), getCompletion());
     }
 
     private void recognizeVideoFrame(@SuppressWarnings("unused") Callback callback, String byteString, final JSONObject opts) throws JSONException {
@@ -502,7 +603,12 @@ public class DocumentReader extends CordovaPlugin {
 
     private void startRFIDReader(@SuppressWarnings("unused") Callback callback) {
         stopBackgroundRFID();
-        Instance().startRFIDReader(getContext(), getCompletion());
+        IRfidReaderRequest delegate = null;
+        if (rfidDelegate == RFIDDelegate.NO_PA)
+            delegate = getIRfidReaderRequestNoPA();
+        if (rfidDelegate == RFIDDelegate.FULL)
+            delegate = getIRfidReaderRequest();
+        Instance().startRFIDReader(getContext(), getCompletion(), delegate, getIRfidNotificationCompletion());
     }
 
     private void stopRFIDReader(Callback callback) {
@@ -538,10 +644,52 @@ public class DocumentReader extends CordovaPlugin {
         startForegroundDispatch(getActivity());
     }
 
+    private void providePACertificates(Callback callback, JSONArray certificatesJSON) throws JSONException {
+        if (paCertificateCompletion == null) {
+            callback.error("paCertificateCompletion is null");
+            return;
+        }
+        PKDCertificate[] certificates = new PKDCertificate[certificatesJSON.length()];
+        for (int i = 0; i < certificatesJSON.length(); i++) {
+            JSONObject certificate = certificatesJSON.getJSONObject(i);
+            certificates[i] = new PKDCertificate(Base64.decode(certificate.get("binaryData").toString(), Base64.DEFAULT), certificate.getInt("resourceType"), certificate.has("privateKey") ? Base64.decode(certificate.get("privateKey").toString(), Base64.DEFAULT) : null);
+        }
+        paCertificateCompletion.onCertificatesReceived(certificates);
+        callback.success();
+    }
+
+    private void provideTACertificates(Callback callback, JSONArray certificatesJSON) throws JSONException {
+        if (taCertificateCompletion == null) {
+            callback.error("taCertificateCompletion is null");
+            return;
+        }
+        PKDCertificate[] certificates = new PKDCertificate[certificatesJSON.length()];
+        for (int i = 0; i < certificatesJSON.length(); i++) {
+            JSONObject certificate = certificatesJSON.getJSONObject(i);
+            certificates[i] = new PKDCertificate(Base64.decode(certificate.get("binaryData").toString(), Base64.DEFAULT), certificate.getInt("resourceType"), certificate.has("privateKey") ? Base64.decode(certificate.get("privateKey").toString(), Base64.DEFAULT) : null);
+        }
+        taCertificateCompletion.onCertificatesReceived(certificates);
+        callback.success();
+    }
+
+    private void provideTASignature(Callback callback, Object signature) {
+        if (taSignatureCompletion == null) {
+            callback.error("taSignatureCompletion is null");
+            return;
+        }
+        taSignatureCompletion.onSignatureReceived(Base64.decode(signature.toString(), Base64.DEFAULT));
+        callback.success();
+    }
+
     private void setCameraSessionIsPaused(Callback callback, @SuppressWarnings("unused") boolean ignored) {
         callback.error("setCameraSessionIsPaused() is an ios-only method");
     }
 
+    private void setRfidDelegate(Callback callback, int delegate) {
+        rfidDelegate = delegate;
+        callback.success();
+    }
+
     private void getCameraSessionIsPaused(Callback callback) {
         callback.error("getCameraSessionIsPaused() is an ios-only method");
     }
@@ -595,10 +743,69 @@ public class DocumentReader extends CordovaPlugin {
 
     private IDocumentReaderInitCompletion getInitCompletion(Callback callback) {
         return (success, error) -> {
-            if (success)
+            if (success) {
+                Instance().setVideoEncoderCompletion(this::sendVideoEncoderCompletion);
                 callback.success("init completed");
-            else
+            } else
                 callback.error("Init failed:" + error);
         };
     }
-}
+
+    private IRfidReaderRequest getIRfidReaderRequest() {
+        return new IRfidReaderRequest() {
+            @Override
+            public void onRequestPACertificates(byte[] serialNumber, PAResourcesIssuer issuer, @NonNull IRfidPKDCertificateCompletion completion) {
+                paCertificateCompletion = completion;
+                completion.onCertificatesReceived(new PKDCertificate[0]);
+                sendPACertificateCompletion(serialNumber, issuer);
+            }
+
+            @Override
+            public void onRequestTACertificates(String keyCAR, @NonNull IRfidPKDCertificateCompletion completion) {
+                taCertificateCompletion = completion;
+                sendTACertificateCompletion(keyCAR);
+            }
+
+            @Override
+            public void onRequestTASignature(TAChallenge challenge, @NonNull IRfidTASignatureCompletion completion) {
+                taSignatureCompletion = completion;
+                sendTASignatureCompletion(challenge);
+            }
+        };
+    }
+
+    private IRfidReaderRequest getIRfidReaderRequestNoPA() {
+        return new IRfidReaderRequest() {
+            @Override
+            public void onRequestPACertificates(byte[] serialNumber, PAResourcesIssuer issuer, @NonNull IRfidPKDCertificateCompletion completion) {
+                paCertificateCompletion = null;
+                completion.onCertificatesReceived(new PKDCertificate[0]);
+            }
+
+            @Override
+            public void onRequestTACertificates(String keyCAR, @NonNull IRfidPKDCertificateCompletion completion) {
+                taCertificateCompletion = completion;
+                sendTACertificateCompletion(keyCAR);
+            }
+
+            @Override
+            public void onRequestTASignature(TAChallenge challenge, @NonNull IRfidTASignatureCompletion completion) {
+                taSignatureCompletion = completion;
+                sendTASignatureCompletion(challenge);
+            }
+        };
+    }
+
+    private static int rfidDelegate = RFIDDelegate.NULL;
+
+    private static class RFIDDelegate {
+        public static final int NULL = 0;
+        public static final int NO_PA = 1;
+        public static final int FULL = 2;
+    }
+
+
+    private IRfidNotificationCompletion getIRfidNotificationCompletion() {
+        return (notificationType, value) -> sendIRfidNotificationCompletion(notificationType);
+    }
+}

package/src/android/Helpers.java

@@ -0,0 +1,146 @@
+package cordova.plugin.documentreader;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Canvas;
+import android.graphics.Matrix;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.util.Base64;
+
+import com.regula.documentreader.api.enums.BarcodeType;
+import com.regula.documentreader.api.params.FaceMetaData;
+import com.regula.documentreader.api.results.Bounds;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.ByteArrayOutputStream;
+import java.util.ArrayList;
+import java.util.List;
+
+class Helpers {
+    static Bitmap bitmapFromBase64(String base64) {
+        byte[] decodedString = Base64.decode(base64, Base64.DEFAULT);
+        BitmapFactory.Options options = new BitmapFactory.Options();
+        options.inPreferredConfig = Bitmap.Config.RGB_565;
+        Bitmap result = BitmapFactory.decodeByteArray(decodedString, 0, decodedString.length, options);
+        int sizeMultiplier = result.getByteCount() / 5000000;
+        if (result.getByteCount() > 5000000)
+            result = Bitmap.createScaledBitmap(result, result.getWidth() / (int) Math.sqrt(sizeMultiplier), result.getHeight() / (int) Math.sqrt(sizeMultiplier), false);
+        return result;
+    }
+
+    static BitmapDrawable drawableFromBase64(String base64, Context context)
+    {
+        byte[] decodedByte = Base64.decode(base64, 0);
+        Bitmap bitmap =  BitmapFactory.decodeByteArray(decodedByte, 0, decodedByte.length);
+        float density = context.getResources().getDisplayMetrics().density;
+        int width = (int)(bitmap.getWidth()*density);
+        int height = (int)(bitmap.getHeight()*density);
+        return new BitmapDrawable(context.getResources(), Bitmap.createScaledBitmap(bitmap, width, height, false));
+    }
+
+    static Bitmap bitmapFromDrawable(Drawable drawable) {
+        Bitmap bitmap;
+
+        if (drawable instanceof BitmapDrawable) {
+            BitmapDrawable bitmapDrawable = (BitmapDrawable) drawable;
+            if (bitmapDrawable.getBitmap() != null) {
+                return bitmapDrawable.getBitmap();
+            }
+        }
+
+        if (drawable.getIntrinsicWidth() <= 0 || drawable.getIntrinsicHeight() <= 0) {
+            bitmap = Bitmap.createBitmap(1, 1, Bitmap.Config.ARGB_8888);
+        } else {
+            bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
+        }
+
+        Canvas canvas = new Canvas(bitmap);
+        drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
+        drawable.draw(canvas);
+        return bitmap;
+    }
+
+    static String bitmapToBase64String(Bitmap bitmap) {
+        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+        bitmap.compress(Bitmap.CompressFormat.JPEG, 100, byteArrayOutputStream);
+        byte[] byteArray = byteArrayOutputStream.toByteArray();
+
+        return Base64.encodeToString(byteArray, Base64.DEFAULT);
+    }
+
+    static Matrix matrixFromFloatArray(float[] floats) {
+        Matrix matrix = new Matrix();
+        matrix.setValues(floats);
+        return matrix;
+    }
+
+    static float[] floatArrayFromJson(JSONArray jsonArray) throws JSONException {
+        float[] result = new float[jsonArray.length()];
+        for (int i = 0; i < jsonArray.length(); i++)
+            result[i] = (float) jsonArray.getDouble(i);
+
+        return result;
+    }
+
+    static int[] intArrayFromJson(JSONArray jsonArray) throws JSONException {
+        int[] result = new int[jsonArray.length()];
+        for (int i = 0; i < jsonArray.length(); i++)
+            result[i] = jsonArray.getInt(i);
+
+        return result;
+    }
+
+    static String[] barcodeTypeArrayFromJson(JSONArray jsonArray) throws JSONException {
+        String[] result = new String[jsonArray.length()];
+        for (int i = 0; i < jsonArray.length(); i++)
+            result[i] = BarcodeType.valueOf(jsonArray.getInt(i));
+
+        return result;
+    }
+
+    static FaceMetaData[] faceMetaDataArrayFromJson(JSONArray jsonArray) throws JSONException {
+        FaceMetaData[] result = new FaceMetaData[jsonArray.length()];
+        for (int i = 0; i < jsonArray.length(); i++)
+            result[i] = faceMetaDataFromJson(jsonArray.getJSONObject(i));
+
+        return result;
+    }
+
+    static FaceMetaData faceMetaDataFromJson(JSONObject object) throws JSONException {
+        FaceMetaData result = new FaceMetaData();
+        result.ID = object.getInt("ID");
+        result.rollAngle = object.getInt("rollAngle");
+        result.bounds = boundsFromJson(object.getJSONObject("bounds"));
+
+        return result;
+    }
+
+    static Bounds boundsFromJson(JSONObject object) throws JSONException {
+        Bounds result = new Bounds();
+        result.height = object.getInt("height");
+        result.width = object.getInt("width");
+        result.x = object.getInt("x");
+        result.y = object.getInt("y");
+
+        return result;
+    }
+
+    static List<String> stringListFromJson(JSONArray jsonArray) {
+        List<String> result = new ArrayList<>();
+        for (int i = 0; i < jsonArray.length(); i++)
+            result.add(jsonArray.optString(i));
+        return result;
+    }
+
+    static String[] stringArrayFromJson(JSONArray jsonArray) {
+        String[] result = new String[jsonArray.length()];
+        for (int i = 0; i < jsonArray.length(); i++)
+            result[i] = jsonArray.optString(i);
+        return result;
+    }
+}