@onekeyfe/react-native-lite-card 0.1.2

package/android/src/main/java/com/onekeyfe/reactnativelitecard/utils/GpsUtil.kt

@@ -0,0 +1,38 @@
+package so.onekey.app.wallet.lite.utils
+
+import android.content.Context
+import android.content.Intent
+import android.provider.Settings
+
+
+object GpsUtil {
+    /**
+     * 判断GPS是否开启，GPS或者AGPS开启一个就认为是开启的
+     * @param context
+     * @return true 表示开启
+     */
+    fun isOpen(context: Context?): Boolean {
+        if (context == null) {
+            return true
+        }
+        var locationMode = 0
+        val locationProviders: String
+
+        locationMode = try {
+            Settings.Secure.getInt(context.getContentResolver(), Settings.Secure.LOCATION_MODE)
+        } catch (e: Settings.SettingNotFoundException) {
+            e.printStackTrace()
+            return false
+        }
+        return locationMode != Settings.Secure.LOCATION_MODE_OFF
+    }
+
+    /**
+     * 跳转设置 打开GPS
+     * @param context
+     */
+    fun openGPS(context: Context) {
+        val intent = Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS)
+        context.startActivity(intent)
+    }
+}

package/android/src/main/java/com/onekeyfe/reactnativelitecard/utils/HexUtils.java

@@ -0,0 +1,93 @@
+package so.onekey.app.wallet.lite.utils;
+
+import java.math.BigInteger;
+import java.util.Collections;
+
+/**
+ * @author liyan
+ */
+public class HexUtils {
+
+  public static byte[] hexString2Bytes(String hex) {
+    if (hex == null) return new byte[0];
+    return String2Bytes(hex, 16);
+  }
+
+  private static byte[] String2Bytes(String str, int digit) {
+    byte[] bArray = new BigInteger("10" + str, digit).toByteArray();
+
+    byte[] ret = new byte[bArray.length - 1];
+    for (int i = 0; i < ret.length; i++) {
+      ret[i] = bArray[i + 1];
+    }
+
+    return ret;
+  }
+
+
+  public static String stringToHexString(String s) {
+    if (s == null) return "";
+    String str = "";
+    for (int i = 0; i < s.length(); i++) {
+      int ch = s.charAt(i);
+      String s4 = Integer.toHexString(ch);
+      str = str + s4;
+    }
+    return str;
+  }
+
+  /**
+   * 将字节数组转换成十六进制的字符串
+   *
+   * @param bt    字节数组
+   * @param start 起始下标
+   * @param end   终止下标
+   */
+  public static String byteArr2HexStr(byte[] bt, int start, int end) {
+    return byteArr2HexStr(bt, start, end, "");
+  }
+
+  /**
+   * 将字节数组转换成十六进制的字符串
+   *
+   * @param bt 字节数组
+   */
+  public static String byteArr2HexStr(byte[] bt) {
+    if (bt == null) return "";
+    if (bt.length == 0) return "";
+    return byteArr2HexStr(bt, 0, bt.length, "");
+  }
+
+  /**
+   * 将字节数组转换成十六进制的字符串
+   *
+   * @param bt    字节数组
+   * @param start 起始下标
+   * @param end   终止下标
+   * @param sep   每个字节之间的分割字符串
+   */
+  public static String byteArr2HexStr(byte[] bt, int start, int end, String sep) {
+    if (bt == null || bt.length < end || start < 0 || start >= end) {
+      throw new RuntimeException("param format error");
+    }
+
+    StringBuffer sb = new StringBuffer();
+    for (int i = start; i < end; i++) {
+      sb.append(byte2HexStr(bt[i])).append(sep);
+    }
+    return sb.toString();
+  }
+
+  /**
+   * 将byte转换成对应的十六进制字符串（如：byte值0x3D转换成字符串"3D"）
+   *
+   * @return 返回字符串长度一定为2
+   */
+  public static String byte2HexStr(byte b) {
+    int i = (b & 0xF0) >> 4;
+    int j = (b & 0x0F);
+    char c = (char) (i > 9 ? 'A' + i % 10 : '0' + i);
+    char d = (char) (j > 9 ? 'A' + j % 10 : '0' + j);
+    return "" + c + d;
+  }
+}

package/android/src/main/java/com/onekeyfe/reactnativelitecard/utils/LogUtil.kt

@@ -0,0 +1,11 @@
+package so.onekey.app.wallet.lite.utils
+
+import so.onekey.app.wallet.lite.onekeyLite.NfcConstant
+import so.onekey.app.wallet.lite.LoggerManager
+
+object LogUtil {
+    @JvmStatic
+    fun printLog(tag: String, msg: String) {
+        if (NfcConstant.DEBUG) LoggerManager.getInstance()?.logInfo("$tag: $msg")
+    }
+}

