目录
此内容是否有帮助?

# Egret Engine Mini Game SDK User Guide

TIP

Before accessing, please read the preparation before accessing .

You can get the SDK source code in GitHub (opens new window).

Egret SDK support platform: HTML5, iOS, Android, WeChat games, Baidu games, Xiaomi fast games, OPPO games, vivo games, QQ games, 360 games, ByteDance games, Huawei fast games, Alipay games, Taobao creative interactive Mini Program, Facebook.

**The latest version is: **2.0. 2

**Updated: **2021-1 2 - 31

Download address (opens new window)

# I. Integrated SDK

# 1.1 Introduction of SDK

Download and unzip the Egret SDK (opens new window).

Introducing the SDK library is the same process as introducing other third-party libraries, introducing the library in the egretP roperties.json and compiling the engine.

{
     "name": "ThinkingAnalyticsSDK",
     "path": "./libs/ThinkingAnalyticsSDK"
}

After being introduced into the project, the compilation engine can use the SDK library.

# 1.2 Initialize SDK

With the TA SDK integration, you can use the ThinkingAnalytics API directly in your code:

// TA SDK Configuration Object
var config = {
  appId: "YOUR_APPID", // Project APP ID
  serverUrl: "YOUR_SERVER_URL", // Report Address
  autoTrack: {
    appShow: true, // Automatic acquisition ta_mg_show
    appHide: true // Automatic acquisition ta_mg_hide
  }
};

// Create TA instance
var ta = new ThinkingAnalyticsAPI(config);

// Initialize
ta.init();

// Report a simple event named test_ Event
ta.track("test_event");

TA configuration object parameters are described as follows:

  • AppId: Your project's APP ID, required, can be viewed in the TA background project management page
  • ServerUrl: Data reporting URL, required
    • If you are using Cloud as a Service, fill in: https://receiver.ta.thinkingdata.cn
    • If you are using the private deployment version, please confirm the reporting address with your operation and maintenance colleagues
  • AutoTrack: optional, indicating whether to turn on the automatic collection function, each element represents the following automatic collection events, all turned off by default:
    • AppShow: Auto-capture mini-game start, or enter the foreground from the background
    • appHide: automatic collection of small games from the front into the background, and record the time of this visit (start to transfer into the background)
  • EnableNative: Allow calls to Native code (see: Native support )

WARNING

Before reporting data, please add the data transfer URL to the request list of the server domain name in the development settings of WeChat public platform or other platforms.

**For more information about automatic collection events, you can see the **automatic collection event section

# II. Set User ID

After integrating the SDK, the SDK will use UUID as the default guest ID for each user, which will be used as the user identification ID when the user is not logged in. It should be noted that UUID will change when users change equipment and clear cache.

# 2.1 Set Visitor ID

If you want to use another ID as the user's guest ID, you can call identifyor authorizeOpenIDto set the visitor ID (the two methods are equivalent, leaving two interface names according to usage habits):

// The incoming value is openid
ta.authorizeOpenID("OpenID");
// identify equivalent to authorizeOpenID
ta.identify("OpenID");

The following points should be noted:

  1. The set OpenID will be set to guest ID #distinct_id. If you use loginto pass in the account ID, according to the user identification rules, the account ID will prevail first
  2. If you need to set up, you must call this interface before init

# 2.2 Set Account ID

When the user generates login behavior, you can call loginto set the user's account ID. The TA platform preferentially uses the account ID as the identity, the set account ID will be saved, and multiple calls to loginwill overwrite the previous account ID:

// Unique logon identification of the user, which corresponds to #account_id in the reported data, when the value of #account_id is "ABC_123456"
ta.login("ABC_123456");

// Call login again to adjust the account ID, when the value of #account_id is "XYZ_987654"
ta.login("XYZ_987654");

Note that this method does not upload events for user logins**.**

# 2.3 Clear Account ID

After the user produces login behavior, you can call logoutto clear the account ID. Before the next call to login, the guest ID will be used as the identification ID:

// Remove the #account_id from the reported data and the data will not have #account_id
ta.logout();

Note that this method does not upload user logged-out events**.**

# III. Send Events

You can directly call trackto upload custom events. It is recommended that you set the attributes of the event and the conditions for sending information according to the previously combed doc. Here, take the purchase of goods as an example:

