@onekeyfe/react-native-jpush 0.0.0-stage → 6.7.0-23

package/android/src/main/java/cn/jiguang/internal/ActionManager.java

@@ -0,0 +1,63 @@
+package cn.jiguang.internal;
+
+import android.content.Context;
+import android.text.TextUtils;
+import cn.jiguang.api.JAction;
+import cn.jiguang.api.JActionExtra;
+import cn.jiguang.api.JDispatchAction;
+import java.util.concurrent.ConcurrentHashMap;
+import org.json.JSONObject;
+
+public class ActionManager {
+    private static volatile ActionManager instance;
+    private final ConcurrentHashMap<String, JDispatchAction> dispatchActions = new ConcurrentHashMap<String, JDispatchAction>();
+    private final ConcurrentHashMap<String, JAction> actions = new ConcurrentHashMap<String, JAction>();
+    private final ConcurrentHashMap<String, JActionExtra> extraActions = new ConcurrentHashMap<String, JActionExtra>();
+
+    public static ActionManager getInstance() {
+        if (instance == null) {
+            synchronized (ActionManager.class) {
+                if (instance == null) {
+                    instance = new ActionManager();
+                }
+            }
+        }
+        return instance;
+    }
+
+    public static void addAction(String sdkType, String className) {
+        if (TextUtils.isEmpty(sdkType) || TextUtils.isEmpty(className)) {
+            return;
+        }
+        try {
+            Object instanceObj = Class.forName(className).getDeclaredConstructor().newInstance();
+            if (instanceObj instanceof JDispatchAction) {
+                getInstance().dispatchActions.put(sdkType, (JDispatchAction) instanceObj);
+            } else if (instanceObj instanceof JAction) {
+                getInstance().actions.put(sdkType, (JAction) instanceObj);
+            } else if (instanceObj instanceof JActionExtra) {
+                getInstance().extraActions.put(sdkType, (JActionExtra) instanceObj);
+            }
+        } catch (Throwable ignored) {
+        }
+    }
+
+    public JDispatchAction getJDispatchAction(String sdkType) {
+        return sdkType != null ? dispatchActions.get(sdkType) : null;
+    }
+
+    public boolean wrapSdkVersionInfo(JSONObject target) {
+        return target != null;
+    }
+
+    public static boolean wrapSdkTypeVersionInfo(JSONObject target) {
+        return target != null;
+    }
+
+    public void handleMessage(Context context, String sdkType, Object message) {
+        JDispatchAction action = getJDispatchAction(sdkType);
+        if (action != null) {
+            action.handleMessage(context, sdkType, message);
+        }
+    }
+}

package/android/src/main/java/cn/jiguang/internal/JConstants.java

@@ -0,0 +1,61 @@
+package cn.jiguang.internal;
+
+import android.content.Context;
+import cn.jiguang.api.JAnalyticsAction;
+import cn.jiguang.core.JCoreStorage;
+import java.util.LinkedList;
+
+public class JConstants {
+    public static final byte USER_SERVICE_ACTION_ON_CREATE = 1;
+    public static final byte USER_SERVICE_ACTION_ON_START_COMMAND = 2;
+    public static final String SDK_TYPE = "JCore";
+    public static String SDK_NAME = "JCore";
+    public static final String SDK_VERSION = "5.2.0";
+    public static int SDK_VERSION_INT = 520;
+    public static boolean DEBUG_MODE = false;
+    public static boolean CMD_TO_PRINT_ALL_LOG = false;
+    public static boolean INTERNAL_USE = false;
+    public static boolean isInstrumentationHook = true;
+    public static final boolean isDynamicLoad = false;
+    public static final long SECOND = 1000L;
+    public static final long MIN = 60000L;
+    public static final long HOUR = 3600000L;
+    public static final long DAY = 86400000L;
+    public static final String ENCODING_UTF_8 = "UTF-8";
+    public static int DEFAULT_HEARTBEAT_INTERVAL = 285;
+    public static int DEFAULT_ALARM_DELAY = 290;
+    public static String TUU = "";
+    public static boolean AT_I = false;
+    public static String APP_KEY = "";
+    public static LinkedList<String> TUU_LIST = new LinkedList<String>();
+    public static JAnalyticsAction jAnalyticsAction;
+    public static Context mApplicationContext;
+
+    public static Context getAppContext(Context context) {
+        if (mApplicationContext == null && context != null) {
+            try {
+                Context app = context.getApplicationContext();
+                mApplicationContext = app != null ? app : context;
+            } catch (Throwable ignored) {
+                mApplicationContext = context;
+            }
+            JCoreStorage.setAppContext(mApplicationContext);
+        }
+        return mApplicationContext != null ? mApplicationContext : JCoreStorage.getAppContext(context);
+    }
+
+    public static Context getAppContext() {
+        return getAppContext(null);
+    }
+
+    public static boolean isTestEnv() {
+        return false;
+    }
+
+    public static void setTestEnv(boolean testEnv) {
+    }
+
+    public static boolean isAndroidQ(Context context, boolean checkTargetSdk, String caller) {
+        return true;
+    }
+}