package/android/src/main/java/com/onekeyfe/reactnativelitecard/utils/MiUtil.kt

@@ -0,0 +1,93 @@
+package so.onekey.app.wallet.lite.utils
+
+import android.app.AppOpsManager
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.os.Build
+import android.provider.Settings
+import android.util.Log
+import androidx.annotation.IntDef
+import androidx.annotation.RequiresApi
+import so.onekey.app.wallet.lite.utils.MiUtil.PermissionResult.Companion.PERMISSION_ASK
+import so.onekey.app.wallet.lite.utils.MiUtil.PermissionResult.Companion.PERMISSION_DENIED
+import so.onekey.app.wallet.lite.utils.MiUtil.PermissionResult.Companion.PERMISSION_GRANTED
+import so.onekey.app.wallet.lite.utils.MiUtil.PermissionResult.Companion.PERMISSION_UNKNOWN
+
+object MiUtil {
+    val TAG = MiUtil::class.simpleName
+
+    @IntDef(value = [PERMISSION_GRANTED, PERMISSION_DENIED, PERMISSION_ASK, PERMISSION_UNKNOWN])
+    @kotlin.annotation.Retention(
+            AnnotationRetention.SOURCE
+    )
+    annotation class PermissionResult {
+        companion object {
+            /**
+             * Permission check result: this is returned by [.check]
+             * if the permission has been granted to the given package.
+             */
+            const val PERMISSION_GRANTED = 0
+
+            /**
+             * Permission check result: this is returned by [.check]
+             * if the permission has not been granted to the given package.
+             */
+            const val PERMISSION_DENIED = -1
+
+            const val PERMISSION_ASK = 1
+
+            const val PERMISSION_UNKNOWN = 2
+        }
+    }
+
+    /**
+     * 检测NFC权限是否有授权.
+     */
+    @PermissionResult
+    @RequiresApi(Build.VERSION_CODES.KITKAT)
+    fun checkNfcPermission(context: Context): Int {
+        try {
+            val mAppOps = context.getSystemService(Context.APP_OPS_SERVICE) as AppOpsManager
+            val pkg = context.applicationContext.packageName
+            val uid = context.applicationInfo.uid
+            val appOpsClass = Class.forName(AppOpsManager::class.java.name)
+            val checkOpNoThrowMethod = appOpsClass.getDeclaredMethod(
+                    "checkOpNoThrow", Integer.TYPE, Integer.TYPE,
+                    String::class.java
+            )
+            //the ops of NFC is 10016,check /data/system/appops/xxx.xml
+            val invoke = checkOpNoThrowMethod.invoke(mAppOps, 10016, uid, pkg)
+            if (invoke == null) {
+                Log.d(TAG,
+                        "MIUI check permission checkOpNoThrowMethod(AppOpsManager) invoke result is null"
+                )
+                return PERMISSION_UNKNOWN
+            }
+            val result = invoke.toString()
+            Log.d(TAG,
+                    "MIUI check permission checkOpNoThrowMethod(AppOpsManager) invoke result = $result"
+            )
+            when (result) {
+                "0" -> return PERMISSION_GRANTED
+                "1" -> return PERMISSION_DENIED
+                "5" -> return PERMISSION_ASK
+            }
+        } catch (e: Exception) {
+            Log.d(TAG, "check nfc permission fail ${e.message}", e)
+        }
+        return PERMISSION_UNKNOWN
+    }
+
+    fun intentToAppSetting(context: Context): Boolean {
+        val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
+        intent.data = Uri.fromParts("package", context.packageName, null)
+        return try {
+            context.startActivity(intent)
+            true
+        } catch (e: Exception) {
+            Log.d(TAG, "open app setting fail ${e.message}", e)
+            false
+        }
+    }
+}

package/android/src/main/java/com/onekeyfe/reactnativelitecard/utils/NfcPermissionUtils.kt

@@ -0,0 +1,24 @@
+package so.onekey.app.wallet.lite.utils
+
+import android.app.Activity
+import android.os.Build
+
+object NfcPermissionUtils {
+
+    inline fun checkPermission(activity: Activity, doNext: () -> Unit): Int {
+        return if ("xiaomi".equals(Build.MANUFACTURER, true)) {
+            return checkMiuiPermission(activity, doNext)
+        } else {
+            doNext.invoke()
+            0
+        }
+    }
+
+    inline fun checkMiuiPermission(activity: Activity, doNext: () -> Unit): Int {
+        when (MiUtil.checkNfcPermission(activity)) {
+            MiUtil.PermissionResult.PERMISSION_GRANTED -> doNext.invoke()
+            else -> {}
+        }
+        return MiUtil.checkNfcPermission(activity)
+    }
+}

