Flutter Application Integration¶

 $ flutter pub add ft_mobile_agent_flutter

dependencies:
  ft_mobile_agent_flutter: [lastest_version]

  # For compatibility with Flutter 2.0, use the following reference method
  ft_mobile_agent_flutter:
    git:
      url: https://github.com/GuanceCloud/datakit-flutter.git
      ref: [github_legacy_lastest_tag]

import 'package:ft_mobile_agent_flutter/ft_mobile_agent_flutter.dart';

import io.flutter.app.FlutterApplication

/**
* If you need to count [Launch Counts] and [Launch Time], you need to add a custom Application here
*/
class CustomApplication : FlutterApplication() {
}

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="com.cloudcare.ft.mobile.sdk.agent_example">
  <application android:name=".CustomApplication">
    //...
  </application>
</manifest>

void main() async {
    WidgetsFlutterBinding.ensureInitialized();
    //Local environment deployment, Datakit deployment
    await FTMobileFlutter.sdkConfig(
      datakitUrl: datakitUrl
    );

    //Use public DataWay
    await FTMobileFlutter.sdkConfig(
      datawayUrl: datawayUrl,
      cliToken: cliToken,
    );
}  

 await FTRUMManager().setConfig(
        androidAppId: appAndroidId, 
        iOSAppId: appIOSId,
    );

///main_prod.dart
void main() async {
    WidgetsFlutterBinding.ensureInitialized();
    //Initialize SDK
    await FTMobileFlutter.sdkConfig(
      datakitUrl: serverUrl,
      debug: true,
    );
    await FTRUMManager().setConfig(
        androidAppId: appAndroidId,
        iOSAppId: appIOSId,
        globalContext: {CUSTOM_STATIC_TAG:"prod_static_tag"},
    );
    runApp(MyApp());
  };

final prefs = await SharedPreferences.getInstance();
String customDynamicValue = prefs.getString("customDynamicValue")?? "not set";

 await FTRUMManager().setConfig(
        androidAppId: appAndroidId,
        iOSAppId: appIOSId,
        globalContext: {CUSTOM_DYNAMIC_TAG:customDynamicValue},
        //… Add other configurations
    );

 static Future<void> setDynamicParams(String value) async{
    final prefs = await SharedPreferences.getInstance();
    prefs.setString(CUSTOM_DYNAMIC_TAG, value);
  }

 await FTLogger().logConfig(
   enableCustomLog: true
 );

await FTTracer().setConfig(
  enableLinkRUMData: true,
  enableAutoTrace: true,
);

  /// Add action
  /// [actionName] action name
  /// [actionType] action type
  /// [property] additional property parameters (optional)
  Future<void> startAction(String actionName, String actionType, 
  {Map<String, String>? property})

FTRUMManager().startAction("action name", "action type");

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: HomeRoute(),
      navigatorObservers: [
        //RUM View: Monitor page lifecycle when using route navigation
        FTRouteObserver(),
      ],
      routes: <String, WidgetBuilder>{
        //Set Route route navigation
        'logging': (BuildContext context) => Logging(),
        'rum': (BuildContext context) => RUM(),
        'tracing_custom': (BuildContext context) => CustomTracing(),
        'tracing_auto': (BuildContext context) => AutoTracing(),
      },
    );
  }
}

//Use this method for page navigation, the page name here is logging
Navigator.pushNamed(context, "logging");

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: HomeRoute(),
      navigatorObservers: [
        //RUM View: Monitor page lifecycle when using route navigation
        FTRouteObserver(),
      ],
    );
  }
}

//Here "page name" is NoRouteNamePage
Navigator.of(context).push(FTMaterialPageRoute(builder: (context) => 
    new NoRouteNamePage()

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: HomeRoute(),
      navigatorObservers: [
        //RUM View: Monitor page lifecycle when using route navigation
        FTRouteObserver(),
      ],
    );
  }
}

