Android 应用接入¶

buildscript {
    //...
    repositories {
        //...
        //添加 SDK 的远程仓库地址
        maven {
            url 'https://mvnrepo.jiagouyun.com/repository/maven-releases'
        }
    }
    dependencies {
        //...
        //添加 Plugin 的插件，依赖 AGP 7.4.2 以上，Gradle 7.2.0 以上
        classpath 'com.cloudcare.ft.mobile.sdk.tracker.plugin:ft-plugin:[latest_version]'
        // AGP 7.4.2 以下版本，请使用 ft-plugin-legacy 
        //classpath 'com.cloudcare.ft.mobile.sdk.tracker.plugin:ft-plugin-legacy:[latest_version]'

    }
}
allprojects {
    repositories {
        //...
        //添加 SDK 的远程仓库地址
        maven {
            url 'https://mvnrepo.jiagouyun.com/repository/maven-releases'
        }
    }
}

//setting.gradle

pluginManagement {
    repositories {
        google()
        mavenCentral()
        gradlePluginPortal()
        //添加 SDK 的远程仓库地址
        maven {
            url('https://mvnrepo.jiagouyun.com/repository/maven-releases')
        }
    }
}
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        //添加 SDK 的远程仓库地址
        maven {
            url('https://mvnrepo.jiagouyun.com/repository/maven-releases')
        }
    }
}

//build.gradle

plugins{
    //添加 Plugin 的插件，依赖 AGP 7.4.2 以上，Gradle 7.2.0 以上
    id 'com.cloudcare.ft.mobile.sdk.tracker.plugin' version '[lastest_version]' apply false
    // AGP 7.4.2 以下版本，请使用 ft-plugin-legacy 
    //id 'com.cloudcare.ft.mobile.sdk.tracker.plugin.legacy' version '[lastest_version]' apply false
}

public class DemoApplication extends Application {

    @Override
    public void onCreate() {
        FTSDKConfig config = FTSDKConfig.builder(DATAKIT_URL)//Datakit 安装地址
                .setDebug(true);

        FTSdk.install(config);

        // ...
    }
}

class DemoApplication : Application() {
    override fun onCreate() {
        val config = FTSDKConfig
            .builder(DATAKIT_URL)//Datakit 安装地址
            .setDebug(true);

        FTSdk.install(config)

        //...
    }
}

FTSdk.initRUMWithConfig(
        new FTRUMConfig()
            .setRumAppId(RUM_APP_ID)
            .setEnableTraceUserAction(true)
            .setEnableTraceUserView(true)
            .setEnableTraceUserResource(true)
            .setSamplingRate(0.8f)
            .setExtraMonitorTypeWithError(ErrorMonitorType.ALL.getValue())
            .setDeviceMetricsMonitorType(DeviceMetricsMonitorType.ALL.getValue())
            .setEnableTrackAppUIBlock(true)
            .setEnableTrackAppCrash(true)
            .setEnableTrackAppANR(true)
);

FTSdk.initRUMWithConfig(
            FTRUMConfig()
                .setRumAppId(RUM_APP_ID)
                .setEnableTraceUserAction(true)
                .setEnableTraceUserView(true)
                .setEnableTraceUserResource(true)
                .setSamplingRate(0.8f)
                .setExtraMonitorTypeWithError(ErrorMonitorType.ALL.getValue())
                .setDeviceMetricsMonitorType(DeviceMetricsMonitorType.ALL.getValue())
                .setEnableTrackAppUIBlock(true)
                .setEnableTrackAppCrash(true)
                .setEnableTrackAppANR(true)
        )

FTSdk.initRUMWithConfig(
        new FTRUMConfig()
            .addGlobalContext(CUSTOM_STATIC_TAG, BuildConfig.CUSTOM_VALUE)
            //... 添加其他配置
);

FTSdk.initRUMWithConfig(
            FTRUMConfig()
                .addGlobalContext(CUSTOM_STATIC_TAG, BuildConfig.CUSTOM_VALUE)
                //… 添加其他配置
        )

SharedPreferences sp = context.getSharedPreferences(SP_STORE_DATA, MODE_PRIVATE);
String customDynamicValue = sp.getString(CUSTOM_DYNAMIC_TAG, "not set");

