@onekeyfe/react-native-jpush 0.0.0-stage → 6.7.0-alpha.436

package/android/src/main/java/cn/jiguang/android/BuildConfig.java

@@ -0,0 +1,10 @@
+package cn.jiguang.android;
+
+public final class BuildConfig {
+    public static final boolean DEBUG = false;
+    public static final String APPLICATION_ID = "cn.jiguang.android";
+    public static final String BUILD_TYPE = "release";
+    public static final String FLAVOR = "";
+    public static final int VERSION_CODE = 520;
+    public static final String VERSION_NAME = "5.2.0";
+}

package/android/src/main/java/cn/jiguang/android/IDataShare.java

@@ -0,0 +1,190 @@
+package cn.jiguang.android;
+
+import android.os.Binder;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.os.IInterface;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.os.RemoteException;
+
+public interface IDataShare extends IInterface {
+    String DESCRIPTOR = "cn.jiguang.android.IDataShare";
+
+    IBinder getBinderByType(String sdkType, String action) throws RemoteException;
+
+    void onAction(String sdkType, String action, Bundle bundle) throws RemoteException;
+
+    Bundle execute(String sdkType, String action, Bundle bundle) throws RemoteException;
+
+    String bind(IDataShare dataShare, String processName) throws RemoteException;
+
+    abstract class Stub extends Binder implements IDataShare {
+        static final int TRANSACTION_getBinderByType = 1;
+        static final int TRANSACTION_onAction = 2;
+        static final int TRANSACTION_execute = 3;
+        static final int TRANSACTION_bind = 4;
+
+        public Stub() {
+            this.attachInterface(this, DESCRIPTOR);
+        }
+
+        public static IDataShare asInterface(IBinder obj) {
+            if (obj == null) {
+                return null;
+            }
+            IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
+            if (iin instanceof IDataShare) {
+                return (IDataShare) iin;
+            }
+            return new Proxy(obj);
+        }
+
+        @Override
+        public IBinder asBinder() {
+            return this;
+        }
+
+        @Override
+        public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
+            if (code == INTERFACE_TRANSACTION) {
+                reply.writeString(DESCRIPTOR);
+                return true;
+            }
+            switch (code) {
+                case TRANSACTION_getBinderByType: {
+                    data.enforceInterface(DESCRIPTOR);
+                    String sdkType = data.readString();
+                    String action = data.readString();
+                    IBinder result = this.getBinderByType(sdkType, action);
+                    reply.writeNoException();
+                    reply.writeStrongBinder(result);
+                    return true;
+                }
+                case TRANSACTION_onAction: {
+                    data.enforceInterface(DESCRIPTOR);
+                    String sdkType = data.readString();
+                    String action = data.readString();
+                    Bundle bundle = data.readInt() != 0 ? Bundle.CREATOR.createFromParcel(data) : null;
+                    this.onAction(sdkType, action, bundle);
+                    return true;
+                }
+                case TRANSACTION_execute: {
+                    data.enforceInterface(DESCRIPTOR);
+                    String sdkType = data.readString();
+                    String action = data.readString();
+                    Bundle bundle = data.readInt() != 0 ? Bundle.CREATOR.createFromParcel(data) : null;
+                    Bundle result = this.execute(sdkType, action, bundle);
+                    reply.writeNoException();
+                    if (result != null) {
+                        reply.writeInt(1);
+                        result.writeToParcel(reply, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
+                    } else {
+                        reply.writeInt(0);
+                    }
+                    return true;
+                }
+                case TRANSACTION_bind: {
+                    data.enforceInterface(DESCRIPTOR);
+                    IDataShare remote = asInterface(data.readStrongBinder());
+                    String processName = data.readString();
+                    String result = this.bind(remote, processName);
+                    reply.writeNoException();
+                    reply.writeString(result);
+                    return true;
+                }
+                default:
+                    return super.onTransact(code, data, reply, flags);
+            }
+        }
+
+        private static class Proxy implements IDataShare {
+            private final IBinder remote;
+
+            Proxy(IBinder remote) {
+                this.remote = remote;
+            }
+
+            @Override
+            public IBinder asBinder() {
+                return remote;
+            }
+
+            @Override
+            public IBinder getBinderByType(String sdkType, String action) throws RemoteException {
+                Parcel data = Parcel.obtain();
+                Parcel reply = Parcel.obtain();
+                try {
+                    data.writeInterfaceToken(DESCRIPTOR);
+                    data.writeString(sdkType);
+                    data.writeString(action);
+                    remote.transact(TRANSACTION_getBinderByType, data, reply, 0);
+                    reply.readException();
+                    return reply.readStrongBinder();
+                } finally {
+                    reply.recycle();
+                    data.recycle();
+                }
+            }
+
+            @Override
+            public void onAction(String sdkType, String action, Bundle bundle) throws RemoteException {
+                Parcel data = Parcel.obtain();
+                try {
+                    data.writeInterfaceToken(DESCRIPTOR);
+                    data.writeString(sdkType);
+                    data.writeString(action);
+                    if (bundle != null) {
+                        data.writeInt(1);
+                        bundle.writeToParcel(data, 0);
+                    } else {
+                        data.writeInt(0);
+                    }
+                    remote.transact(TRANSACTION_onAction, data, null, IBinder.FLAG_ONEWAY);
+                } finally {
+                    data.recycle();
+                }
+            }
+
+            @Override
+            public Bundle execute(String sdkType, String action, Bundle bundle) throws RemoteException {
+                Parcel data = Parcel.obtain();
+                Parcel reply = Parcel.obtain();
+                try {
+                    data.writeInterfaceToken(DESCRIPTOR);
+                    data.writeString(sdkType);
+                    data.writeString(action);
+                    if (bundle != null) {
+                        data.writeInt(1);
+                        bundle.writeToParcel(data, 0);
+                    } else {
+                        data.writeInt(0);
+                    }
+                    remote.transact(TRANSACTION_execute, data, reply, 0);
+                    reply.readException();
+                    return reply.readInt() != 0 ? Bundle.CREATOR.createFromParcel(reply) : null;
+                } finally {
+                    reply.recycle();
+                    data.recycle();
+                }
+            }
+
+            @Override
+            public String bind(IDataShare dataShare, String processName) throws RemoteException {
+                Parcel data = Parcel.obtain();
+                Parcel reply = Parcel.obtain();
+                try {
+                    data.writeInterfaceToken(DESCRIPTOR);
+                    data.writeStrongBinder(dataShare != null ? dataShare.asBinder() : null);
+                    data.writeString(processName);
+                    remote.transact(TRANSACTION_bind, data, reply, 0);
+                    reply.readException();
+                    return reply.readString();
+                } finally {
+                    reply.recycle();
+                    data.recycle();
+                }
+            }
+        }
+    }
+}