//Here "page name" is "RouteSettingName"
Navigator.of(context).push(
          MaterialPageRoute(
              builder: (context) => new NoRouteNamePage(),
              settings: RouteSettings(name: "RouteSettingName"))

class _HomeState extends State<HomeRoute> {

    @override
    void initState(){

        //Add application sleep and wake listener
        FTLifeRecycleHandler().initObserver();
    }

    @override
    void dispose(){

        //Remove application sleep and wake listener
        FTLifeRecycleHandler().removeObserver();
    }
}

MaterialApp(
  navigatorObservers: [
        // RUM View: routeFilter filters pages that do not need to be monitored
         FTRouteObserver(routeFilter: (Route? route, Route? previousRoute) {
          if (filterConfig) {
            //Do not collect
            return true;
           }
           return false;
        }),
])

MaterialApp(
  navigatorObservers: [
    //RUM View filter DialogRoute type components
    FTDialogRouteFilterObserver(filterOnlyNoSettingName: true)
])

// Here the Dialog will be collected if filterOnlyNoSettingName is true.
// view_name is "About"
showAboutDialog(
            context: context, routeSettings: RouteSettings(name: "About"));

  /// view creation, this method needs to be called before [starView], currently flutter route does not have
  /// [viewName] page name
  /// [duration]
  Future<void> createView(String viewName, int duration)

  /// view start
  /// [viewName] page name
  /// [viewReferer] previous page name
  /// [property] additional property parameters (optional)
  Future<void> starView(String viewName, {Map<String, String>? property})

  /// view end
  /// [property] additional property parameters (optional)
  Future<void> stopView({Map<String, String>? property})

FTRUMManager().createView("Current Page Name", 100000000)

FTRUMManager().starView("Current Page Name");

FTRUMManager().stopView();

void main() async {
  runZonedGuarded(() async {
    WidgetsFlutterBinding.ensureInitialized();
    await FTMobileFlutter.sdkConfig(
      datakitUrl: serverUrl,
      debug: true,
    );
    await FTRUMManager().setConfig(
        androidAppId: appAndroidId,
        iOSAppId: appIOSId,
    );

    // Flutter exception capture
    FlutterError.onError = FTRUMManager().addFlutterError;
    runApp(MyApp());
  }, (Object error, StackTrace stack) {
    //Add Error data
    FTRUMManager().addError(error, stack);
  });

  ///Add custom error
  /// [stack] stack log
  /// [message] error message
  /// [appState] application state
  /// [errorType] custom errorType
  /// [property] additional property parameters (optional)
  Future<void> addCustomError(String stack, String message,
   {Map<String, String>? property, String? errorType}) 

 ///Custom error
 FTRUMManager().addCustomError("error stack", "error message");

  ///Start resource request
  /// [key] unique id
  /// [property] additional property parameters (optional)
  Future<void> startResource(String key, {Map<String, String>? property})

  ///End resource request
  /// [key] unique id
  /// [property] additional property parameters (optional)
  Future<void> stopResource(String key, {Map<String, String>? property})

  /// Send resource data metrics
  /// [key] unique id
  /// [url] request URL
  /// [httpMethod] request method
  /// [requestHeader] request header parameters
  /// [responseHeader] response header parameters
  /// [responseBody] response content
  /// [resourceStatus] response status code
  Future<void> addResource(
      {required String key,
      required String url,
      required String httpMethod,
      required Map<String, dynamic> requestHeader,
      Map<String, dynamic>? responseHeader,
      String? responseBody = "",
      int? resourceStatus})

/// Use httpClient  
void httpClientGetHttp(String url) async {
    var httpClient = new HttpClient();
    String key = Uuid().v4();
    HttpClientResponse? response;
    HttpClientRequest? request;
    try {
      request = await httpClient
          .getUrl(Uri.parse(url))
          .timeout(Duration(seconds: 10));
      FTRUMManager().startResource(key);
      response = await request.close();
    } finally {
      Map<String, dynamic> requestHeader = {};
      Map<String, dynamic> responseHeader = {};

      request!.headers.forEach((name, values) {
        requestHeader[name] = values;
      });
      var responseBody = "";
      if (response != null) {
        response.headers.forEach((name, values) {
          responseHeader[name] = values;
        });
        responseBody = await response.transform(Utf8Decoder()).join();
      }
      FTRUMManager().stopResource(key);
      FTRUMManager().addResource(
        key: key,
        url: request.uri.toString(),
        requestHeader: requestHeader,
        httpMethod: request.method,
        responseHeader: responseHeader,
        resourceStatus: response?.statusCode,
        responseBody: responseBody,
      );
    }
  }

  ///Output log
  ///[content] log content
  ///[status] log status
  ///[property] additional property parameters (optional)
  Future<void> logging(String content, FTLogStatus status, {Map<String, String>? property})

FTLogger().logging("info log content", FTLogStatus.info);

  /// Get trace http request header data
  /// [key] unique id
  /// [url] request URL
  ///
  Future<Map<String, String>> getTraceHeader(String url, {String? key})

/// Use httpClient    
void httpClientGetHttp() async {
    var url = 'http://reqeust.url.cn';
    var httpClient = new HttpClient();
    String key = DateTime.now().millisecondsSinceEpoch.toString() + url;
    var errorMessage = "";
    HttpClientRequest request = await httpClient.getUrl(Uri.parse(url));
    HttpClientResponse? response;
    try {
      final traceHeaders =
          await FTTracer().getTraceHeader(key, request.uri.toString());
      traceHeaders.forEach((key, value) {
        request.headers.add(key, value);
      });
      response = await request.close();
    } catch (exception) {
      errorMessage = exception.toString();
    } finally {
      Map<String, dynamic> requestHeader = {};
      Map<String, dynamic> responseHeader = {};

      request.headers.forEach((name, values) {
        requestHeader[name] = values;
      });
      if (response != null) {
        response.headers.forEach((name, values) {
          responseHeader[name] = values;
        });
      }
    }
  }

  ///Bind user
  ///
  ///[userid] user id
  ///[userName] user name
  ///[userEmail] user email
  ///[userExt] extended data
  static Future<void> bindRUMUserData(String userId,
      {String? userName, String? userEmail, Map<String, String>? ext})

  ///Unbind user
  static Future<void> unbindRUMUserData()

 FTMobileFlutter.bindUser("flutterUser");

 FTMobileFlutter.unbindUser();

FTMobileFlutter.flushSyncData();

await FTMobileFlutter.sdkConfig(
    dataModifier: {"device_uuid":"xxx"},
    lineDataModifier: {"view":{"view_name":"xxx"}}
)