// 配置 RUM
FTSdk.initRUMWithConfig(
     new FTRUMConfig().addGlobalContext(CUSTOM_DYNAMIC_TAG, customDynamicValue)
     //… 添加其他配置
);

val sp = context.getSharedPreferences(SP_STORE_DATA, MODE_PRIVATE)
val customDynamicValue = sp.getString(CUSTOM_DYNAMIC_TAG, "not set")

//配置 RUM
FTSdk.initRUMWithConfig(
     FTRUMConfig().addGlobalContext(CUSTOM_DYNAMIC_TAG, customDynamicValue!!)
     //… 添加其他配置
)

public void setDynamicParams(Context context, String value) {
    SharedPreferences sp = context.getSharedPreferences(SP_STORE_DATA, MODE_PRIVATE);
    sp.edit().putString(CUSTOM_DYNAMIC_TAG, value).apply();
}

fun setDynamicParams(context: Context, value: String) {
            val sp = context.getSharedPreferences(SP_STORE_DATA, MODE_PRIVATE)
            sp.edit().putString(CUSTOM_DYNAMIC_TAG, value).apply()

        }

FTSdk.initLogWithConfig(new FTLoggerConfig()
    //.setEnableConsoleLog(true,"log prefix")
    .setEnableLinkRumData(true)
    .setEnableCustomLog(true)
    //.setLogLevelFilters(new Status[]{Status.CRITICAL, Status.ERROR})
    .setSamplingRate(0.8f));

   FTSdk.initLogWithConfig(
            FTLoggerConfig()
              //.setEnableConsoleLog(true,"log prefix")
                .setEnableLinkRumData(true)
                .setEnableCustomLog(true)
              //.setLogLevelFilters(arrayOf(Status.CRITICAL,Status.ERROR))
                .setSamplingRate(0.8f)
        )

FTSdk.initTraceWithConfig(new FTTraceConfig()
    .setSamplingRate(0.8f)
    .setEnableAutoTrace(true)
    .setEnableLinkRUMData(true));

   FTSdk.initTraceWithConfig(
            FTTraceConfig()
                .setSamplingRate(0.8f)
                .setEnableAutoTrace(true)
                .setEnableLinkRUMData(true)
        )

    /**
     *  添加 action
     *
     * @param actionName action 名称
     * @param actionType action 类型
     */
    public void startAction(String actionName, String actionType)


    /**
     * 添加 action
     *
     * @param actionName action 名称
     * @param actionType action 类型
     * @param property   附加属性参数
     */
    public void startAction(String actionName, String actionType, HashMap<String, Object> property)

    /**
     *  添加 action
     *
     * @param actionName action 名称
     * @param actionType action 类型
     */
    fun startAction(actionName: String, actionType: String)


    /**
     * 添加 action
     *
     * @param actionName action 名称
     * @param actionType action 类型
     * @param property   附加属性参数
     */
    fun startAction(actionName: String, actionType: String, property: HashMap<String, Any>)

// 场景1
FTRUMGlobalManager.get().startAction("login", "action_type");

// 场景2: 动态参数
HashMap<String, Object> map = new HashMap<>();
map.put("ft_key", "ft_value");
FTRUMGlobalManager.get().startAction("login", "action_type", map);

// 场景1
FTRUMGlobalManager.get().startAction("login", "action_type")

// 场景2: 动态参数
val map = HashMap<String,Any>()
map["ft_key"]="ft_value"
FTRUMGlobalManager.get().startAction("login","action_type",map)

    /**
     * view 起始
     *
     * @param viewName 当前页面名称
     */
    public void startView(String viewName)


    /**
     * view 起始
     *
     * @param viewName 当前页面名称
     * @param property 附加属性参数
     */
    public void startView(String viewName, HashMap<String, Object> property)


    /**
     * view 结束
     */
    public void stopView()

    /**
     * view 结束
     *
     * @param property 附加属性参数
     */
    public void stopView(HashMap<String, Object> property)

    /**
     * view 起始
     *
     * @param viewName 当前页面名称
     */
    fun startView(viewName: String)

     /**
     * view 起始
     *
     * @param viewName 当前页面名称
     * @param property 附加属性参数
     */

    fun startView(viewName: String, property: HashMap<String, Any>)

     /**
     * view 结束
     */
    fun stopView()

     /**
     * view 结束
     *
     * @param property 附加属性参数
     */
    fun stopView(property: HashMap<String, Any>)