package/android/src/main/java/cn/jiguang/internal/JCoreHelperAction.java

@@ -0,0 +1,12 @@
+package cn.jiguang.internal;
+
+import android.content.Context;
+import android.os.Bundle;
+
+public abstract class JCoreHelperAction {
+    public abstract Object onEvent(Context context, String sdkType, int cmd, String action, Bundle bundle, Object... extras);
+
+    public abstract Bundle directHandle(Context context, String sdkType, String action, Bundle bundle);
+
+    public abstract Object onCommonMethod(Context context, String action, Object arg);
+}

package/android/src/main/java/cn/jiguang/internal/JCoreInternalHelper.java

@@ -0,0 +1,102 @@
+package cn.jiguang.internal;
+
+import android.content.Context;
+import android.os.Bundle;
+import cn.jiguang.core.JCoreStorage;
+import cn.jiguang.core.JCoreTcpEngine;
+
+public class JCoreInternalHelper {
+    private static volatile JCoreInternalHelper instance;
+    private volatile JCoreHelperAction helperAction;
+
+    private JCoreInternalHelper() {
+    }
+
+    public static JCoreInternalHelper getInstance() {
+        if (instance == null) {
+            synchronized (JCoreInternalHelper.class) {
+                if (instance == null) {
+                    instance = new JCoreInternalHelper();
+                }
+            }
+        }
+        return instance;
+    }
+
+    public void setHelperAction(JCoreHelperAction action) {
+        this.helperAction = action;
+    }
+
+    public Object onEvent(Context context, String sdkType, int cmd, String action, Bundle bundle, Object... extras) {
+        return onEvent(context, sdkType, cmd, true, action, bundle, extras);
+    }
+
+    public Object onEvent(
+        final Context context,
+        final String sdkType,
+        final int cmd,
+        boolean async,
+        final String action,
+        final Bundle bundle,
+        final Object... extras
+    ) {
+        JConstants.getAppContext(context);
+        JCoreHelperAction custom = this.helperAction;
+        if (custom != null) {
+            return custom.onEvent(context, sdkType, cmd, action, bundle, extras);
+        }
+        Bundle result = JCoreTcpEngine.getInstance().handleEvent(context, sdkType, cmd, action, bundle, extras);
+        if (result != null && result.containsKey("result")) {
+            return result.get("result");
+        }
+        return result;
+    }
+
+    public Bundle directHandle(Context context, String sdkType, String action, Bundle bundle) {
+        Context app = JConstants.getAppContext(context);
+        JCoreHelperAction custom = this.helperAction;
+        if (custom != null) {
+            return custom.directHandle(app, sdkType, action, bundle);
+        }
+        Bundle out = new Bundle();
+        out.putString("sdk_type", sdkType != null ? sdkType : "");
+        out.putString("action", action != null ? action : "");
+        if ("get_reg_id".equals(action)) {
+            out.putString("reg_id", JCoreStorage.getRegistrationId(app));
+        } else if ("sp_set".equals(action) && bundle != null) {
+            String key = bundle.getString("key");
+            if (key != null && !key.isEmpty()) {
+                JCoreStorage.putSpValue(app, key, bundle.getString("value", ""));
+                out.putBoolean("success", true);
+            } else {
+                for (String k : bundle.keySet()) {
+                    Object v = bundle.get(k);
+                    if (v != null) {
+                        JCoreStorage.putSpValue(app, k, String.valueOf(v));
+                    }
+                }
+                out.putBoolean("success", true);
+            }
+        } else if ("sp_get".equals(action) && bundle != null) {
+            String key = bundle.getString("key");
+            String defVal = bundle.getString("default", "");
+            out.putString("value", JCoreStorage.getSpValue(app, key, defVal));
+        } else if ("get_uid".equals(action)) {
+            out.putLong("uid", JCoreStorage.getUid(app));
+        }
+        return out;
+    }
+
+    public Object commonMethod(Context context, String action, Object arg) {
+        JConstants.getAppContext(context);
+        JCoreHelperAction custom = this.helperAction;
+        if (custom != null) {
+            return custom.onCommonMethod(context, action, arg);
+        }
+        return null;
+    }
+
+    public synchronized void initLoad(Context context) {
+        JConstants.getAppContext(context);
+    }
+}