package/android/src/main/java/com/onekeyfe/reactnativelitecard/utils/Utils.java

@@ -0,0 +1,437 @@
+package so.onekey.app.wallet.lite.utils;
+
+import android.annotation.SuppressLint;
+import android.app.Activity;
+import android.app.ActivityManager;
+import android.app.Application;
+import android.app.Application.ActivityLifecycleCallbacks;
+import android.content.Context;
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * <pre>
+ *     author:
+ *                                      ___           ___           ___         ___
+ *         _____                       /  /\         /__/\         /__/|       /  /\
+ *        /  /::\                     /  /::\        \  \:\       |  |:|      /  /:/
+ *       /  /:/\:\    ___     ___    /  /:/\:\        \  \:\      |  |:|     /__/::\
+ *      /  /:/~/::\  /__/\   /  /\  /  /:/~/::\   _____\__\:\   __|  |:|     \__\/\:\
+ *     /__/:/ /:/\:| \  \:\ /  /:/ /__/:/ /:/\:\ /__/::::::::\ /__/\_|:|____    \  \:\
+ *     \  \:\/:/~/:/  \  \:\  /:/  \  \:\/:/__\/ \  \:\~~\~~\/ \  \:\/:::::/     \__\:\
+ *      \  \::/ /:/    \  \:\/:/    \  \::/       \  \:\  ~~~   \  \::/~~~~      /  /:/
+ *       \  \:\/:/      \  \::/      \  \:\        \  \:\        \  \:\         /__/:/
+ *        \  \::/        \__\/        \  \:\        \  \:\        \  \:\        \__\/
+ *         \__\/                       \__\/         \__\/         \__\/
+ *     blog  : http://blankj.com
+ *     time  : 16/12/08
+ *     desc  : utils about initialization
+ * </pre>
+ */
+public final class Utils {
+
+    @SuppressLint("StaticFieldLeak")
+    private static Application sApplication;
+
+    static final ActivityLifecycleImpl ACTIVITY_LIFECYCLE = new ActivityLifecycleImpl();
+
+    private Utils() {
+        throw new UnsupportedOperationException("u can't instantiate me...");
+    }
+
+    /**
+     * Init utils.
+     *
+     * <p>Init it in the class of Application.
+     *
+     * @param context context
+     */
+    public static void init(@NonNull final ReactApplicationContext context) {
+        Utils.getActivityLifecycle().setTopActivity(context.getCurrentActivity());
+        init((Application) context.getApplicationContext());
+    }
+
+    /**
+     * Init utils.
+     *
+     * <p>Init it in the class of Application.
+     *
+     * @param app application
+     */
+    public static void init(@NonNull final Application app) {
+        if (sApplication == null) {
+            Utils.sApplication = app;
+            Utils.sApplication.registerActivityLifecycleCallbacks(ACTIVITY_LIFECYCLE);
+        }
+    }
+
+    /**
+     * Return the context of Application object.
+     *
+     * @return the context of Application object
+     */
+    public static Application getApp() {
+        if (sApplication != null) {
+            return sApplication;
+        }
+        try {
+            @SuppressLint("PrivateApi")
+            Class<?> activityThread = Class.forName("android.app.ActivityThread");
+            Object at = activityThread.getMethod("currentActivityThread").invoke(null);
+            Object app = activityThread.getMethod("getApplication").invoke(at);
+            if (app == null) {
+                throw new NullPointerException("u should init first");
+            }
+            init((Application) app);
+            return sApplication;
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+        }
+        throw new NullPointerException("u should init first");
+    }
+
+    public static ActivityLifecycleImpl getActivityLifecycle() {
+        return ACTIVITY_LIFECYCLE;
+    }
+
+    public static LinkedList<Activity> getActivityList() {
+        return ACTIVITY_LIFECYCLE.mActivityList;
+    }
+
+    @NotNull
+    public static Context getTopActivityOrApp() {
+        if (isAppForeground()) {
+            Activity topActivity = ACTIVITY_LIFECYCLE.getTopActivity();
+            return topActivity == null ? Utils.getApp() : topActivity;
+        } else {
+            return Utils.getApp();
+        }
+    }
+
+    @Nullable
+    public static Activity getTopActivity() {
+        if (!isAppForeground()) {
+            return null;
+        }
+        return ACTIVITY_LIFECYCLE.getTopActivity();
+    }
+
+    /**
+     * Finish all of activities.
+     */
+    public static void finishAllActivities() {
+        finishAllActivities(false);
+    }
+
+    /**
+     * Finish all of activities.
+     *
+     * @param isLoadAnim True to use animation for the outgoing activity, false otherwise.
+     */
+    public static void finishAllActivities(final boolean isLoadAnim) {
+        List<Activity> activityList = getActivityList();
+        for (Activity act : activityList) {
+            // sActivityList remove the index activity at onActivityDestroyed
+            act.finish();
+            if (!isLoadAnim) {
+                act.overridePendingTransition(0, 0);
+            }
+        }
+    }
+
+    /**
+     * Finish all of activities except the newest activity.
+     */
+    public static void finishAllActivitiesExceptNewest() {
+        finishAllActivitiesExceptNewest(false);
+    }
+
+    /**
+     * Finish all of activities except the newest activity.
+     *
+     * @param isLoadAnim True to use animation for the outgoing activity, false otherwise.
+     */
+    public static void finishAllActivitiesExceptNewest(final boolean isLoadAnim) {
+        List<Activity> activities = getActivityList();
+        for (int i = 1; i < activities.size(); i++) {
+            finishActivity(activities.get(i), isLoadAnim);
+        }
+    }
+
+    public static void finishActivity(@NonNull final Activity activity) {
+        finishActivity(activity, false);
+    }
+
+    public static void finishActivity(@NonNull final Activity activity, final boolean isLoadAnim) {
+        activity.finish();
+        if (!isLoadAnim) {
+            activity.overridePendingTransition(0, 0);
+        }
+    }
+
+    /**
+     * Finish the activity.
+     *
+     * @param clz The activity class.
+     */
+    public static void finishActivity(@NonNull final Class<? extends Activity> clz) {
+        finishActivity(clz, false);
+    }
+
+    /**
+     * Finish the activity.
+     *
+     * @param clz        The activity class.
+     * @param isLoadAnim True to use animation for the outgoing activity, false otherwise.
+     */
+    public static void finishActivity(
+            @NonNull final Class<? extends Activity> clz, final boolean isLoadAnim) {
+        List<Activity> activities = getActivityList();
+        for (Activity activity : activities) {
+            if (activity.getClass().equals(clz)) {
+                activity.finish();
+                if (!isLoadAnim) {
+                    activity.overridePendingTransition(0, 0);
+                }
+            }
+        }
+    }
+
+    /**
+     * Finish the activities whose type not equals the activity class.
+     *
+     * @param clz The activity class.
+     */
+    public static void finishOtherActivities(@NonNull final Class<? extends Activity> clz) {
+        finishOtherActivities(clz, false);
+    }
+
+    /**
+     * Finish the activities whose type not equals the activity class.
+     *
+     * @param clz        The activity class.
+     * @param isLoadAnim True to use animation for the outgoing activity, false otherwise.
+     */
+    public static void finishOtherActivities(
+            @NonNull final Class<? extends Activity> clz, final boolean isLoadAnim) {
+        List<Activity> activities = getActivityList();
+        for (Activity act : activities) {
+            if (!act.getClass().equals(clz)) {
+                finishActivity(act, isLoadAnim);
+            }
+        }
+    }
+
+    public static boolean isAppForeground() {
+        ActivityManager am =
+                (ActivityManager) Utils.getApp().getSystemService(Context.ACTIVITY_SERVICE);
+        if (am == null) {
+            return false;
+        }
+        List<ActivityManager.RunningAppProcessInfo> info = am.getRunningAppProcesses();
+        if (info == null || info.size() == 0) {
+            return false;
+        }
+        for (ActivityManager.RunningAppProcessInfo aInfo : info) {
+            if (aInfo.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND) {
+                return aInfo.processName.equals(Utils.getApp().getPackageName());
+            }
+        }
+        return false;
+    }
+
+    static class ActivityLifecycleImpl implements ActivityLifecycleCallbacks {
+
+        final LinkedList<Activity> mActivityList = new LinkedList<>();
+        final HashMap<Object, OnAppStatusChangedListener> mStatusListenerMap = new HashMap<>();
+
+        private int mForegroundCount = 0;
+        private int mConfigCount = 0;
+
+        void addListener(final Object object, final OnAppStatusChangedListener listener) {
+            mStatusListenerMap.put(object, listener);
+        }
+
+        void removeListener(final Object object) {
+            mStatusListenerMap.remove(object);
+        }
+
+        @Override
+        public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
+            setTopActivity(activity);
+        }
+
+        @Override
+        public void onActivityStarted(Activity activity) {
+            setTopActivity(activity);
+            if (mForegroundCount <= 0) {
+                postStatus(true);
+            }
+            if (mConfigCount < 0) {
+                ++mConfigCount;
+            } else {
+                ++mForegroundCount;
+            }
+        }
+
+        @Override
+        public void onActivityResumed(Activity activity) {
+            setTopActivity(activity);
+        }
+
+        @Override
+        public void onActivityPaused(Activity activity) {
+            /**/
+        }
+
+        @Override
+        public void onActivityStopped(Activity activity) {
+            if (activity.isChangingConfigurations()) {
+                --mConfigCount;
+            } else {
+                --mForegroundCount;
+                if (mForegroundCount <= 0) {
+                    postStatus(false);
+                }
+            }
+        }
+
+        @Override
+        public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
+            /**/
+        }
+
+        @Override
+        public void onActivityDestroyed(Activity activity) {
+            mActivityList.remove(activity);
+        }
+
+        private void postStatus(final boolean isForeground) {
+            if (mStatusListenerMap.isEmpty()) {
+                return;
+            }
+            for (OnAppStatusChangedListener onAppStatusChangedListener :
+                    mStatusListenerMap.values()) {
+                if (onAppStatusChangedListener == null) {
+                    return;
+                }
+                if (isForeground) {
+                    onAppStatusChangedListener.onForeground();
+                } else {
+                    onAppStatusChangedListener.onBackground();
+                }
+            }
+        }
+
+        private void setTopActivity(final Activity activity) {
+            if (activity == null || mActivityList == null) {
+                return;
+            }
+            if (mActivityList.contains(activity)) {
+                Activity lastActivity = mActivityList.getLast();
+                if (lastActivity != null && !lastActivity.equals(activity)) {
+                    mActivityList.remove(activity);
+                    mActivityList.addLast(activity);
+                }
+            } else {
+                mActivityList.addLast(activity);
+            }
+        }
+
+        @Nullable
+        Activity getTopActivity() {
+            if (!mActivityList.isEmpty()) {
+                final Activity topActivity = mActivityList.getLast();
+                if (topActivity != null) {
+                    return topActivity;
+                }
+            }
+            // using reflect to get top activity
+            try {
+                @SuppressLint("PrivateApi")
+                Class<?> activityThreadClass = Class.forName("android.app.ActivityThread");
+                Object activityThread =
+                        activityThreadClass.getMethod("currentActivityThread").invoke(null);
+                Field activitiesField = activityThreadClass.getDeclaredField("mActivityList");
+                activitiesField.setAccessible(true);
+                Map activities = (Map) activitiesField.get(activityThread);
+                if (activities == null) {
+                    return null;
+                }
+                for (Object activityRecord : activities.values()) {
+                    Class activityRecordClass = activityRecord.getClass();
+                    Field pausedField = activityRecordClass.getDeclaredField("paused");
+                    pausedField.setAccessible(true);
+                    if (!pausedField.getBoolean(activityRecord)) {
+                        Field activityField = activityRecordClass.getDeclaredField("activity");
+                        activityField.setAccessible(true);
+                        Activity activity = (Activity) activityField.get(activityRecord);
+                        setTopActivity(activity);
+                        return activity;
+                    }
+                }
+            } catch (ClassNotFoundException e) {
+                e.printStackTrace();
+            } catch (IllegalAccessException e) {
+                e.printStackTrace();
+            } catch (InvocationTargetException e) {
+                e.printStackTrace();
+            } catch (NoSuchMethodException e) {
+                e.printStackTrace();
+            } catch (NoSuchFieldException e) {
+                e.printStackTrace();
+            }
+            return null;
+        }
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // interface
+    ///////////////////////////////////////////////////////////////////////////
+
+    public interface OnAppStatusChangedListener {
+
+        void onForeground();
+
+        void onBackground();
+    }
+
+    public static int dp2px(final @NotNull Context context, final Float dpValue) {
+        final float scale = context.getResources().getDisplayMetrics().density;
+        return (int) (dpValue * scale + 0.5f);
+    }
+
+    public static int sp2px(final @NotNull Context context, final Float sp) {
+        final float scale = context.getResources().getDisplayMetrics().scaledDensity;
+        return (int) (sp * scale + 0.5f);
+    }
+
+    public static boolean isEmail(String email) {
+        if (null == email || "".equals(email)) return false;
+        // Pattern p = Pattern.compile("\\w+@(\\w+.)+[a-z]{2,3}"); //简单匹配
+        Pattern p = Pattern.compile("\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*"); // 复杂匹配
+        Matcher m = p.matcher(email);
+        return m.matches();
+    }
+}