@Override
protected void onResume() {
    super.onResume();

    // 场景 1
    FTRUMGlobalManager.get().startView("Current Page Name");

    // 场景 2: 动态参数
    HashMap<String, Object> map = new HashMap<>();
    map.put("ft_key", "ft_value");
    map.put("ft_key_will_change", "ft_value");
    FTRUMGlobalManager.get().startView("Current Page Name", map);
}

@Override
protected void onPause() {
    super.onPause();

    // 场景 1
    FTRUMGlobalManager.get().stopView();

    // 场景 2 : 动态参数
    HashMap<String, Object> map = new HashMap<>();
    map.put("ft_key_will_change", "ft_value_change"); //ft_key_will_change 这个数值，会在 stopView 时候被修改为 ft_value_change
    FTRUMGlobalManager.get().startView("Current Page Name", map);
}

override fun onResume() {
     super.onResume()

     // 场景 1
     FTRUMGlobalManager.get().startView("Current Page Name")

     // 场景 2: 动态参数
     val map = HashMap<String, Any>()
     map["ft_key"] = "ft_value"
     map["ft_key_will_change"] = "ft_value"
     FTRUMGlobalManager.get().startView("Current Page Name", map)

}

override fun onPause() {
     super.onPause()

     // 场景 1
     FTRUMGlobalManager.get().stopView()


     // 场景 2 : 动态参数
     val map = HashMap<String, Any>()
     map["ft_key_will_change"] = "ft_value_change" //ft_key_will_change 这个数值，会在 stopView 时候被修改为 ft_value_change
     FTRUMGlobalManager.get().startView("Current Page Name", map)

}

    /**
     * 添加错误信息
     *
     * @param log       日志
     * @param message   消息
     * @param errorType 错误类型
     * @param state     程序运行状态
     */
    public void addError(String log, String message, ErrorType errorType, AppState state)


     /**
     * 添加错误
     *
     * @param log       日志
     * @param message   消息
     * @param errorType 错误类型
     * @param state     程序运行状态
     * @param dateline  发生时间，纳秒
     */
    public void addError(String log, String message, long dateline, ErrorType errorType, AppState state)

    /**
     * 添加错误信息
     *
     * @param log
     * @param message
     * @param errorType
     * @param state
     * @param property
     */
    public void addError(String log, String message, ErrorType errorType, AppState state, HashMap<String, Object> property)


    /**
     * 添加错误
     *
     * @param log       日志
     * @param message   消息
     * @param errorType 错误类型
     * @param state     程序运行状态
     * @param dateline  发生时间，纳秒
     */
    public void addError(String log, String message, long dateline, ErrorType errorType,
                         AppState state, HashMap<String, Object> property)

    /**
     * 添加错误信息
     *
     * @param log       日志
     * @param message   消息
     * @param errorType 错误类型
     * @param state     程序运行状态
     */
    fun addError(log: String, message: String, errorType: ErrorType, state: AppState)

     /**
     * 添加错误
     *
     * @param log       日志
     * @param message   消息
     * @param errorType 错误类型
     * @param state     程序运行状态
     * @param dateline  发生时间，纳秒
     */
    fun addError(log: String, message: String, dateline: Long, errorType: ErrorType, state: AppState)

     /**
     * 添加错误信息
     *
     * @param log
     * @param message
     * @param errorType
     * @param state
     * @param property
     */
    fun addError(log: String, message: String, errorType: ErrorType, state: AppState, property: HashMap<String, Any>)

     /**
     * 添加错误
     *
     * @param log       日志
     * @param message   消息
     * @param errorType 错误类型
     * @param state     程序运行状态
     * @param dateline  发生时间，纳秒
     */
    fun addError(log: String, message: String, dateline: Long, errorType: ErrorType,state: AppState, property: HashMap<String, Any>)