package/android/src/main/java/cn/jiguang/net/DefaultHostVerifier.java

@@ -0,0 +1,40 @@
+package cn.jiguang.net;
+
+import java.security.cert.Certificate;
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.HttpsURLConnection;
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.SSLSession;
+
+public class DefaultHostVerifier implements HostnameVerifier {
+    public String expectedHost;
+
+    public DefaultHostVerifier(String expectedHost) {
+        this.expectedHost = expectedHost;
+    }
+
+    @Override
+    public boolean verify(String hostname, SSLSession session) {
+        if (hostname == null || hostname.isEmpty() || session == null) {
+            return false;
+        }
+        String targetHost = (this.expectedHost != null && !this.expectedHost.isEmpty())
+            ? this.expectedHost
+            : hostname;
+        if (!targetHost.equalsIgnoreCase(hostname)) {
+            return false;
+        }
+        try {
+            Certificate[] peerCertificates = session.getPeerCertificates();
+            if (peerCertificates == null || peerCertificates.length == 0) {
+                return false;
+            }
+        } catch (SSLPeerUnverifiedException e) {
+            return false;
+        } catch (Throwable ignored) {
+            return false;
+        }
+        HostnameVerifier defaultVerifier = HttpsURLConnection.getDefaultHostnameVerifier();
+        return defaultVerifier != null && defaultVerifier != this && defaultVerifier.verify(targetHost, session);
+    }
+}

package/android/src/main/java/cn/jiguang/net/HttpRequest.java

@@ -0,0 +1,78 @@
+package cn.jiguang.net;
+
+import java.util.HashMap;
+import java.util.Map;
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLSocketFactory;
+
+public class HttpRequest {
+    private String url;
+    private int connectTimeout = 10000;
+    private int readTimeout = 10000;
+    private Map<String, String> requestProperties = new HashMap<String, String>();
+    private Object body;
+    private SSLSocketFactory sslSocketFactory;
+    private HostnameVerifier hostnameVerifier;
+
+    public HttpRequest(String url) {
+        this.url = url;
+    }
+
+    public String getUrl() {
+        return url;
+    }
+
+    public void setUrl(String url) {
+        this.url = url;
+    }
+
+    public int getConnectTimeout() {
+        return connectTimeout;
+    }
+
+    public void setConnectTimeout(int connectTimeout) {
+        this.connectTimeout = connectTimeout;
+    }
+
+    public int getReadTimeout() {
+        return readTimeout;
+    }
+
+    public void setReadTimeout(int readTimeout) {
+        this.readTimeout = readTimeout;
+    }
+
+    public Map<String, String> getRequestProperties() {
+        return requestProperties;
+    }
+
+    public void setRequestProperty(String key, String value) {
+        if (key != null && value != null) {
+            requestProperties.put(key, value);
+        }
+    }
+
+    public Object getBody() {
+        return body;
+    }
+
+    public void setBody(Object body) {
+        this.body = body;
+    }
+
+    public SSLSocketFactory getSslSocketFactory() {
+        return sslSocketFactory;
+    }
+
+    public void setSslSocketFactory(SSLSocketFactory sslSocketFactory) {
+        this.sslSocketFactory = sslSocketFactory;
+    }
+
+    public HostnameVerifier getHostnameVerifier() {
+        return hostnameVerifier;
+    }
+
+    public void setHostnameVerifier(HostnameVerifier hostnameVerifier) {
+        this.hostnameVerifier = hostnameVerifier;
+    }
+}