package/android/src/main/java/cn/jiguang/api/BaseLogger.java

@@ -0,0 +1,82 @@
+package cn.jiguang.api;
+
+import android.util.Log;
+import cn.jiguang.core.JCoreStorage;
+import cn.jiguang.plugins.push.common.JLogger;
+
+public abstract class BaseLogger {
+    public abstract String getCommonTag();
+
+    private void log(int priority, boolean force, String tag, String msg, Throwable tr) {
+        if (!force && !JCoreStorage.isDebugMode() && !JLogger.isLoggerEnable()) {
+            return;
+        }
+        String fullTag = "[" + getCommonTag() + "]" + (tag != null ? tag : "");
+        String body = msg != null ? msg : "";
+        if (tr != null) {
+            body = body + '\n' + Log.getStackTraceString(tr);
+        }
+        String combined = fullTag + " " + body;
+        if (priority >= Log.ERROR) {
+            JLogger.e(combined);
+        } else if (priority == Log.WARN) {
+            JLogger.w(combined);
+        } else if (priority == Log.INFO) {
+            JLogger.i(combined);
+        } else {
+            JLogger.d(combined);
+        }
+    }
+
+    public void v(String tag, String msg) {
+        log(Log.VERBOSE, false, tag, msg, null);
+    }
+
+    public void vv(String tag, String msg) {
+        log(Log.VERBOSE, true, tag, msg, null);
+    }
+
+    public void d(String tag, String msg) {
+        log(Log.DEBUG, false, tag, msg, null);
+    }
+
+    public void dd(String tag, String msg) {
+        log(Log.DEBUG, true, tag, msg, null);
+    }
+
+    public void i(String tag, String msg) {
+        log(Log.INFO, false, tag, msg, null);
+    }
+
+    public void ii(String tag, String msg) {
+        log(Log.INFO, true, tag, msg, null);
+    }
+
+    public void w(String tag, String msg) {
+        log(Log.WARN, false, tag, msg, null);
+    }
+
+    public void ww(String tag, String msg) {
+        log(Log.WARN, true, tag, msg, null);
+    }
+
+    public void ww(String tag, String msg, Throwable tr) {
+        log(Log.WARN, true, tag, msg, tr);
+    }
+
+    public void e(String tag, String msg) {
+        log(Log.ERROR, false, tag, msg, null);
+    }
+
+    public void ee(String tag, String msg) {
+        log(Log.ERROR, true, tag, msg, null);
+    }
+
+    public void e(String tag, String msg, Throwable tr) {
+        log(Log.ERROR, false, tag, msg, tr);
+    }
+
+    public void ee(String tag, String msg, Throwable tr) {
+        log(Log.ERROR, true, tag, msg, tr);
+    }
+}