// 场景 1:
FTRUMGlobalManager.get().addError("error log", "error msg", ErrorType.JAVA, AppState.RUN);

// 场景 2:延迟记录发生的错误，这里的时间一般为错误发生的时间
FTRUMGlobalManager.get().addError("error log", "error msg", 16789000000000000000L, ErrorType.JAVA, AppState.RUN);

// 场景 3：动态参数
HashMap<String, Object> map = new HashMap<>();
map.put("ft_key", "ft_value");
FTRUMGlobalManager.get().addError("error log", "error msg", ErrorType.JAVA, AppState.RUN, map);

// 场景 1:
FTRUMGlobalManager.get().addError("error log", "error msg", ErrorType.JAVA, AppState.RUN)

// 场景 2:延迟记录发生的错误，这里的时间一般为错误发生的时间
FTRUMGlobalManager.get().addError("error log", "error msg", 16789000000000000000, ErrorType.JAVA, AppState.RUN)

// 场景 3：动态参数
val map = HashMap<String, Any>()
map["ft_key"] = "ft_value"
FTRUMGlobalManager.get().addError("error log", "error msg",ErrorType.JAVA,AppState.RUN,map)

    /**
     * 添加长任务
     *
     * @param log      日志内容
     * @param duration 持续时间，纳秒
     */
    public void addLongTask(String log, long duration)

    /**
     * 添加长任务
     *
     * @param log      日志内容
     * @param duration 持续时间，纳秒
     */
    public void addLongTask(String log, long duration, HashMap<String, Object> property)

    /**
     * 添加长任务
     *
     * @param log      日志内容
     * @param duration 持续时间，纳秒
     */
    fun addLongTask(log: String, duration: Long)

    /**
     * 添加长任务
     *
     * @param log      日志内容
     * @param duration 持续时间，纳秒
     */

    fun addLongTask(log: String, duration: Long, property: HashMap<String, Any>)

// 场景 1
FTRUMGlobalManager.get().addLongTask("error log", 1000000L);

// 场景 2:动态参数
HashMap<String, Object> map = new HashMap<>();
map.put("ft_key", "ft_value");
FTRUMGlobalManager.get().addLongTask("", 1000000L, map);

// 场景 1
FTRUMGlobalManager.get().addLongTask("error log",1000000L)

// 场景 2:动态参数
 val map = HashMap<String, Any>()
 map["ft_key"] = "ft_value"
 FTRUMGlobalManager.get().addLongTask("", 1000000L,map)

    /**
     * resource 起始
     *
     * @param resourceId 资源 Id
     */
    public void startResource(String resourceId)

    /**
     * resource 起始
     *
     * @param resourceId 资源 Id
     */
    public void startResource(String resourceId, HashMap<String, Object> property)

    /**
     * resource 终止
     *
     * @param resourceId 资源 Id
     */
    public void stopResource(String resourceId)

    /**
     * resource 终止
         *
     * @param resourceId 资源 Id
     * @param property   附加属性参数
     */
    public void stopResource(final String resourceId, HashMap<String, Object> property)


    /**
     * 设置网络传输内容
     *
     * @param resourceId
     * @param params
     * @param netStatusBean
     */
    public void addResource(String resourceId, ResourceParams params, NetStatusBean netStatusBean)

/**
 * resource 起始
 *
 * @param resourceId 资源 Id
 */
fun startResource(resourceId: String)

/**
 * resource 起始
 *
 * @param resourceId 资源 Id
 */
fun startResource(resourceId: String, property: HashMap<String, Any>)

/**
 * resource 终止
 *
 * @param resourceId 资源 Id
 */
fun stopResource(resourceId: String)

/**
 * resource 终止
 *
 * @param resourceId 资源 Id
 * @param property   附加属性参数
 */
fun stopResource(resourceId: String, property: HashMap<String, Any>)

/**
 * 设置网络传输内容
 *
 * @param resourceId
 * @param params
 * @param netStatusBean
 */
fun addResource(resourceId: String, params: ResourceParams, netStatusBean: NetStatusBean)

// 场景 1
// 请求开始
FTRUMGlobalManager.get().startResource("resourceId");

//...

// 请求结束
FTRUMGlobalManager.get().stopResource("resourceId");