ta.track(
  "Purchase", // Name of tracking event
  {
    Item: "Product A",
    ItemNum: 1,
    Cost: 100,
    Elements: ["apple", "ball", "cat"]
  } // Event attributes to upload
);
  • The trackinterface has two parameters, the first parameter is the name of the event, and the second parameter is the attribute of the event
  • The name of the event is string, can only start with a letter, can contain numbers, letters and underscore '_', is up to 50 characters in length, and is not sensitive to letter case.
  • The properties of the event are JS objects, and each element represents a property.
  • The name of the element corresponds to the name of the attribute. It is stipulated that only letters can be used at the beginning, including numbers, letters and underlined '_'. The maximum length is 50 characters and is not sensitive to case of letters.
  • The value of the element is the value of the property, supporting String, Number, Boolean, Dateand Array.

    Note: The Array type property needs to be compatible with TA platform 2.5 and later.

# 3.1 Set the Event reporting time

The time when the event is triggered defaults to the local time, but in some cases, you may need to manually set the time of the event. You can use the following methods to call:

// The third parameter, which can be entered as a Date type parameter, replaces the event triggering time
ta.track("event", { parakey: "paravalue" }, new Date());

// If no properties need to be uploaded, pass in an empty object
ta.track("event", {}, new Date());
  • The third parameter is the event trigger time, which must be of type Date. The event trigger time will be replaced. If this parameter is not passed, the event trigger time will default to the user's native time

# 3.2 Record the Duration of the Event

You can call timeEventto start timing, configure the event type you want to time, and when you upload the event, you will automatically add #durationto your event attribute to indicate the length of the record, in seconds.

// The user enters the merchandise page and starts timing with the event "Enter_Shop"
ta.timeEvent("Enter_Shop");

//...

// Upload the event, the timer ends, and the event "Enter_Shop" will have the attribute "#duration" indicating the length of the event.
ta.track("Enter_Shop", { product_id: "A1354" });

# 3.3 Setting Public Properties

For some important attributes, such as the user's device ID, source channel, user status, etc., these attributes need to be set in each event. At this time, you can set these attributes as public attributes, that is, the attributes carried in each event. We recommend that you set public properties before sending an event.

There are two types of public attributes, the event public attribute and the dynamic public attribute. When the event is reported, the public attribute will be inserted into the properties of the data. If the public property has the same key value as the custom property set in the event, the property determines what value to take based on the following priority:

User custom event properties > Dynamic public properties > Event public properties

# 3.3.1 Set Event Public Properties

Event public properties refer to static public properties. Only constants can be passed in during setting. It is suitable for setting stable properties. You can call setSuperPropertiesto set public event properties. The format requirements of public event properties are consistent with event properties.

According to the property priority, the custom property priority is higher than the event public property, so the event public property can also be used as the default value of a property, setting the key of the same name to override the default value in the event that needs to be modified.

// Set common Event Properties
ta.setSuperProperties({ channel: "channel" });

// Upload events using track with common event attributes
ta.track(
  "Purchase", // Name of tracking event
  {
    Item: "Product A",
    ItemNum: 1,
    Cost: 100
  } // Event attributes to upload
);

/* Equivalent to adding these common attributes to an event
ta.track(
    'Purchase', // Name of tracking event
    {
        Item:'Product A',
        ItemNum:1,
        Cost:100,
        channel:'Channel' // Equivalent to adding this attribute to an event
    }
);
*/

If you call setSuperPropertiesmultiple times to set the public event property, the call after the field with the same name overrides the previous field with different names.

If you need to delete a public event property, you can call unsetSuperProperty ()to clear one of the public event properties; if you want to empty all public event properties, you can call clearSuperProperties (); if you want to get all public event properties, you can call getSuperProperties;

// Clear public property named CHANNEL
ta.unsetSuperProperty("CHANNEL");

//Clear common event attributes
ta.clearSuperProperties();

//Get static common event attributes
ta.getSuperProperties();

# 3.3.2 Setting dynamic public properties

The dynamic public property executes a function when the event is reported, and adds the return value to the event as the value of the dynamic public property. You can set dynamic public properties by calling the setDynamicSuperPropertiesinterface, which accepts a function as a parameter.

// Set UTC time as event attribute reporting via dynamic common attributes
ta.setDynamicSuperProperties(() => {
  var localDate = new Date();
  return {
    utcTime: new Date(
      localDate.getTime() + localDate.getTimezoneOffset() * 60000
    )
  };
});

The function must return a JS object, where each element represents an attribute. The format of the attribute must be consistent with the event attribute.

# IV. User Attributes