package/android/src/main/java/cn/jiguang/net/HttpResponse.java

@@ -0,0 +1,48 @@
+package cn.jiguang.net;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class HttpResponse {
+    private String url;
+    private String responseBody;
+    private int responseCode = -1;
+    private Map<String, Object> responseHeaders = new HashMap<String, Object>();
+
+    public HttpResponse() {
+    }
+
+    public HttpResponse(String url) {
+        this.url = url;
+    }
+
+    public String getUrl() {
+        return url;
+    }
+
+    public void setUrl(String url) {
+        this.url = url;
+    }
+
+    public String getResponseBody() {
+        return responseBody;
+    }
+
+    public void setResponseBody(String responseBody) {
+        this.responseBody = responseBody;
+    }
+
+    public int getResponseCode() {
+        return responseCode;
+    }
+
+    public void setResponseCode(int responseCode) {
+        this.responseCode = responseCode;
+    }
+
+    public void setResponseHeader(String key, String value) {
+        if (key != null) {
+            responseHeaders.put(key, value);
+        }
+    }
+}

package/android/src/main/java/cn/jiguang/net/HttpUtils.java

@@ -0,0 +1,106 @@
+package cn.jiguang.net;
+
+import android.content.Context;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+import javax.net.ssl.HttpsURLConnection;
+
+public class HttpUtils {
+    public static HttpResponse httpGet(Context context, String url) {
+        return httpGet(context, new HttpRequest(url));
+    }
+
+    public static HttpResponse httpGet(Context context, HttpRequest request) {
+        return execute(context, request, false);
+    }
+
+    public static HttpResponse httpPost(Context context, String url, String body) {
+        HttpRequest req = new HttpRequest(url);
+        req.setBody(body);
+        return httpPost(context, req);
+    }
+
+    public static HttpResponse httpPost(Context context, HttpRequest request) {
+        return execute(context, request, true);
+    }
+
+    private static HttpResponse execute(Context context, HttpRequest request, boolean isPost) {
+        HttpResponse response = new HttpResponse(request != null ? request.getUrl() : "");
+        if (request == null || request.getUrl() == null) {
+            return response;
+        }
+        HttpURLConnection conn = null;
+        InputStream in = null;
+        OutputStream out = null;
+        try {
+            URL url = new URL(request.getUrl());
+            conn = (HttpURLConnection) url.openConnection();
+            conn.setConnectTimeout(request.getConnectTimeout());
+            conn.setReadTimeout(request.getReadTimeout());
+            if (conn instanceof HttpsURLConnection) {
+                HttpsURLConnection https = (HttpsURLConnection) conn;
+                if (request.getSslSocketFactory() != null) {
+                    https.setSSLSocketFactory(request.getSslSocketFactory());
+                }
+                https.setHostnameVerifier(
+                    request.getHostnameVerifier() != null
+                        ? request.getHostnameVerifier()
+                        : new DefaultHostVerifier(url.getHost())
+                );
+            }
+            for (Map.Entry<String, String> entry : request.getRequestProperties().entrySet()) {
+                conn.setRequestProperty(entry.getKey(), entry.getValue());
+            }
+            if (isPost) {
+                conn.setRequestMethod("POST");
+                conn.setDoOutput(true);
+                Object body = request.getBody();
+                byte[] bytes = null;
+                if (body instanceof byte[]) {
+                    bytes = (byte[]) body;
+                } else if (body instanceof String) {
+                    bytes = ((String) body).getBytes(StandardCharsets.UTF_8);
+                }
+                if (bytes != null) {
+                    out = conn.getOutputStream();
+                    out.write(bytes);
+                    out.flush();
+                }
+            } else {
+                conn.setRequestMethod("GET");
+            }
+            int code = conn.getResponseCode();
+            response.setResponseCode(code);
+            in = code >= 400 ? conn.getErrorStream() : conn.getInputStream();
+            if (in != null) {
+                ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+                byte[] chunk = new byte[2048];
+                int read;
+                while ((read = in.read(chunk)) != -1) {
+                    buffer.write(chunk, 0, read);
+                }
+                response.setResponseBody(new String(buffer.toByteArray(), StandardCharsets.UTF_8));
+            }
+        } catch (Throwable ignored) {
+        } finally {
+            try {
+                if (out != null) {
+                    out.close();
+                }
+                if (in != null) {
+                    in.close();
+                }
+                if (conn != null) {
+                    conn.disconnect();
+                }
+            } catch (Throwable ignored) {
+            }
+        }
+        return response;
+    }
+}

