affise-attribution-lib 1.6.14 → 1.6.15

package/src/native/AffiseNative.ts

@@ -16,9 +16,14 @@ import {toAffiseKeyValueList} from "../module/AffiseKeyValue";
 import type {DebugOnValidateCallback} from "../debug/validate/DebugOnValidateCallback";
 import type {DebugOnNetworkCallback} from "../debug/network/DebugOnNetworkCallback";
 import {DebugUtils} from "./utils/DebugUtils";
+import type {OnSendSuccessCallback} from "../events/OnSendSuccessCallback";
+import type {OnSendFailedCallback} from "../events/OnSendFailedCallback";
 
 export class AffiseNative extends NativeBase {
 
+    protected SUCCESS: string = "success";
+    protected FAILED: string = "failed";
+
     init(initProperties: AffiseInitProperties | AffiseInitPropertiesType) {
         let option: AffiseInitProperties;
         if (isAffiseInitPropertiesType(initProperties)) {
@@ -38,6 +43,17 @@ export class AffiseNative extends NativeBase {
         this.native(AffiseApiMethod.SEND_EVENT, event.toRecord());
     }
 
+    sendEventNow(event: AffiseEvent, success: OnSendSuccessCallback, failed: OnSendFailedCallback) {
+        this.nativeCallbackGroup(
+            AffiseApiMethod.SEND_EVENT_NOW,
+            new Map([
+                [this.SUCCESS, success],
+                [this.FAILED, failed],
+            ]),
+            event.toRecord()
+        );
+    }
+
     addPushToken(pushToken: string) {
         this.native(AffiseApiMethod.ADD_PUSH_TOKEN, pushToken);
     }
@@ -146,8 +162,22 @@ export class AffiseNative extends NativeBase {
         this.nativeCallback(AffiseApiMethod.DEBUG_NETWORK_CALLBACK, callback);
     }
 
-    protected handleCallback(api: AffiseApiMethod, callback: unknown, data: any) {
+    protected handleCallback(api: AffiseApiMethod, callback: unknown, data: any, tag: string | null) {
         switch (api) {
+            case AffiseApiMethod.SEND_EVENT_NOW:
+                switch (tag) {
+                    case this.SUCCESS:
+                        tryCast<OnSendSuccessCallback>(callback)?.();
+                        break;
+                    case this.FAILED: {
+                        const response = DebugUtils.parseResponse(data);
+                        tryCast<OnSendFailedCallback>(callback)?.(response);
+                    }
+                        break;
+                    default:
+                        break;
+                }
+                break;
             case AffiseApiMethod.GET_REFERRER_CALLBACK:
                 tryCast<ReferrerCallback>(callback)?.(data as string || "");
                 break;

package/src/native/NativeBase.ts

@@ -6,7 +6,9 @@ import {apiMethodFrom} from "./AffiseApiMethod";
 
 export class NativeBase extends NativeBasePlatform {
     protected UUID: string = "callback_uuid";
+    protected TAG: string = "callback_tag";
 
+    protected callbacksGroup: Map<string, Map<string, unknown>> = new Map<string, Map<string, unknown>>();
     protected callbacksOnce: Map<string, unknown> = new Map<string, unknown>();
     protected callbacks: Map<AffiseApiMethod, unknown> = new Map<AffiseApiMethod, unknown>();
 
@@ -34,6 +36,16 @@ export class NativeBase extends NativeBasePlatform {
         this.apiCall(api.toString(), apiData);
     }
 
+    protected nativeCallbackGroup(api: AffiseApiMethod, callbackGroup: Map<string, unknown>, data: any | null = null) {
+        const uuid = Uuid.generate();
+        const apiData: Record<string, any> = {
+            [api.toString()]: data,
+            [this.UUID]: uuid,
+        };
+        this.callbacksGroup.set(uuid, callbackGroup);
+        this.apiCall(api.toString(), apiData);
+    }
+
     protected nativeCallback(api: AffiseApiMethod, callback: unknown, data: any | null = null) {
         const apiData: Record<string, any> = {
             [api.toString()]: data,
@@ -47,23 +59,34 @@ export class NativeBase extends NativeBasePlatform {
         if (api == null) return;
         const dataRecord = apiData as Record<string, any>;
         const uuid = dataRecord[this.UUID] as string;
+        const tag = dataRecord[this.TAG] as string;
         const data = dataRecord[apiName];
+
         if (uuid == null || uuid.length == 0) {
             const callback = this.callbacks.get(api);
             if (callback !== undefined) {
-                this.handleCallback(api, callback, data);
+                this.handleCallback(api, callback, data, null);
+            }
+        } else if (tag != null && uuid.length > 0) {
+            const callbackGroup = this.callbacksGroup.get(uuid);
+            if (callbackGroup !== undefined) {
+                const callback = callbackGroup.get(tag);
+                if (callback !== undefined) {
+                    this.handleCallback(api, callback, data, tag);
+                }
             }
+            this.callbacksGroup.delete(uuid);
         } else {
             const callback = this.callbacksOnce.get(uuid);
             if (callback !== undefined) {
-                this.handleCallback(api, callback, data);
+                this.handleCallback(api, callback, data, null);
             }
             this.callbacksOnce.delete(uuid);
         }
     }
 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    protected handleCallback(_api: AffiseApiMethod, _callback: unknown, _data: any) {
+    protected handleCallback(_api: AffiseApiMethod, _callback: unknown, _data: any, _tag: string | null) {
 
     }
 }

package/src/native/utils/DebugUtils.ts

@@ -9,29 +9,43 @@ export class DebugUtils {
         return validationStatusFrom(data as string || "") || ValidationStatus.UNKNOWN_ERROR;
     }
 
-    static parseRequestResponse(data: any): [HttpRequest, HttpResponse] {
+    static parseResponse(data: any): HttpResponse {
         const json = tryCast<Record<string, any>>(data) || {};
+        const resCode = json["code"] as number || 0;
+        const resMessage = json["message"] || "";
+        const resBody = json["body"];
 
-        const req = json["request"];
-        const reqUrl = req["url"] || "";
-        const reqMethod = req["method"] || "";
-        const reqBody = req["body"];
-        const reqHeaders = tryCast<Record<string, string>>(req["headers"]) || {};
+        return new HttpResponse({
+            code: resCode,
+            message: resMessage,
+            body: resBody
+        });
+    }
 
-        const res = json["response"];
-        const resCode = res["code"] as number || 0;
-        const resMessage = res["message"] || "";
-        const resBody = res["body"];
+    static parseRequest(data: any): HttpRequest {
+        const json = tryCast<Record<string, any>>(data) || {};
+        const reqUrl = json["url"] || "";
+        const reqMethod = json["method"] || "";
+        const reqBody = json["body"];
+        const reqHeaders = tryCast<Record<string, string>>(json["headers"]) || {};
 
-        return [new HttpRequest({
+        return new HttpRequest({
             url: reqUrl,
             method: httpMethodFrom(reqMethod) || HttpMethod.POST,
             headers: reqHeaders,
             body: reqBody
-        }), new HttpResponse({
-            code: resCode,
-            message: resMessage,
-            body: resBody
-        })];
+        });
+    }
+
+    static parseRequestResponse(data: any): [HttpRequest, HttpResponse] {
+        const json = tryCast<Record<string, any>>(data) || {};
+
+        const req = json["request"];
+        const request = this.parseRequest(req);
+
+        const res = json["response"];
+        const response = this.parseResponse(res);
+
+        return [request, response];
     }
 }