# 4.1 Set User Features ( userSet )

For general user features, you can call userSetto set it. Attributes uploaded using this interface will overwrite the original attribute values. If the user feature does not exist before, the user feature will be created

// Set user attributes, membership levels
ta.userSet({ vip_level: "Diamond Members" });

Consistent with the event attribute when uploading an event, the user feature passed in here is also an object type. Name corresponds to the name of the attribute. It is stipulated that it can only start with letters, including numbers, letters and underscores '_'. The maximum length is 50 characters. It is not sensitive to case of letters. Value is the value of the attribute and supports String, Number, Boolean, Dateand Array.

Note: The Array type needs to be used with TA platform 2.5 and later versions.

# 4.2 Initializing User Features ( userSetOnce )

If the user feature you want to upload only needs to be set once, you can call userSetOnceto set it. When the attribute already has a value before, this information will be ignored.

// For example, set the username. If the username is set, ignore this setting and if it does not exist, set it to the incoming value
ta.userSetOnce({ user_name: "TA" });

The parameter requirements of userSetOnce are consistent with userSet.

# 4.3 Accumulate User Features ( userAdd )

When you want to upload a numeric attribute, you can call userAddto accumulate the attribute. If the attribute has not been set, a value of 0 will be assigned before calculation

// For example, if the user calls this interface every time he pays, then'total_ The revenue'field processes the accumulated payment amount each time
ta.userAdd({ total_revenue: 50 });

Consistent with the event attribute when uploading an event, the user feature passed in here is also an object type. The name of the attribute corresponding to name can only start with letters, including numbers, letters and underlined "_". The maximum length is 50 characters. It is not sensitive to case of letters. Value is the value that needs to be accumulated for this attribute. Only the Numbertype is supported. Passing in negative numbers is equivalent to subtraction.

# 4.4 Reset User Features ( userUnset )

When you want to empty a user feature value of a user, you can call userUnsetto empty the specified attribute. If the attribute has not been created in the cluster, the userUnsetwill not create the attribute

// Clear property is a user property value with the name userPropertykey. This user is set to NULL
ta.userUnset("userPropertykey");

# 4.5 Delete User ( userDel )

If you want to delete a user, you can call userDelto delete the user. You will no longer be able to query the user features of the user, but the events generated by the user can still be queried

ta.userDel();

# 4.6 Add elements to user attributes of type Array ( userAppend )

You can call userAppendto append elements to user data of type Array (List).

ta.userAppend({ Elements: [("a": 1), ("b": 2)] });

Note: This feature needs to be used with TA platform 2.5 and later versions.

# V. Automatic Acquisition Events

Open the events that you need to automatically collect in the config that creates the instance, and the SDK will automatically collect some behaviors of the mini-game. Now there are mainly the following events that support automatic collection:

Automated data collection now supported are:

  1. Small game back to the front of the event
  2. Small game transferred to the background, and record the time of this visit (start to transfer to the background)

Next, we will introduce in detail the collection method of each data.

# 5.1 Turn on Automatic Collection Event

In config, the element in the parameter autoTrackrepresents the switch for each automatic collection event. Set to trueto turn on automatic collection:

var config = {
  appid: "YOUR_APPID",
  server_url: "YOUR_SERVER_URL",
  autoTrack: {
    appShow: true, // Automatic acquisition ta_mg_show
    appHide: true // Automatic acquisition ta_mg_hide
  }
};
  • AppShow: Auto-capture mini-game start, or enter the foreground from the background
  • AppHide: Auto-capture mini-games enter the background from the front desk

# 5.2 Detailed Automated Acquisition Events

# 5.2.1 Small game start

The start of the mini-game will be triggered when the mini-game is started or the mini-game is transferred back to the foreground from the background. The detailed events are described as follows:

  • Event name: ta_mg_show
  • Automatic collection of attributes:
  • #Scene, scene value, taken from the scene value provided by WeChat

Since the start of small games will be affected by the recall of the front and back (the number of pieces is large), it is not suitable for direct analysis, but it can identify a user's use in the behavior path and can be used as the initial behavior of the user's behavior path

# 5.2.2 Small game hidden

Small game hiding will be triggered when the small game is transferred to the background, and record the duration of this use. The detailed events are described as follows:

  • Event name: ta_mg_hide
  • Automatic collection of attributes:
    • #Scene, scene value, taken from the scene value provided by WeChat
    • #duration, numeric type, indicating the duration from this start (ta_m g _show) to hidden