package/android/src/main/java/cn/jiguang/api/JAction.java

@@ -0,0 +1,22 @@
+package cn.jiguang.api;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.os.IBinder;
+import java.nio.ByteBuffer;
+
+public interface JAction {
+    long dispatchMessage(Context context, long connectionId, int command, Object header, ByteBuffer body);
+
+    void dispatchTimeOutMessage(Context context, long connectionId, long rid, int command);
+
+    boolean isSupportedCMD(int command);
+
+    void onActionRun(Context context, long rid, Bundle bundle, Object handler);
+
+    void onEvent(Context context, long rid, int eventType);
+
+    IBinder getBinderByType(String type);
+
+    String getSdkVersion();
+}

package/android/src/main/java/cn/jiguang/api/JActionExtra.java

@@ -0,0 +1,21 @@
+package cn.jiguang.api;
+
+import android.content.Context;
+
+public abstract class JActionExtra {
+    public Object beforRegister(Context context, int cmd, String extra) {
+        return null;
+    }
+
+    public Object beforLogin(Context context, int cmd, String extra) {
+        return null;
+    }
+
+    public boolean checkAction(int actionType) {
+        return true;
+    }
+
+    public Object onSendData(Context context, long connId, long rid, int cmd, int ver) {
+        return null;
+    }
+}

package/android/src/main/java/cn/jiguang/api/JAnalyticsAction.java

@@ -0,0 +1,11 @@
+package cn.jiguang.api;
+
+import android.content.Context;
+
+public interface JAnalyticsAction {
+    void dispatchResume(Context context);
+
+    void dispatchPause(Context context);
+
+    void dispatchStatus(Context context, String status);
+}

package/android/src/main/java/cn/jiguang/api/JCoreInterface.java