// 最后，在请求结束之后，发送请求相关的数据指标
ResourceParams params = new ResourceParams();
params.setUrl("https://www.guance.com");
params.setResponseContentType(response.header("Content-Type"));
params.setResponseConnection(response.header("Connection"));
params.setResponseContentEncoding(response.header("Content-Encoding"));
params.setResponseHeader(response.headers().toString());
params.setRequestHeader(request.headers().toString());
params.setResourceStatus(response.code());
params.setResourceMethod(request.method());

NetStatusBean bean = new NetStatusBean();
bean.setTcpStartTime(60000000);
//...

FTRUMGlobalManager.get().addResource("resourceId", params, bean);


// 场景 2 ：动态参数使用
HashMap<String, Object> map = new HashMap<>();
map.put("ft_key", "ft_value");
map.put("ft_key_will_change", "ft_value");

FTRUMGlobalManager.get().startResource("resourceId",map);

//...
HashMap<String, Object> map = new HashMap<>()；
map.put("ft_key_will_change", "ft_value_change"); //ft_key_will_change 这个数值，会在 stopResource 时候被修改为 ft_value_change
FTRUMGlobalManager.get().stopResource(uuid,map);

// 场景 1
//请求开始
FTRUMGlobalManager.get().startResource("resourceId")

//请求结束
FTRUMGlobalManager.get().stopResource("resourceId")

//最后，在请求结束之后，发送请求相关的数据指标
val params = ResourceParams()
params.url = "https://www.guance.com"
params.responseContentType = response.header("Content-Type")
arams.responseConnection = response.header("Connection")
params.responseContentEncoding = response.header("Content-Encoding")
params.responseHeader = response.headers.toString()
params.requestHeader = request.headers.toString()
params.resourceStatus = response.code
params.resourceMethod = request.method

val bean = NetStatusBean()
bean.tcpStartTime = 60000000
//...
FTRUMGlobalManager.get().addResource("resourceId",params,bean)

// 场景 2 ：动态参数使用
val map = hashMapOf<String, Any>(
        "ft_key" to "ft_value",
        "ft_key_will_change" to "ft_value"
)
FTRUMGlobalManager.get().startResource("resourceId", map)

//...
val map = hashMapOf<String, Any>(
        "ft_key_will_change" to "ft_value_change"
)
// ft_key_will_change 这个数值，会在 stopResource 时候被修改为 ft_value_change

FTRUMGlobalManager.get().stopResource(uuid, map)

    /**
     * 将单条日志数据存入本地同步
     *
     * @param content 日志内容
     * @param status  日志等级
     */
    public void logBackground(String content, Status status)

    /**
     * 将单条日志数据存入本地同步
     *
     * @param content 日志内容
     * @param status  日志等级
     */
    public void logBackground(String content, Status status, HashMap<String, Object> property)


    /**
     * 将多条日志数据存入本地同步
     *
     * @param logDataList {@link LogData} 列表
     */
    public void logBackground(List<LogData> logDataList)

    /**
     * 将单条日志数据存入本地同步
     *
     * @param content 日志内容
     * @param status  日志等级
     */
    fun logBackground(content: String, status: Status)

    /**
     * 将单条日志数据存入本地同步
     *
     * @param content 日志内容
     * @param status  日志等级
     * @param property 日志属性
     */
    fun logBackground(content: String, status: Status, property: HashMap<String, Any>)

    /**
     * 将多条日志数据存入本地同步
     *
     * @param logDataList 日志数据列表
     */
    fun logBackground(logDataList: List<LogData>)

// 上传单个日志
FTLogger.getInstance().logBackground("test", Status.INFO);

// 传递参数到 HashMap
HashMap<String, Object> map = new HashMap<>();
map.put("ft_key", "ft_value");
FTLogger.getInstance().logBackground("test", Status.INFO, map);

// 批量上传日志
List<LogData> logList = new ArrayList<>();
logList.add(new LogData("test", Status.INFO));
FTLogger.getInstance().logBackground(logList);

//上传单个日志
FTLogger.getInstance().logBackground("test", Status.INFO)

//传递参数到 HashMap
val map = HashMap<String,Any>()
map["ft_key"]="ft_value"
FTLogger.getInstance().logBackground("test", Status.INFO,map)