Small game hidden events will record the usage time (in seconds), so the total usage time and timespan per person can be directly calculated, or the single usage time can be calculated by dividing the initialization times.

# VI. Other Functions

# 6.1 Multiple Instances

This SDK supports multiple instances. We refer to the instance ta initialized by the methods described above as the main instance, and the instance created by the methods described in this section as the sub-instance.

Device-related preset attributes (including device ID) are shared between multiple instances, and other attributes are not shared, including:

  • #distinct_idVisitor ID
  • #account_idAccount ID
  • Public event properties, dynamic public properties
  • TimeEventmonitored events

You can report data to another project by creating a child instance, or as another set of user IDs.

// Create a sub-instance TT with the same default configuration as the main instance
ta.initInstance("tt");

ta.lightInstance("tt").identify("another_distinct_id");
ta.lightInstance("tt").track("event_from_tt_instance");

// Create sub-instances of different configurations
var config = {
  appid: "ANOTHER-APP-ID",
  enablePersistence: true // Open local caching for sub-instances
};

ta.initInstance("tt_1", config);
ta.lightInstance("tt_1").track("event_from_tt1_instance");

# 6.2 Get the Device ID

You can call getDeviceId ()to get the device ID. Due to the operating environment, the device ID will be saved in the local cache. Once the user deletes the cache, the device ID will change, so the device ID cannot be guaranteed to be stable

var deviceId = ta.getDeviceId();

# 6.3 onCompelete Callback Function

For track, userSet, userSetOnce, userAdd, userDel and other interfaces, onComplete callbacks are supported.

You can pass onComplete directly after the original parameter list, or you can use the method of parameter objects. If you use parameter objects, the parameter objects must contain onComplete, otherwise parameter errors will occur.

Take the above event as an example:

// Input callbacks as parameter lists
ta.track("test", { testkey: 123 }, new Date(), res => {
  console.log(res);
});

// Input callback as a parameter object
ta.track({
  eventName: "test", // Reuqired
  properties: { testkey: 123 }, // Optional
  time: new Date(), // Optional
  onComplete: res => {
    console.log(res);
  } // Required
});

The parameter res of onComplete is of type object, with two properties code and msg.

res.code type int, defined as follows:

  • 0: Success
  • -1: Incorrect data format
  • -2: APP ID is invalid
  • -3: Network or server level exception

The Debug mode is defined as follows:

  • 0: Success
  • -1: Parameter or permission verification problem
  • 1: Represents the basic error of the field, and will give detailed error fields and reasons
  • 2: Indicates the whole error
  • -3: Network or server level exception

res.msg is a written description of res.code.

# 6.4 Open Debug Mode

Starting from v1.6.0, the client side SDK supports Debug mode and needs to be used with TA platform versions after 2.5.

Debug mode may affect the quality of data collection and the stability of the app. It is only used for data verification during the integration phase and should not be used in online environments.

The current SDK instance supports three operating modes:

  • 'None': Do not open Debug
  • 'Debug': Open Debug mode and put it into storage
  • 'DebugOnly': Open Debug mode, no storage

SDK initialization:

var config = {
  appid: "YOUR_APPID",
  server_url: "YOUR_SERVER_URL",
  debugMode: "debug"
};

ta = new ThinkingDataAPI(config);
ta.init();

In order to prevent Debug mode from going live in the production environment, it is stipulated that only specified devices can turn on Debug mode. Debug mode can only be enabled on the client side, and the device ID is configured in the 'Debug Data' section of the 'Event tracking management' page in the background of the TA.

The device ID can be obtained in three ways:

  • #device_id attribute in event data in TA platform
  • Call through the instance interface: get device ID

# VII. Relevant Preset Attributes

# 7.1 Preset Properties for All Events

The following preset attributes are preset attributes that all events in the mini-game SDK (including automatic collection events) will carry.

Attribute name
 Chinese name
 Description
#ip
 IP address
 The user's IP address, which the TA will use to obtain the user's geographic location information
#country
 Country
 User's country, generated according to IP address
#country_code
 Country code
 The country code of the country where the user is located (ISO 3166-1 alpha-2, that is, two uppercase English letters), generated based on the IP address
#province
 Province
 The user's province is generated according to the IP address
#city
 City
 The user's city is generated according to the IP address
#device_model
 Equipment model
 Model of user equipment, such as iPhone 8, etc
#device_id
 Device ID
 The user's device ID, take the UUID generated during initialization
