acl_sdk 0.2.3

acl_sdk: ^0.2.3 copied to clipboard

example/lib/main.dart

import 'dart:async';

import 'package:acl_sdk/acl_sdk.dart';
import 'package:acl_sdk/database/data_models/app_config.dart';
import 'package:acl_sdk/helpers/device_info_helper.dart';
import 'package:acl_sdk/helpers/permission_helper.dart';
import 'package:acl_sdk/work_manager_dispatchers/acl_fcm_on_receive_handler.dart';
import 'package:acl_sdk_example/firebase_options.dart';
import 'package:firebase_core/firebase_core.dart';
import 'package:firebase_messaging/firebase_messaging.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:permission_handler/permission_handler.dart';

void main() {
  // WidgetsFlutterBinding.ensureInitialized();
  runApp(const MyApp());
}

class MyApp extends StatefulWidget {
  const MyApp({super.key});

  @override
  State<MyApp> createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> with WidgetsBindingObserver {
  String _platformVersion = 'Unknown';
  String _deviceId = 'Unknown';
  bool _isAllowAppUsage = false;
  bool _isAllowLocationAlways = false;
  bool _isAllowNotificationListener = false;

  final _aclSdkPlugin = AclSdk();

  @override
  void initState() {
    super.initState();
    initPlatformState();
  }

  @override
  void didChangeAppLifecycleState(AppLifecycleState state) async {
    if (state == AppLifecycleState.resumed) {
      bool allowAppUsage = await PermissionHelper.isPackageUsageStatsEnable();
      bool allowLocationAlways =
          await Permission.locationAlways.status.isGranted;
      bool allowNotificationListener =
          await PermissionHelper.isNotificationListenerRunning();
      setState(() {
        _isAllowAppUsage = allowAppUsage;
        _isAllowLocationAlways = allowLocationAlways;
        _isAllowNotificationListener = allowNotificationListener;
      });
    }
    super.didChangeAppLifecycleState(state);
  }

  // Platform messages are asynchronous, so we initialize in an async method.
  Future<void> initPlatformState() async {
    String platformVersion;
    bool allowAppUsage = false;
    bool allowLocationAlways = false;
    bool allowNotificationListener = false;
    // Platform messages may fail, so we use a try/catch PlatformException.
    // We also handle the message potentially returning null.
    try {
      // init firebase
      await Firebase.initializeApp(
          options: DefaultFirebaseOptions.currentPlatform);
      await FirebaseMessaging.instance.requestPermission();
      // set the background messaging handler
      FirebaseMessaging.onBackgroundMessage(aclFCMOnReceiveHandler);
      FirebaseMessaging.onMessage.listen(aclFCMOnReceiveHandler);

      platformVersion = await _aclSdkPlugin.getPlatformVersion() ??
          'Unknown platform version';
      allowAppUsage = await PermissionHelper.isPackageUsageStatsEnable();
      // allowLocationAlways = (await LocationPermissions().checkPermissionStatus(
      //         level: LocationPermissionLevel.locationAlways)) ==
      //     PermissionStatus.granted;
      allowLocationAlways = await Permission.locationAlways.status.isGranted;
      allowNotificationListener =
          await PermissionHelper.isNotificationListenerRunning();

      // To get device id
      _deviceId = await DeviceInfoHelper.generateDeviceId();

      // To init SDK plugin
      await _aclSdkPlugin.initialize(
        AppConfigCreateInput(
          partnerId: '',
          apiEndpoint: '',
          apiKey: '',
          apiSecret: '',
          appBundle: '',
        ),
        isInDebugMode: true,
      );
      await _aclSdkPlugin.registerDevice();
      await _aclSdkPlugin.mapDeviceMember('hello-world');
      await _aclSdkPlugin.startCollectData();
      await _aclSdkPlugin.startCollectLocation();
    } on PlatformException {
      platformVersion = 'Failed to get platform version.';
    }

    // If the widget was removed from the tree while the asynchronous platform
    // message was in flight, we want to discard the reply rather than calling
    // setState to update our non-existent appearance.
    if (!mounted) return;

    setState(() {
      _platformVersion = platformVersion;
      _isAllowAppUsage = allowAppUsage;
      _isAllowLocationAlways = allowLocationAlways;
      _isAllowNotificationListener = allowNotificationListener;
    });
  }

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      debugShowCheckedModeBanner: false,
      home: Scaffold(
        appBar: AppBar(
          title: const Text('Plugin example app'),
        ),
        body: Center(
          child: Column(
            children: [
              Text(_deviceId),
              Text('Running on: $_platformVersion\n'),
              ElevatedButton(
                onPressed: _handleAllowAppUsageClick,
                child: Text(
                  _isAllowAppUsage == true
                      ? 'Allowed app usage access'
                      : 'Press to allow app usage access!',
                ),
              ),
              ElevatedButton(
                onPressed: _handleAllowLocationAlwaysClick,
                child: Text(
                  _isAllowLocationAlways == true
                      ? 'Allowed location always access'
                      : 'Press to allow location always access!',
                ),
              ),
              ElevatedButton(
                onPressed: _handleAllowNotificationListenerClick,
                child: Text(
                  _isAllowNotificationListener == true
                      ? 'Allowed notification listener access'
                      : 'Press to allow notification listener access!',
                ),
              ),
            ],
          ),
        ),
      ),
    );
  }

  void _handleAllowAppUsageClick() async {
    final isAlreadyAllow = await PermissionHelper.isPackageUsageStatsEnable();
    if (isAlreadyAllow == false) {
      await PermissionHelper.goToAppUsageSetting();
    }
  }

  void _handleAllowLocationAlwaysClick() async {
    var permission = await Permission.locationWhenInUse.request();
    permission = await Permission.locationAlways.request();
    if (permission.isGranted) {
      return;
    }

    if (!permission.isDenied) {
      permission = await Permission.locationAlways.request();
    }

    setState(() {
      _isAllowLocationAlways = permission.isGranted;
    });
    // if (Platform.isIOS) {
    //   // var permission = await LocationPermissions().requestPermissions(
    //   //     permissionLevel: LocationPermissionLevel.locationWhenInUse);
    //   // permission = await LocationPermissions().requestPermissions(
    //   //     permissionLevel: LocationPermissionLevel.locationAlways);
    //   // if (permission == PermissionStatus.granted) {
    //   //   return;
    //   // }

    //   // if (permission != PermissionStatus.denied) {
    //   //   LocationPermissions().requestPermissions(
    //   //       permissionLevel: LocationPermissionLevel.locationAlways);
    //   // }
    //   var permission = await Permission.locationWhenInUse.request();
    //   permission = await Permission.locationAlways.request();
    //   if (permission.isGranted) {
    //     return;
    //   }

    //   if (!permission.isDenied) {
    //     permission = await Permission.locationAlways.request();
    //   }

    //   setState(() {
    //     _isAllowLocationAlways = permission.isGranted;
    //   });
    // } else {
    //   final permission = await Geolocator.requestPermission();
    //   if (permission == LocationPermission.always) {
    //     return;
    //   }

    //   if (permission != LocationPermission.denied &&
    //       permission != LocationPermission.deniedForever) {
    //     Geolocator.openAppSettings();
    //   }

    //   setState(() {
    //     _isAllowLocationAlways = permission == LocationPermission.always;
    //   });
    // }

    await _aclSdkPlugin.startCollectLocation();
  }

  void _handleAllowNotificationListenerClick() async {
    final isAlreadyAllow =
        await PermissionHelper.isNotificationListenerRunning();
    if (isAlreadyAllow == false) {
      await PermissionHelper.goToNotificationListenerSetting();
    }
  }
}