//批量上传日志
FTLogger.getInstance().logBackground(mutableListOf(LogData("test",Status.INFO)))

String url = "https://www.guance.com";
String uuid = "uuid";
// 获取链路头参数
Map<String, String> headers = FTTraceManager.get().getTraceHeader(uuid, url);

OkHttpClient client = new OkHttpClient.Builder().addInterceptor(chain -> {
    Request original = chain.request();
    Request.Builder requestBuilder = original.newBuilder();
    // 在请求中，添加链路头参数
    for (String key : headers.keySet()) {
        requestBuilder.header(key, headers.get(key));
    }
    Request request = requestBuilder.build();

    Response response = chain.proceed(request);

    if (response != null) {
        Map<String, String> requestHeaderMap = new HashMap<>();
        Map<String, String> responseHeaderMap = new HashMap<>();
        for (Pair<String, String> header : response.request().headers()) {
            requestHeaderMap.put(header.first, header.second);
        }
        for (Pair<String, String> header : response.headers()) {
            responseHeaderMap.put(header.first, header.second);
        }
    }

    return response;
}).build();

Request.Builder builder = new Request.Builder().url(url).method(RequestMethod.GET.name(), null);
client.newCall(builder.build()).execute();

val url = "https://www.guance.com"
val uuid ="uuid"
//获取链路头参数
val headers = FTTraceManager.get().getTraceHeader(uuid, url)

val client: OkHttpClient = OkHttpClient.Builder().addInterceptor { chain ->

                    val original = chain.request()
                    val requestBuilder = original.newBuilder()
                    //在请求中，添加链路头参数
                    for (key in headers.keys) {
                        requestBuilder.header(key!!, headers[key]!!)
                    }
                    val request = requestBuilder.build()

                    response = chain.proceed(request)

                    if (response != null) {
                        val requestHeaderMap = HashMap<String, String>()
                        val responseHeaderMap = HashMap<String, String>()
                        request.headers.forEach {
                            requestHeaderMap[it.first] = it.second
                        }
                        response!!.headers.forEach {
                            responseHeaderMap[it.first] = it.second

                        }

                    }

                    response!!
                }.build()

 val builder: Request.Builder = Request.Builder().url(url).method(RequestMethod.GET.name, null)
client.newCall(builder.build()).execute()

   /**
     * 绑定用户信息
     *
     * @param id
     */
    public static void bindRumUserData(@NonNull String id)

    /**
     * 绑定用户信息
     */
    public static void bindRumUserData(@NonNull UserData data)

/**
     * 绑定用户信息
     *
     * @param id 用户 ID
     */
    fun bindRumUserData(id: String) {
        // TODO: implement bindRumUserData method
    }

    /**
     * 绑定用户信息
     *
     * @param data 用户信息
     */
    fun bindRumUserData(data: UserData) {
        // TODO: implement bindRumUserData method
    }

// 可以在用户登录成功后调用此方法用来绑定用户信息
FTSdk.bindRumUserData("001");

UserData userData = new UserData();
userData.setName("test.user");
userData.setId("test.id");
userData.setEmail("test@mail.com");
Map<String, String> extMap = new HashMap<>();
extMap.put("ft_key", "ft_value");
userData.setExts(extMap);
FTSdk.bindRumUserData(userData);

// 可以在用户退出登录后调用此方法来解绑用户信息
FTSdk.unbindRumUserData();

//可以在用户登录成功后调用此方法用来绑定用户信息
FTSdk.bindRumUserData("001")


//绑定用户更多数据
val userData = UserData()
userData.name = "test.user"
userData.id = "test.id"
userData("test@mail.com")
val extMap = HashMap<String, String>()
extMap["ft_key"] = "ft_value"
userData.setExts(extMap)
FTSdk.bindRumUserData(userData)

//可以在用户退出登录后调用此方法来解绑用户信息
FTSdk.unbindRumUserData()

    /**
     * 关闭 SDK 内正在运行对象
     */
    public static void shutDown()

    /**
     * 关闭 SDK 内正在运行对象
     */
    fun shutDown()