#screen_height
 Screen height
 The screen height of the user equipment, such as 1920, etc
#screen_width
 Screen width
 The screen height of the user equipment, such as 1080, etc
#manufacturer
 Equipment manufacturer
 Manufacturers of user equipment, such as Apple, vivo, etc
#os_version
 Operating system version
 iOS 11.2.2、Android 8.0.0 等
#os
 Operating system
 Such as Android, iOS, etc
#network_type
 Network status
 Network status when uploading events, such as WIFI, 3G, 4G, etc
# lib
 SDK type
 The type of SDK you access, such as MG (mini-game)
#lib_version
 SDK version
 The version you access to the SDK
#scene
 Scene value
 The incoming scene value when the WeChat mini-game starts
#mp_platform
 Small game platform
 Identify the platform where the application is located
#zone_offset
 Time zone offset
 The number of hours the data time is offset from UTC time

# 7.2 Automatically collect preset properties of events

The following preset properties are unique to each AutoCollect event

  • Prefab properties for ta mg hide
Attribute name
 Chinese name
 Description
#duration
 Event duration
 Represents the duration of this startup
ta_m g _show
to hide
ta_m g _hide
in seconds

# 7.3 Get Prefabricated Attributes

When server level event tracking requires some preset properties on the App side, you can obtain the preset properties on the client side through this method and then pass them to the server level.

   //Get Attribute Object
   var presetProperties = ta.getPresetProperties();

   //Generate event preset properties
   var properties = presetProperties.toEventPresetProperties();
   /*
      {
         "#device_model":"iPhone 5",
         "#device_id":"3204487163-1624513721217",
         "#screen_width":320,
         "#screen_height":568,
         "#os":"iOS",
         "#os_version":"10.0.1",
         "#network_type":"wifi",
         "#zone_offset":8,
         "#manufacturer":"Apple"
       }
   */

    //Get a preset property
    var os =  presetProperties.os;//os type，as Android
    var osVersion = presetProperties.osVersion;//System Version Number
    var networkType = presetProperties.networkType;//Network Type
    var manufacture = presetProperties.manufacture;//Device Manufacturer
    var deviceModel= presetProperties.deviceModel;//Device Model
    var screenWidth = presetProperties.screenWidth;//Screen width
    var screenHeight = presetProperties.screenHeight;//Screen height
    var deviceId = presetProperties.deviceId;//Device ID
    var zoneOffset = presetProperties.zoneOffset;//Time zone offset value

IP, country city information is generated by server level resolution, and the client side does not provide an interface to obtain these attributes

# VIII. Advanced Functions

Starting from v1.7.0, the SDK supports the reporting of three special types of events: first events, updatable events, and rewritable events. These three events need to be used in conjunction with TA system 2.8 and later versions. Since special events are only applicable in certain specific scenarios, please use special events to report data with the help of Count Technology's customer success and analysts.

# 8.1 First Event

First-time events are events that are recorded only once for a device or another dimension ID. For example, in some scenarios, you may want to record the first event on a device, you can use first-time events to report data.

// Instance: Report device first event, assuming event name is DEVICE_ FIRST
ta.trackFirstEvent({
  eventName: "DEVICE_FIRST",
  properties: { INT_PROPERTY: 0 }
});

If you want to determine whether it is the first time in a dimension other than the device, you can set FIRST_CHECK_ID for the first event. For example, if you need to record the first event of an account, you can set the account ID to the FIRST_CHECK_ID of the first event:

// Instance: First event to report a user account, assuming the event name is USER_ FIRST
// FIRST_Setting User ID to First Event CHECK_ ID
ta.trackFirstEvent({
  eventName: "USER_FIRST",
  firstCheckId: "YOUR_ACCOUNT_ID",
  properties: { INT_PROPERTY: 0 }
});

Note: Due to the completion of the verification of whether it is the first time at the server level, the first event will be delayed by 1 hour by default.

# 8.2 Updatable Events

You can implement the need to modify event data in a specific scenario through updatable events. Updatable events need to specify an ID that identifies the event and pass it in when you create an updatable event object. The TA background will determine the data that needs to be updated based on the event name and event ID.

// Instance: Report an event that can be updated, assuming the event name is UPDATABLE_ EVENT
ta.trackUpdate({
  eventName: "UPDATABLE_EVENT",
  properties: { status: 3, price: 100 },
  eventId: "test_event_id"
});
// Event attributes after reporting are status 3 and price 100

