react-native-quicktracking-analytics-module 1.0.4 → 2.0.2

package/android/build.gradle

@@ -134,7 +134,7 @@ dependencies {
 //  implementation fileTree(include:['*.jar'], dir:'libs')
   implementation "com.facebook.react:react-native:+"
   //友盟基础库
-  implementation "com.umeng.umsdk:qt-px-common:1.4.0.PX"
+  implementation "com.lydaas.qtsdk:qt-px-common:1.8.3.PX"
 }
 
 if (isNewArchitectureEnabled()) {

package/android/src/main/java/com/reactnativequicktrackinganalyticsmodule/QTSDKManager.java

@@ -0,0 +1,93 @@
+package com.reactnativequicktrackinganalyticsmodule;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.uimanager.JSTouchDispatcher;
+import com.facebook.react.uimanager.events.EventDispatcher;
+import com.quick.qt.analytics.QtTrackAgent;
+
+import java.lang.reflect.Field;
+import java.util.Map;
+import java.util.WeakHashMap;
+import android.util.SparseArray;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.reactnativequicktrackinganalyticsmodule.property.QTViewProperties;
+import com.reactnativequicktrackinganalyticsmodule.utils.*;
+import org.json.JSONObject;
+
+public class QTSDKManager {
+  public static final WeakHashMap jsTouchDispatcherViewGroupWeakHashMap = new WeakHashMap();
+  private static SparseArray<QTViewProperties> viewPropertiesArray = new SparseArray<>();
+
+  public static void handleTouchEvent(JSTouchDispatcher jsTouchDispatcher, MotionEvent event, EventDispatcher eventDispatcher) {
+    try {
+      if (event.getAction() == MotionEvent.ACTION_DOWN) {
+        ViewGroup viewGroup = (ViewGroup) jsTouchDispatcherViewGroupWeakHashMap.get(jsTouchDispatcher);
+        if (viewGroup == null) {
+          try {
+            Field viewGroupField = jsTouchDispatcher.getClass().getDeclaredField("mRootViewGroup");
+            viewGroupField.setAccessible(true);
+            viewGroup = (ViewGroup) viewGroupField.get(jsTouchDispatcher);
+            jsTouchDispatcherViewGroupWeakHashMap.put(jsTouchDispatcher, viewGroup);
+          } catch (Exception e) {
+            QTLog.printStackTrace(e);
+          }
+        } else {
+          View nativeTargetView = RNTouchTargetHelper.findTouchTargetView(new float[]{event.getX(), event.getY()}, viewGroup);
+          if (nativeTargetView != null) {
+            View reactTargetView = RNTouchTargetHelper.findClosestReactAncestor(nativeTargetView);
+            if (reactTargetView != null) {
+              nativeTargetView = reactTargetView;
+            }
+            RNViewUtils.setOnTouchView(nativeTargetView);
+          }
+        }
+      }
+    } catch (Exception ignored) {
+
+    }
+  }
+
+  static void trackViewClick(int viewId, ReactApplicationContext ctx) {
+    try {
+      View clickView = RNViewUtils.getViewByTag(viewId);
+      QTLog.t("current clickView ===" + clickView);
+      if (clickView != null) {
+        JSONObject properties = new JSONObject();
+        if (RNViewUtils.getTitle() != null) {
+          properties.put("title", RNViewUtils.getTitle());
+        }
+        if (RNViewUtils.getScreenName() != null) {
+          properties.put("$screen_name", RNViewUtils.getScreenName());
+        }
+        QTViewProperties viewProperties = viewPropertiesArray.get(viewId);
+        if (viewProperties != null && viewProperties.properties != null && viewProperties.properties.length() > 0) {
+          //TODO: ignore 这个字段名是否需要重构
+          if (viewProperties.properties.optBoolean("ignore", false)) {
+            return;
+          }
+          viewProperties.properties.remove("ignore");
+          RNUtils.mergeJSONObject(viewProperties.properties, properties);
+        }
+        String eventID = RNUtils.MD5(Integer.toString(viewId));
+        JSONObject mergedProperties = RNPropertyManager.mergeProperty(properties, true);
+        Map<String, Object> map = RNUtils.convertToMap(mergedProperties);
+        QtTrackAgent.onEventObject(ctx, eventID, map);
+      }
+    } catch (Exception e) {
+      QTLog.printStackTrace(e);
+    }
+  }
+
+  static void saveViewProperties(int viewTag, boolean clickable, ReadableMap viewProperties) {
+    QTLog.t("currentView Tag ===" + viewTag);
+    QTLog.t("currentView clickable ===" + clickable);
+    if (clickable) {
+      QTLog.t("before invoke viewPropertiesArray");
+      viewPropertiesArray.put(viewTag, new QTViewProperties(clickable, viewProperties));
+    }
+  }
+}

package/android/src/main/java/com/reactnativequicktrackinganalyticsmodule/{QuicktrackingAnalyticsModuleModule.java → QuicktrackingAnalyticsModule.java}

@@ -2,39 +2,40 @@ package com.reactnativequicktrackinganalyticsmodule;
 
 import androidx.annotation.NonNull;
 
-import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
-import org.json.JSONObject;
-import org.json.JSONException;
 import java.util.Iterator;
 
-import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.Promise;
 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.ReadableMapKeySetIterator;
 import com.facebook.react.bridge.ReadableNativeMap;
 import com.facebook.react.bridge.ReadableType;
 import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.bridge.LifecycleEventListener;
 
 import com.quick.qt.analytics.QtTrackAgent;
 import com.quick.qt.commonsdk.QtConfigure;
 import com.quick.qt.spm.SpmAgent;
+import com.reactnativequicktrackinganalyticsmodule.utils.*;
 
-@ReactModule(name = QuicktrackingAnalyticsModuleModule.NAME)
-public class QuicktrackingAnalyticsModuleModule extends ReactContextBaseJavaModule {
+@ReactModule(name = QuicktrackingAnalyticsModule.NAME)
+public class QuicktrackingAnalyticsModule extends ReactContextBaseJavaModule {
     public static final String NAME = "QuicktrackingAnalyticsModule";
     public static final String TAG = "QuickTracking == ";
     private ReactApplicationContext context;
 
-    public QuicktrackingAnalyticsModuleModule(ReactApplicationContext reactContext) {
+    public QuicktrackingAnalyticsModule(ReactApplicationContext reactContext) {
         super(reactContext);
         context = reactContext;
+        try {
+          reactContext.addLifecycleEventListener(new QTDataLifecycleListener());
+        } catch (Exception e) {
+
+        }
     }
 
     @Override
@@ -45,13 +46,11 @@ public class QuicktrackingAnalyticsModuleModule extends ReactContextBaseJavaModu
 
     @ReactMethod
     public void onPageStart(String pageName) {
-      // android.util.Log.e("xxxxxx","onPageStart="+mPageName);
       QtTrackAgent.onPageStart(pageName);
     }
 
     @ReactMethod
     public void onPageEnd(String pageName) {
-      //android.util.Log.e("xxxxxx","onPageEnd="+mPageName);
       QtTrackAgent.onPageEnd(pageName);
     }
 
@@ -131,13 +130,17 @@ public class QuicktrackingAnalyticsModuleModule extends ReactContextBaseJavaModu
     @ReactMethod
     public void onEventForH5(String content) {
       try {
-        // android.util.Log.e(TAG, " " + content);
         SpmAgent.CALL(content);
       } catch (Exception e) {
         android.util.Log.e(TAG, "桥接事件发送失败！", e);
       }
     }
 
+    @ReactMethod
+    public void onEventAutoCLK(int viewId) {
+        QTSDKManager.trackViewClick(viewId, context);
+    }
+
     @ReactMethod
     public  void registerGlobalProperties(ReadableMap map) throws Exception {
       try {
@@ -216,4 +219,24 @@ public class QuicktrackingAnalyticsModuleModule extends ReactContextBaseJavaModu
     public void initWithAppkey(String AppKey, String Channel) {
         QtConfigure.init(context, AppKey, Channel, QtConfigure.DEVICE_TYPE_PHONE, "");
     }
+
+    @ReactMethod
+    public void saveViewProperties(int viewId, boolean clickable, ReadableMap viewProperties) {
+        QTSDKManager.saveViewProperties(viewId, clickable, viewProperties);
+    }
+
+
+    class QTDataLifecycleListener implements LifecycleEventListener {
+      public void onHostResume() {
+        RNViewUtils.onActivityResumed(getCurrentActivity());
+      }
+
+      public void onHostPause() {
+        RNViewUtils.onActivityPaused();
+      }
+
+      public void onHostDestroy() {
+
+      }
+    }
 }

package/android/src/main/java/com/reactnativequicktrackinganalyticsmodule/QuicktrackingAnalyticsModulePackage.java

@@ -16,7 +16,7 @@ public class QuicktrackingAnalyticsModulePackage implements ReactPackage {
     @Override
     public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
         List<NativeModule> modules = new ArrayList<>();
-        modules.add(new QuicktrackingAnalyticsModuleModule(reactContext));
+        modules.add(new QuicktrackingAnalyticsModule(reactContext));
         return modules;
     }
 

package/android/src/main/java/com/reactnativequicktrackinganalyticsmodule/property/QTViewProperties.java

@@ -0,0 +1,48 @@
+
+package com.reactnativequicktrackinganalyticsmodule.property;
+import com.reactnativequicktrackinganalyticsmodule.utils.RNUtils;
+import com.facebook.react.bridge.ReadableMap;
+import org.json.JSONObject;
+
+import android.content.Context;
+import android.view.View;
+import android.widget.ScrollView;
+
+
+public class QTViewProperties {
+  public static final String TAG = "QuickTracking == ";
+  private boolean clickable;
+  public JSONObject properties;
+  private int viewTagKey = 0;
+
+  public QTViewProperties(boolean clickable, ReadableMap params) {
+    this.clickable = clickable;
+    this.properties = RNUtils.convertToJSONObject(params);
+  }
+
+  public void setViewClickable(View view) {
+    try {
+      if (view != null && !(view instanceof ScrollView)) {
+        view.setClickable(clickable);
+      }
+    } catch (Exception e) {
+      android.util.Log.e(TAG, e.getMessage());
+    }
+  }
+
+  public void setViewTag(View view) {
+    try {
+      if (view != null) {
+        if (viewTagKey == 0) {
+          Context context = view.getContext();
+          viewTagKey = context.getResources().getIdentifier("qt_rn_tag_view_rn_key", "id", context.getPackageName());
+        }
+        if (viewTagKey != 0) {
+          view.setTag(viewTagKey, true);
+        }
+      }
+    } catch (Exception e) {
+      android.util.Log.e(TAG, "设置viewTag 失败！" + e.getMessage());
+    }
+  }
+}

package/android/src/main/java/com/reactnativequicktrackinganalyticsmodule/utils/QTLog.java

@@ -0,0 +1,122 @@
+package com.reactnativequicktrackinganalyticsmodule.utils;
+
+import android.util.Log;
+
+public class QTLog {
+  private static boolean debug;
+  private static boolean enableLog;
+  private static boolean disableSDK;
+  private static final int CHUNK_SIZE = 4000;
+
+  public static void d(String tag, String msg) {
+    if (debug && !disableSDK) {
+      info(tag, msg, null);
+    }
+  }
+
+  public static void t(String msg, Object... object) {
+    if (enableLog && !disableSDK) {
+      i("===TEST===", msg, object);
+    }
+  }
+
+  public static void d(String tag, String msg, Throwable tr) {
+    if (debug && !disableSDK) {
+      info(tag, msg, tr);
+    }
+  }
+
+  public static void i(String tag, String msg) {
+    if (enableLog && !disableSDK) {
+      info(tag, msg, null);
+    }
+  }
+
+  public static void i(String tag, Throwable tr) {
+    if (enableLog && !disableSDK) {
+      info(tag, "", tr);
+    }
+  }
+
+  public static void i(String tag, String msg, Throwable tr) {
+    if (enableLog && !disableSDK) {
+      info(tag, msg, tr);
+    }
+  }
+
+  public static void i(String tag, String msg, Object... object) {
+    if (enableLog && !disableSDK) {
+      info(tag, String.format(msg, object), null);
+    }
+  }
+
+  public static void info(String tag, String msg, Throwable tr) {
+    try {
+      if (msg != null) {
+        byte[] bytes = msg.getBytes();
+        int length = bytes.length;
+        if (length <= CHUNK_SIZE) {
+          Log.i(tag, msg, tr);
+        } else {
+          int index = 0, lastIndexOfLF = 0;
+          //当最后一次剩余值小于 CHUNK_SIZE 时，不需要再截断
+          while (index < length - CHUNK_SIZE) {
+            lastIndexOfLF = lastIndexOfLF(bytes, index);
+            int chunkLength = lastIndexOfLF - index;
+            Log.i(tag, new String(bytes, index, chunkLength), null);
+            if (chunkLength < CHUNK_SIZE) {
+              //跳过换行符
+              index = lastIndexOfLF + 1;
+            } else {
+              index = lastIndexOfLF;
+            }
+          }
+          if (length > index) {
+            Log.i(tag, new String(bytes, index, length - index), tr);
+          }
+        }
+      } else {
+        Log.i(tag, null, tr);
+      }
+    } catch (Exception e) {
+      printStackTrace(e);
+    }
+  }
+
+  private static int lastIndexOfLF(byte[] bytes, int fromIndex) {
+    int index = Math.min(fromIndex + CHUNK_SIZE, bytes.length - 1);
+    for (int i = index; i > index - CHUNK_SIZE; i--) {
+      //返回换行符的位置
+      if (bytes[i] == (byte) 10) {
+        return i;
+      }
+    }
+    return index;
+  }
+
+  public static void printStackTrace(Exception e) {
+    if (enableLog && !disableSDK && e != null) {
+      Log.e("QuickTracking Exception", "", e);
+    }
+  }
+
+  static void setDebug(boolean isDebug) {
+    debug = isDebug;
+  }
+
+  public static void setEnableLog(boolean isEnableLog) {
+    enableLog = isEnableLog;
+  }
+
+  public static void setDisableSDK(boolean configDisableSDK) {
+    disableSDK = configDisableSDK;
+  }
+
+  public static boolean isLogEnabled() {
+    return enableLog;
+  }
+
+  public static boolean isDebug() {
+    return debug;
+  }
+}

package/android/src/main/java/com/reactnativequicktrackinganalyticsmodule/utils/RNPropertyManager.java

@@ -0,0 +1,29 @@
+package com.reactnativequicktrackinganalyticsmodule.utils;
+
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class RNPropertyManager {
+  public static List<Interceptor> interceptors = new ArrayList<>();
+
+  public static void addInterceptor(Interceptor interceptor){
+    interceptors.add(interceptor);
+  }
+
+  public static JSONObject mergeProperty(JSONObject properties){
+    return mergeProperty(properties, false);
+  }
+
+  public static JSONObject mergeProperty(JSONObject properties, boolean isAuto){
+    for(Interceptor interceptor:interceptors){
+      properties = interceptor.proceed(properties, isAuto);
+    }
+    return properties;
+  }
+
+  interface Interceptor{
+    JSONObject proceed(JSONObject properties, boolean isAuto);
+  }
+}

package/android/src/main/java/com/reactnativequicktrackinganalyticsmodule/utils/RNTouchTargetHelper.java

@@ -0,0 +1,139 @@
+package com.reactnativequicktrackinganalyticsmodule.utils;
+
+import android.annotation.SuppressLint;
+import android.graphics.Matrix;
+import android.graphics.PointF;
+import android.graphics.Rect;
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.facebook.react.bridge.JSApplicationIllegalArgumentException;
+import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.touch.ReactHitSlopView;
+import com.facebook.react.uimanager.PointerEvents;
+import com.facebook.react.uimanager.ReactCompoundView;
+import com.facebook.react.uimanager.ReactCompoundViewGroup;
+import com.facebook.react.uimanager.ReactPointerEventsView;
+
+public class RNTouchTargetHelper {
+  private static final float[] mEventCoords = new float[2];
+  private static final Matrix mInverseMatrix = new Matrix();
+  private static final float[] mMatrixTransformCoords = new float[2];
+  private static final PointF mTempPoint = new PointF();
+
+  public static int findTargetTagForTouch(float eventX, float eventY, ViewGroup viewGroup) {
+    return findTargetTagAndCoordinatesForTouch(eventX, eventY, viewGroup, mEventCoords);
+  }
+
+  public static int findTargetTagAndCoordinatesForTouch(float eventX, float eventY, ViewGroup viewGroup, float[] viewCoords) {
+    UiThreadUtil.assertOnUiThread();
+    int targetTag = viewGroup.getId();
+    viewCoords[0] = eventX;
+    viewCoords[1] = eventY;
+    View nativeTargetView = findTouchTargetView(viewCoords, viewGroup);
+    if (nativeTargetView == null) {
+      return targetTag;
+    }
+    View reactTargetView = findClosestReactAncestor(nativeTargetView);
+    if (reactTargetView != null) {
+      return getTouchTargetForView(reactTargetView, viewCoords[0], viewCoords[1]);
+    }
+    return targetTag;
+  }
+
+  @SuppressLint("ResourceType")
+  public static View findClosestReactAncestor(View view) {
+    while (view != null && view.getId() <= 0) {
+      view = (View) view.getParent();
+    }
+    return view;
+  }
+
+  public static View findTouchTargetView(float[] eventCoords, ViewGroup viewGroup) {
+    for (int i = viewGroup.getChildCount() - 1; i >= 0; i--) {
+      View child = viewGroup.getChildAt(i);
+      PointF childPoint = mTempPoint;
+      if (isTransformedTouchPointInView(eventCoords[0], eventCoords[1], viewGroup, child, childPoint)) {
+        float restoreX = eventCoords[0];
+        float restoreY = eventCoords[1];
+        eventCoords[0] = childPoint.x;
+        eventCoords[1] = childPoint.y;
+        View targetView = findTouchTargetViewWithPointerEvents(eventCoords, child);
+        if (targetView != null) {
+          return targetView;
+        }
+        eventCoords[0] = restoreX;
+        eventCoords[1] = restoreY;
+      }
+    }
+    return viewGroup;
+  }
+
+  private static boolean isTransformedTouchPointInView(float x, float y, ViewGroup parent, View child, PointF outLocalPoint) {
+    float localX = (((float) parent.getScrollX()) + x) - ((float) child.getLeft());
+    float localY = (((float) parent.getScrollY()) + y) - ((float) child.getTop());
+    Matrix matrix = child.getMatrix();
+    if (!matrix.isIdentity()) {
+      float[] localXY = mMatrixTransformCoords;
+      localXY[0] = localX;
+      localXY[1] = localY;
+      Matrix inverseMatrix = mInverseMatrix;
+      matrix.invert(inverseMatrix);
+      inverseMatrix.mapPoints(localXY);
+      localX = localXY[0];
+      localY = localXY[1];
+    }
+    if ((child instanceof ReactHitSlopView) && ((ReactHitSlopView) child).getHitSlopRect() != null) {
+      Rect hitSlopRect = ((ReactHitSlopView) child).getHitSlopRect();
+      if (localX < ((float) (-hitSlopRect.left)) || localX >= ((float) ((child.getRight() - child.getLeft()) + hitSlopRect.right)) || localY < ((float) (-hitSlopRect.top)) || localY >= ((float) ((child.getBottom() - child.getTop()) + hitSlopRect.bottom))) {
+        return false;
+      }
+      outLocalPoint.set(localX, localY);
+      return true;
+    } else if (localX < 0.0f || localX >= ((float) (child.getRight() - child.getLeft())) || localY < 0.0f || localY >= ((float) (child.getBottom() - child.getTop()))) {
+      return false;
+    } else {
+      outLocalPoint.set(localX, localY);
+      return true;
+    }
+  }
+
+  private static View findTouchTargetViewWithPointerEvents(float[] eventCoords, View view) {
+    PointerEvents pointerEvents = view instanceof ReactPointerEventsView ? ((ReactPointerEventsView) view).getPointerEvents() : PointerEvents.AUTO;
+    if (pointerEvents == PointerEvents.NONE) {
+      return null;
+    }
+    if (pointerEvents == PointerEvents.BOX_ONLY) {
+      return view;
+    }
+    if (pointerEvents == PointerEvents.BOX_NONE) {
+      if (view instanceof ViewGroup) {
+        View targetView = findTouchTargetView(eventCoords, (ViewGroup) view);
+        if (targetView != view) {
+          return targetView;
+        }
+        if (!(view instanceof ReactCompoundView) || ((ReactCompoundView) view).reactTagForTouch(eventCoords[0], eventCoords[1]) == view.getId()) {
+          return null;
+        }
+        return view;
+      }
+      return null;
+    } else if (pointerEvents != PointerEvents.AUTO) {
+      StringBuilder stringBuilder = new StringBuilder();
+      stringBuilder.append("Unknown pointer event type: ");
+      stringBuilder.append(pointerEvents.toString());
+      throw new JSApplicationIllegalArgumentException(stringBuilder.toString());
+    } else if ((!(view instanceof ReactCompoundViewGroup) || !((ReactCompoundViewGroup) view).interceptsTouchEvent(eventCoords[0], eventCoords[1])) && (view instanceof ViewGroup)) {
+      return findTouchTargetView(eventCoords, (ViewGroup) view);
+    } else {
+      return view;
+    }
+  }
+
+  public static int getTouchTargetForView(View targetView, float eventX, float eventY) {
+    if (targetView instanceof ReactCompoundView) {
+      return ((ReactCompoundView) targetView).reactTagForTouch(eventX, eventY);
+    }
+    return targetView.getId();
+  }
+}