WearableCalibration.java

/*
 * Copyright 2016 Maxst, Inc. All Rights Reserved.
 */
package com.maxst.ar;

import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.os.Handler;
import android.util.DisplayMetrics;
import android.util.Log;
import android.util.TypedValue;
import android.view.Gravity;
import android.view.ViewGroup;
import android.widget.TextView;
import android.widget.Toast;

public class WearableCalibration {

    private static final String TAG = WearableCalibration.class.getSimpleName();

    private static final String COLUMN_FILE_NAME = "Filename";
    private static final String COLUMN_CALIBRATION_DATA = "Calibration Data";

    public enum EyeType {
        EYE_LEFT(0),
        EYE_RIGHT(1),
        EYE_NUM(2);

        private int value;

        private EyeType(int value) {
            this.value = value;
        }

        public int getValue() {
            return value;
        }
    }

    public enum DistanceType {
        DISTANCE_NEAR(0),
        DISTANCE_MIDDLE(1),
        DISTANCE_FAR(2),
        DISTANCE_NUM(3);

        private int value;

        private DistanceType(int value) {
            this.value = value;
        }

        public int getValue() {
            return value;
        }
    }

//  public static final String PROFILE_SAVE_DIR = Environment.getExternalStorageDirectory() + "/MaxstAR/WearableCalibrationProfile";
//  public static final String CONFIG_DIR = Environment.getExternalStorageDirectory() + "/MaxstAR" + "/Config";
//  public static final String CALIBRATION_CONFIG_NAME = "cali.config";

    private static WearableCalibration instance = null;

    public static WearableCalibration getInstance() {
        if (instance == null) {
            instance = new WearableCalibration();
        }

        return instance;
    }

    private String activeProfileName = "";

    private WearableCalibration() {
    }

    public boolean init(String modelName) {
        return MaxstARJNI.WearableCalibration_init(modelName);
    }

    public boolean isActivated() {
        return MaxstARJNI.WearableCalibration_isActivated();
    }

    public void setSurfaceSize(int surfaceWidth, int surfaceHeight) {
        final Context context = MaxstAR.getApplicationContext();

        int licenseType = MaxstARJNI.getLicenseType();

        if(licenseType == 1 || licenseType == 3 || licenseType == 4) {
            String licenseTypeString = "";
            switch (licenseType) {
                case 1:
                    licenseTypeString = "Free";
                    break;
                case 2:
                    licenseTypeString = "Invalid";
                    break;
                case 3:
                    licenseTypeString = "None";
                    break;
            }

            final String LicenseMessage = "This License " + licenseTypeString;
            Handler mainHandler = new Handler(context.getMainLooper());

            Runnable myRunnable = new Runnable() {
                @Override
                public void run() {
                    DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
                    int offsetX = displayMetrics.widthPixels / 2;
                    int offsetY = 0;

                    Toast toast = Toast.makeText(context, LicenseMessage, Toast.LENGTH_LONG);
                    ViewGroup group = (ViewGroup) toast.getView();
                    TextView messageTextView = (TextView) group.getChildAt(0);
                    messageTextView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 50);

                    toast.setGravity(Gravity.CENTER, offsetX, offsetY);
                    toast.show();
                }
            };
            mainHandler.post(myRunnable);
        }

        MaxstARJNI.WearableCalibration_setSurfaceSize(surfaceWidth, surfaceHeight);
    }

    public void deinit() {
        MaxstARJNI.WearableCalibration_deinit();
    }

    public float[] getViewport(EyeType eyeType) {
        return MaxstARJNI.WearableCalibration_getViewport(eyeType.getValue());
    }

    public float[] getProjectionMatrix(int eyeType) {
        return MaxstARJNI.WearableCalibration_getProjectionMatrix(eyeType);
    }

    public boolean writeProfile(String filePath) {
        return MaxstARJNI.WearableCalibration_writeProfile(filePath);
    }

    public boolean readProfile(String filePath) {
        return MaxstARJNI.WearableCalibration_readProfile(filePath);
    }

    public void loadDefaultProfile(String modelName) {
        MaxstARJNI.WearableCalibration_loadDefaultProfile(modelName);
    }

    public boolean setProfile(byte[] data) {
        return MaxstARJNI.WearableCalibration_setProfile(data);
    }

    public boolean readActiveProfile(Context context, String wearableDeviceName) {
        Uri uri = Uri.parse("content://com.maxst.ar.wearablecali/activeprofile");
        Cursor c = context.getContentResolver().query(uri, null, null, null, null);
        if (c == null || c.getCount() == 0) {
            Log.e(TAG, "No active profile");
            loadDefaultProfile(wearableDeviceName);
            Log.e(TAG, "Load default device profile "+ wearableDeviceName);
            return false;
        }
        c.moveToFirst();
        activeProfileName = c.getString(c.getColumnIndex(COLUMN_FILE_NAME));
        byte[] data = c.getBlob(c.getColumnIndex(COLUMN_CALIBRATION_DATA));

        Log.d(TAG, "fileName:" + activeProfileName);
        activeProfileName = activeProfileName.substring(0, activeProfileName.lastIndexOf("."));
        Log.d(TAG, "data:" + new String(data, 0, data.length));

        return setProfile(data);
    }

    public String getActiveProfileName() {
        return activeProfileName;
    }

    public void getDistancePos(DistanceType distanceType, float[] pos) {
        MaxstARJNI.WearableCalibration_getDistancePos(distanceType.getValue(), pos);
    }

    public void setCameraToEyePose(EyeType eyeType, DistanceType distanceType, float[] pose) {
        MaxstARJNI.WearableCalibration_setCameraToEyePose(eyeType.getValue(), distanceType.getValue(), pose);
    }

    public float[] getScreenCoordinate() {
        return MaxstARJNI.WearableCalibration_getScreenCoordinate();
    }

    public void getTargetGLScale(DistanceType distanceType, float[] scale) {
        MaxstARJNI.WearableCalibration_getTargetGLScale(distanceType.getValue(), scale);
    }

    public void getTargetGLPosition(DistanceType distanceType, float[] position) {
        MaxstARJNI.WearableCalibration_getTargetGLPosition(distanceType.getValue(), position);
    }
}