package/android/src/main/java/cn/jiguang/plugins/core/JCoreModule.java

@@ -0,0 +1,91 @@
+
+package cn.jiguang.plugins.core;
+
+import android.app.Activity;
+import android.app.Application;
+import android.os.Bundle;
+import android.text.TextUtils;
+import android.util.Log;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+
+import org.json.JSONObject;
+
+import java.util.HashSet;
+import java.util.Set;
+import cn.jiguang.api.utils.JCollectionAuth;
+import cn.jiguang.api.JCoreInterface;
+import cn.jiguang.plugins.push.JPushModule;
+
+public class JCoreModule extends ReactContextBaseJavaModule {
+
+    public static ReactApplicationContext reactContext;
+
+
+    public JCoreModule(ReactApplicationContext reactApplicationContext) {
+        super(reactApplicationContext);
+        reactContext = reactApplicationContext;
+        JPushModule.registerReactContext(reactApplicationContext);
+    }
+
+    @Override
+    public String getName() {
+        return "JCoreModule";
+    }
+
+    @ReactMethod
+    public void setAuth(boolean bool){
+        JCollectionAuth.setAuth(reactContext,bool);
+    }
+    @ReactMethod
+    public void enableAutoWakeup(boolean bool) {
+        JCollectionAuth.enableAutoWakeup(reactContext,bool);
+    }
+    @ReactMethod
+    public void setCountryCode(ReadableMap readableMap){
+        if (readableMap == null) {
+            return;
+        }
+        String code = readableMap.getString("code");
+        if (TextUtils.isEmpty(code)) {
+        } else {
+            JCoreInterface.setCountryCode(reactContext,code);
+        }
+    }
+
+    @ReactMethod
+    public void enableSDKLocalLog(ReadableMap readableMap){
+        if (readableMap == null) {
+            return;
+        }
+        boolean enable = false;
+        if (readableMap.hasKey("enable")) {
+            enable = readableMap.getBoolean("enable");
+        }
+        boolean uploadJgToServer = false;
+       if (readableMap.hasKey("uploadJgToServer")) {
+            uploadJgToServer = readableMap.getBoolean("uploadJgToServer");
+        }
+        JCoreInterface.enableSDKLocalLog(reactContext,enable,uploadJgToServer);
+    }
+
+    @ReactMethod
+    public void readNewLogs(Callback callback) {
+        if (callback == null) {
+            return;
+        }
+        String logs = JCoreInterface.readNewLogs(reactContext);
+        WritableMap writableMap = Arguments.createMap();
+        writableMap.putString("logs", logs);
+        callback.invoke(writableMap);
+    }
+
+
+}

package/android/src/main/java/cn/jiguang/plugins/core/JCorePackage.java

@@ -0,0 +1,27 @@
+
+package cn.jiguang.plugins.core;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import cn.jiguang.plugins.core.JCoreModule;
+
+public class JCorePackage implements ReactPackage {
+
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+        return Arrays.<NativeModule>asList(new JCoreModule(reactContext));
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+
+}