//如果动态改变 SDK 配置，需要先关闭，以避免错误数据的产生
FTSdk.shutDown();

//如果动态改变 SDK 配置，需要先关闭，以避免错误数据的产生
FTSdk.shutDown()

   /**
     * 动态控制获取 Android ID
     *
     * @param enableAccessAndroidID 是为应用，否为不应用
     */
    public static void setEnableAccessAndroidID(boolean enableAccessAndroidID)

   /**
     * 动态控制获取 Android ID
     *
     * @param enableAccessAndroidID 是为应用，否为不应用
     */
    fun setEnableAccessAndroidID(enableAccessAndroidID:Boolean)

// 开启获取 Android ID
FTSdk.setEnableAccessAndroidID(true);

// 关闭获取 Android ID
FTSdk.setEnableAccessAndroidID(false);

//开启获取 Android ID
FTSdk.setEnableAccessAndroidID(true)

//关闭获取 Android ID
FTSdk.setEnableAccessAndroidID(false)

View.setOnClickListener(new View.OnClickListener() {
        @Override
        @IgnoreAOP
        public void onClick(View v) {

        }
    }

View.setOnClickListener @IngoreAOP{

    }

public class DemoApplication extends Application {
    @Override
    public void onCreate() {
        // 在初始化设置时将 setEnableAccessAndroidID 设置为 false
        FTSDKConfig config = new FTSDKConfig.Builder(DATAKIT_URL)
                .setEnableAccessAndroidID(false)
                .build();
        FTSdk.install(config);

        // ...
    }
}

// 用户同意隐私协议后再开启
FTSdk.setEnableAccessAndroidID(true);

class DemoApplication : Application() {
    override fun onCreate() {

        //在初始化设置时将  setEnableAccessAndroidID 设置为 false
        val config = FTSDKConfig
            .builder(DATAKIT_URL)
            . setEnableAccessAndroidID(false)

        FTSdk.install(config)

        //...
    }
}

//用户同意隐私协议后再开启
FTSdk.setEnableAccessAndroidID(true);

// Application
public class DemoApplication extends Application {
    @Override
    public void onCreate() {
        //如果已经同意协议，在 Application 中初始化
        if(agreeProtocol){
            FTSdk.init();
        }
    }
}

// 隐私声明  Activity 页面
public class MainActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        //未阅读隐私声明
        if ( notReadProtocol ) {
            //隐私声明弹出弹窗
            showProtocolView();

            //如果同意隐私声明
            if( agreeProtocol ){
                FTSdk.init();
            }
        }
    }
}

// Application  
class DemoApplication : Application() {
    override fun onCreate() {
        // 如果已经同意协议，在 Application 中初始化
        if (agreeProtocol) {
            FTSdk.init()
        }
    }
}

// 隐私声明 Activity 页面
class MainActivity : Activity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        // 未阅读隐私声明
        if (notReadProtocol) {
            // 隐私声明弹出弹窗
            showProtocolView()

            // 如果同意隐私声明
            if (agreeProtocol) {
                FTSdk.init()
            }
        }
    }
}

// Application
@Override
public void onCreate() {
    super.onCreate();
    //需要在 SDK 初始化前调用
    FTAutoTrack.startApp(null);
    //设置 SDK 配置
    setSDK(this);
}

  //Application
    override fun onCreate() {
        super.onCreate()
    //需要在 SDK 初始化前调用
        FTAutoTrack.startApp(null)
        //设置 SDK 配置
        setSDK(this)

    }

view.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        FTRUMGlobalManager.get().startAction("[action button]", "click");
    }
});

    view.setOnClickListener{
        FTRUMGlobalManager.get().startAction("[action button]", "click")
    }

OkHttpClient.Builder builder = new OkHttpClient.Builder()
.addInterceptor(new FTTraceInterceptor())
.addInterceptor(new FTResourceInterceptor())
.eventListenerFactory(new FTResourceEventListener.FTFactory());
OkHttpClient client = builder.build();

val builder = OkHttpClient.Builder()
.addInterceptor(FTTraceInterceptor())
.addInterceptor(FTResourceInterceptor())
.eventListenerFactory(FTResourceEventListener.FTFactory())
val client = builder.build()