ta.trackUpdate({
  eventName: "UPDATABLE_EVENT",
  properties: { status: 5 },
  eventId: "test_event_id"
});
// Event attributes status is updated to 5 after reporting, price remains unchanged

# 8.3 Rewritable Events

Rewritable events are similar to updatable events, except that rewritable events will completely cover historical data with the latest data, which is equivalent to deleting the previous data and storing the latest data in effect. The TA background will determine the data that needs to be updated based on the event name and event ID.

// Instance: Report an event that can be overridden, assuming the event name is OVERWRITE_ EVENT
ta.trackOverwrite({
  eventName: "OVERWRITE_EVENT",
  properties: { status: 3, price: 100 },
  eventId: "test_event_id"
});

// Event attributes after reporting are status 3 and price 100
ta.trackOverwrite({
  eventName: "OVERWRITE_EVENT",
  properties: { status: 5 },
  eventId: "test_event_id"
});

// Event attributes status is updated to 5 and price attributes are deleted after reporting

# Native support

# 9.1 iOS Native Support

Build iOS platform applications

# 9.1.1 Configuration iOS Engineering

  • Add iOS project dependency file
    • EgretProxyApi.h
    • EgretProxyApi.mm
    • ThinkingSDK.framework
  • Build Settings
    • Other Linker Flags add -ObjC
  • Registered Native Agent
    • Register the Native agent in the AppD elegate.mm's application: didFinishLaunchingWithOptions:method, calling the code [EgretProxyApi registExternalInterface: _native]

# 9.2 Android Native Support

Build Android platform applications

# 9.2.1 Configure Android project

  • Add Adnroid project dependency file
    • EgretProxyApi.java
  • Add the following configuration dependencies to the build.gradlefile at the Projectlevel
buildscript {
    repositories {
        jcenter()
        mavenCentral()
    }
}
  • Add dependencies in build.gradlefiles in the Moduleproject directory
dependencies {
    implementation 'cn.thinkingdata.android:ThinkingAnalyticsSDK:2.7.3'
}
  • Registered Native Agent
    • Register the Native agent in the onCreate MainActivitymethod, calling the code EgretProxyApi.registExternalInterface_(nativeAndroid, this) _

# 9.3 Enable Native Support

When initializing the SDK, add enableNative: trueto config to turn on Native support.

// TA SDK Configuration Object
var config = {
  appId: "YOUR_APPID", // Project APP ID
  serverUrl: "YOUR_SERVER_URL", // Report Address
  enableNative: true, // Allow calling Native code
  autoTrack: {
    appShow: true, // Automatic collection of start-up events
    appHide: true, // Automatic Acquisition of Close Events
    appClick: true, // Automatic collection of click events (native only)
    appView: true, // Automatic capture of page browsing events (native only)
    appCrash: true, // Collect crash events automatically (native only)
    appInstall: true // Automatic collection of installation events (native only)
  }
};

// Create TA Instance
var ta = new ThinkingAnalyticsAPI(config);

// Initialize
ta.init();

// Report a simple event named test_ Event
ta.track("test_event");

# Release Notes

v2.0.2 2021/12/31

  • Support Alipay, Taobao creative interaction, 360, Toutiao, Facebook and other small games
  • Code optimization

v2.0.1 2021/11/15

  • Code optimization

v2.0.0 2021/09/15

  • Support iOS /Android Native
  • Support pause/start, stop/resume data reporting
  • Support event blacklist
  • Code Optimization

v1.8.2 2021/06/24

  • Support prefabricated attribute acquisition
  • Fix bug: When the native/web platform is running, the data sent failed due to disconnection and reconnection

v1.8.0 2020/11/20

  • Added Bilibili mini-game support
  • Improve game engine support: support ts project access
  • Perfect game engine support: support common small games, fast game platforms (Huawei, Xiaomi, OPPO, VIVO), H5 games
  • Optimization of other code details

v1.7.0 2020/08/24

  • Supports first events, updatable events, rewritable events

v1.6.0 2020/06/10

  • Support debug mode

v1.5.1 2020/03/21

  • Support Egret engine small game platform: WeChat small game, Baidu small game, QQ small game, VIVO small game, OPPO small game
  • Support LAYABOX engine small game platform: WeChat small game, Baidu small game, QQ small game, VIVO small game, OPPO small game
  • Support CocosCreator engine small game platform: WeChat small game, Baidu small game, VIVO small game, OPPO small game

← LayaAir Engine Mini Game SDK Usage Guide →