@@ -0,0 +1,228 @@
+package cn.jiguang.api;
+
+import android.content.Context;
+import android.os.Bundle;
+import cn.jiguang.core.JCoreStorage;
+import cn.jiguang.core.JCoreTcpEngine;
+import cn.jiguang.internal.ActionManager;
+import org.json.JSONObject;
+
+public class JCoreInterface {
+    public static String DAEMON_ACTION = "cn.jpush.android.intent.DaemonService";
+    private static Context mApplicationContext;
+
+    public static void initAction(String sdkType, Class<?> actionClass) {
+        if (actionClass != null) {
+            ActionManager.addAction(sdkType, actionClass.getName());
+        }
+    }
+
+    public static void initActionExtra(String sdkType, Class<?> actionExtraClass) {
+        if (actionExtraClass != null) {
+            ActionManager.addAction(sdkType, actionExtraClass.getName());
+        }
+    }
+
+    public static boolean init(Context context, boolean force) {
+        if (context != null) {
+            try {
+                Context app = context.getApplicationContext();
+                mApplicationContext = app != null ? app : context;
+            } catch (Throwable ignored) {
+                mApplicationContext = context;
+            }
+        }
+        JCoreManager.init(context);
+        return true;
+    }
+
+    public static void register(Context context) {
+        init(context, false);
+    }
+
+    public static void sendData(Context context, String sdkType, int version, byte[] data) {
+        JCoreManager.onEvent(context, sdkType, 50, null, null, data);
+    }
+
+    public static void sendRequestData(Context context, String sdkType, int timeout, byte[] data) {
+        JCoreManager.onEvent(context, sdkType, 17, null, null, data);
+    }
+
+    public static void sendAction(Context context, String sdkType, Bundle bundle) {
+        if (bundle != null) {
+            JCoreManager.onEvent(context, sdkType, 3, bundle.getString("action"), bundle);
+        }
+    }
+
+    public static void stop(Context context, String sdkType, Bundle bundle) {
+        JCoreStorage.setPushStopped(context, true);
+        JCoreTcpEngine.getInstance().stop(context);
+    }
+
+    public static void restart(Context context, String sdkType, Bundle bundle, boolean force) {
+        JCoreStorage.setPushStopped(context, false);
+        if (force) {
+            JCoreTcpEngine.getInstance().triggerReconnectNow(context);
+        } else {
+            JCoreTcpEngine.getInstance().start(context);
+        }
+    }
+
+    public static String getDeviceId(Context context) {
+        return JCoreStorage.getDeviceId(context);
+    }
+
+    public static boolean canCallDirect() {
+        return true;
+    }
+
+    public static void setDebugMode(boolean enable) {
+        JCoreManager.setDebugMode(enable);
+    }
+
+    public static boolean getDebugMode() {
+        return JCoreManager.getDebugMode();
+    }
+
+    public static void execute(String name, Runnable task, int... flags) {
+        JCoreTcpEngine.getInstance().executeAsync(task);
+    }
+
+    public static void asyncExecute(Runnable task, int... flags) {
+        JCoreTcpEngine.getInstance().executeAsync(task);
+    }
+
+    public static void putSingleExecutor(String name) {
+    }
+
+    public static void setAnalysisAction(JAnalyticsAction action) {
+        JCoreManager.setAnalysisAction(action);
+    }
+
+    public static String getRegistrationID(Context context) {
+        return JCoreStorage.getRegistrationId(context != null ? context : mApplicationContext);
+    }
+
+    public static boolean isValidRegistered() {
+        return !getRegistrationID(mApplicationContext).isEmpty();
+    }
+
+    public static String getAppKey() {
+        return JCoreStorage.getAppKey(mApplicationContext);
+    }
+
+    public static long getReportTime() {
+        return System.currentTimeMillis() / 1000L;
+    }
+
+    public static long getUid() {
+        return JCoreStorage.getUid(mApplicationContext);
+    }
+
+    public static int getSid() {
+        return JCoreTcpEngine.getInstance().getSessionId();
+    }
+
+    public static long getNextRid() {
+        return JCoreStorage.nextRid();
+    }
+
+    public static boolean isTcpConnected() {
+        return JCoreStorage.isConnected(mApplicationContext);
+    }
+
+    public static boolean getConnectionState(Context context) {
+        return JCoreStorage.isConnected(context != null ? context : mApplicationContext);
+    }
+
+    public static String getChannel() {
+        return JCoreStorage.getChannel(mApplicationContext);
+    }
+
+    public static boolean reportHttpData(Context context, Object data, String sdkType) {
+        return true;
+    }
+
+    public static boolean report(Context context, JSONObject data, boolean checkAuth) {
+        return true;
+    }
+
+    public static String getHttpConfig(Context context, String key) {
+        return "";
+    }
+
+    public static boolean getRuningFlag() {
+        return false;
+    }
+
+    @Deprecated
+    public static void setImLBSEnable(Context context, boolean enable) {
+    }
+
+    public static void setWakeEnable(Context context, boolean enable) {
+    }
+
+    public static void onResume(Context context) {
+    }
+
+    public static void onPause(Context context) {
+    }
+
+    public static void onFragmentResume(Context context, String fragmentName) {
+    }
+
+    public static void onFragmentPause(Context context, String fragmentName) {
+    }
+
+    public static void onKillProcess(Context context) {
+    }
+
+    public static void initCrashHandler(Context context) {
+    }
+
+    public static void stopCrashHandler(Context context) {
+    }
+
+    public static void requestPermission(Context context) {
+        JCoreManager.requestPermission(context);
+    }
+
+    public static void setCanLaunchedStoppedService(boolean enabled) {
+    }
+
+    public static void setTestConn(boolean testConn) {
+        JCoreTcpEngine.getInstance().setTestConnectionEnabled(testConn);
+    }
+
+    public static void setTestConnIPPort(String ip, int port) {
+        JCoreTcpEngine.getInstance().setCustomEndpoint(ip, port);
+    }
+
+    public static void setPowerSaveMode(Context context, boolean enable) {
+    }
+
+    public static void setHeartbeatInterval(Context context, int intervalSeconds) {
+        if (intervalSeconds > 0) {
+            long clampedSeconds = Math.max(30L, Math.min(290L, (long) intervalSeconds));
+            JCoreTcpEngine.getInstance().setHeartbeatIntervalMs(clampedSeconds * 1000L);
+        }
+    }
+
+    public static void enableAutoWakeup(Context context, boolean enable) {
+    }
+
+    public static void setCountryCode(Context context, String countryCode) {
+        JCoreStorage.setCountryCode(context, countryCode);
+    }
+
+    public static void enableSDKLocalLog(Context context, boolean enable, boolean uploadJgToServer) {
+        JCoreStorage.enableSDKLocalLog(context, enable, uploadJgToServer);
+    }
+
+    public static String readNewLogs(Context context) {
+        return JCoreStorage.readNewLogs(context);
+    }
+
+    public static void triggerSceneCheck(Context context, int scene) {
+    }
+}