wisetrack_sdk 1.0.6

wisetrack_sdk: ^1.0.6 copied to clipboard

example/lib/main.dart

import 'package:example/Configs.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'package:wisetrack_sdk/wisetrack.dart';
import 'package:wisetrack_sdk/wisetrack_attribution.dart';
import 'package:wisetrack_sdk/wisetrack_config.dart';
import 'package:wisetrack_sdk/wisetrack_currency.dart';
import 'package:wisetrack_sdk/wisetrack_event.dart';
import 'package:wisetrack_sdk/wisetrack_event_failure.dart';
import 'package:wisetrack_sdk/wisetrack_event_success.dart';
import 'package:wisetrack_sdk/wisetrack_session_failure.dart';
import 'package:wisetrack_sdk/wisetrack_session_success.dart';
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';

import 'util.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        // This is the theme of your application.
        //
        // Try running your application with "flutter run". You'll see the
        // application has a blue toolbar. Then, without quitting the app, try
        // changing the primarySwatch below to Colors.green and then invoke
        // "hot reload" (press "r" in the console where you ran "flutter run",
        // or simply save your changes to "hot reload" in a Flutter IDE).
        // Notice that the counter didn't reset back to zero; the application
        // is not restarted.
        primarySwatch: Colors.blue,
        // This makes the visual density adapt to the platform that you run
        // the app on. For desktop platforms, the controls will be smaller and
        // closer together (more dense) than on mobile platforms.
        visualDensity: VisualDensity.adaptivePlatformDensity,
      ),
      home: MyHomePage(title: 'Flutter Demo Home Page'),
    );
  }
}

class MyHomePage extends StatefulWidget {
  MyHomePage({Key? key, this.title}) : super(key: key);

  // This widget is the home page of your application. It is stateful, meaning
  // that it has a State object (defined below) that contains fields that affect
  // how it looks.

  // This class is the configuration for the state. It holds the values (in this
  // case the title) provided by the parent (in this case the App widget) and
  // used by the build method of the State. Fields in a Widget subclass are
  // always marked "final".

  final String? title;

  @override
  _MyHomePageState createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage>  with WidgetsBindingObserver {
  final _formKey = GlobalKey<FormState>();
  final _eventTokenController = TextEditingController();
  final _eventNameController = TextEditingController();
  final _eventPriceController = TextEditingController();
  final _eventCurrencyController = TextEditingController();
  String _selectedCurrency = "USD";

  bool _isSdkEnabled = true;
  bool _isFirstLaunch = true;
  String environment = '';

  String defaultTracker = '';
  String appToken = '';
  String storeName = '';
  Configs configtoken = new Configs();

  @override
  initState() {
    super.initState();
     WidgetsBinding.instance.addObserver(this);

    _checkFirstLaunch();
  }

  Future<void> _checkFirstLaunch() async {
    SharedPreferences prefs = await SharedPreferences.getInstance();
    bool isConfigured = prefs.getBool('isConfigured') ?? false;
    environment = prefs.getString('environment') ?? '';
    appToken = prefs.getString('appToken') ?? '';
    defaultTracker = prefs.getString('defaultTracker') ?? '';
    storeName = prefs.getString('StoreName') ?? '';

    if (!isConfigured) {
      //initPlatformState();
       _showConfigDialog();
    } else {
      initPlatformState();
    }
  }

  void _showConfigDialog() {
    TextEditingController tokenController = TextEditingController();
    TextEditingController trackerController = TextEditingController();
    TextEditingController storeNameController = TextEditingController();
    String selectedEnvironment = "Production";

    showDialog(
      context: context,
      barrierDismissible: false,
      builder: (BuildContext context) {
        return AlertDialog(
          title: Text('App Configuration'),
          content: Column(
            mainAxisSize: MainAxisSize.min,
            children: [
              TextField(
                controller: tokenController,
                decoration: InputDecoration(labelText: 'App Token'),
              ),
              TextField(
                controller: trackerController,
                decoration: InputDecoration(labelText: 'Default Tracker'),
              ),
              TextField(
                controller: storeNameController,
                decoration: InputDecoration(labelText: 'Store Name'),
              ),
              DropdownButton<String>(
                value: selectedEnvironment,
                items: ['Production', 'Stage', 'Debug']
                    .map((env) => DropdownMenuItem(
                          value: env,
                          child: Text(env),
                        ))
                    .toList(),
                onChanged: (value) {
                  setState(() {
                    selectedEnvironment = value!;
                  });
                },
              ),
            ],
          ),
          actions: [
            TextButton(
              onPressed: () async {
                if (tokenController.text.isEmpty) {
                  ScaffoldMessenger.of(context).showSnackBar(
                    SnackBar(content: Text('All fields are required')),
                  );
                  return;
                }

                SharedPreferences prefs = await SharedPreferences.getInstance();
                await prefs.setBool('isConfigured', true);
                await prefs.setString('appToken', tokenController.text);
                await prefs.setString('defaultTracker', trackerController.text);
                await prefs.setString('storeName', storeNameController.text);
                await prefs.setString(
                    'environment', selectedEnvironment.toLowerCase());

                environment = prefs.getString('environment') ?? '';
                appToken = prefs.getString('appToken') ?? '';
                defaultTracker = prefs.getString('defaultTracker') ?? '';
                storeName = prefs.getString('storeName') ?? '';

                if (environment.isEmpty || appToken.isEmpty) {
                  initPlatformState();
                } else {
                  initPlatformState();
                  print("data is not true");
                }

                Navigator.of(context).pop();
              },
              child: Text('Save'),
            ),
          ],
        );
      },
    );
  }

  @override
  void dispose() {
    WidgetsBinding.instance.removeObserver(this );
    super.dispose();
  }

  @override
  void didChangeAppLifecycleState(AppLifecycleState state) {
    switch (state) {
      case AppLifecycleState.inactive:
        break;
      case AppLifecycleState.resumed:
        print('start RRRR onResume -----');
        WiseTrack.onResume();
        break;
      case AppLifecycleState.paused:
        WiseTrack.onPause();
        break;
      case AppLifecycleState.detached:
        break;
    }
  }

  // Platform messages are asynchronous, so we initialize in an async method.
  initPlatformState() async {

    await Future.delayed(Duration.zero, () {

      print("data is not true ::: ${environment}");
      if (environment.isEmpty || appToken.isEmpty) {
        return;
      }

      configtoken.inti(ConfigType.stage);

      WiseTrackConfig config =
      new WiseTrackConfig(appToken, WiseTrackEnvironment.sandbox);
      // config.logLevel = WiseTrackLogLevel.verbose;
      config.processName = "com.wisetrack.flutter.examples";

      config.setAppSecret(159957537531, 1236987415000, 25852, 14741, 789987);

      if (defaultTracker.length > 0) {
        config.defaultTracker = defaultTracker;
      }

      if (environment.length > 0) {
        config.packageName = environment;
      }

      if (storeName.length > 0) {
        config.storeName = storeName;
      }

      config.attributionCallback = (WiseTrackAttribution attributionChangedData) {
        print('[WiseTrack]: Attribution changed!');

        if (attributionChangedData.trackerToken != null) {
          print('[WiseTrack]: Tracker token: ' +
              attributionChangedData.trackerToken!);
        }
        if (attributionChangedData.trackerName != null) {
          print('[WiseTrack]: Tracker name: ' +
              attributionChangedData.trackerName!);
        }
        if (attributionChangedData.campaign != null) {
          print('[WiseTrack]: Campaign: ' + attributionChangedData.campaign!);
        }
        if (attributionChangedData.network != null) {
          print('[WiseTrack]: Network: ' + attributionChangedData.network!);
        }
        if (attributionChangedData.creative != null) {
          print('[WiseTrack]: Creative: ' + attributionChangedData.creative!);
        }
        if (attributionChangedData.adgroup != null) {
          print('[WiseTrack]: Adgroup: ' + attributionChangedData.adgroup!);
        }
        if (attributionChangedData.clickLabel != null) {
          print(
              '[WiseTrack]: Click label: ' + attributionChangedData.clickLabel!);
        }
        if (attributionChangedData.costType != null) {
          print('[WiseTrack]: Cost type: ' + attributionChangedData.costType!);
        }
        if (attributionChangedData.costAmount != null) {
          print('[WiseTrack]: Cost amount: ' +
              attributionChangedData.costAmount!.toString());
        }
        if (attributionChangedData.costCurrency != null) {
          print('[WiseTrack]: Cost currency: ' +
              attributionChangedData.costCurrency!);
        }
      };

      config.sessionSuccessCallback =
          (WiseTrackSessionSuccess sessionSuccessData) {
        print('[WiseTrack]: Session tracking success!');

        if (sessionSuccessData.message != null) {
          print('[WiseTrack]: Message: ' + sessionSuccessData.message!);
        }
        if (sessionSuccessData.timestamp != null) {
          print('[WiseTrack]: Timestamp: ' + sessionSuccessData.timestamp!);
        }
        if (sessionSuccessData.adid != null) {
          print('[WiseTrack]: Adid: ' + sessionSuccessData.adid!);
        }
        if (sessionSuccessData.jsonResponse != null) {
          print(
              '[WiseTrack]: JSON response: ' + sessionSuccessData.jsonResponse!);
        }
      };

      config.sessionFailureCallback =
          (WiseTrackSessionFailure sessionFailureData) {
        print('[WiseTrack]: Session tracking failure!');

        if (sessionFailureData.message != null) {
          print('[WiseTrack]: Message: ' + sessionFailureData.message!);
        }
        if (sessionFailureData.timestamp != null) {
          print('[WiseTrack]: Timestamp: ' + sessionFailureData.timestamp!);
        }
        if (sessionFailureData.adid != null) {
          print('[WiseTrack]: Adid: ' + sessionFailureData.adid!);
        }
        if (sessionFailureData.willRetry != null) {
          print('[WiseTrack]: Will retry: ' +
              sessionFailureData.willRetry.toString());
        }
        if (sessionFailureData.jsonResponse != null) {
          print(
              '[WiseTrack]: JSON response: ' + sessionFailureData.jsonResponse!);
        }
      };

      config.eventSuccessCallback = (WiseTrackEventSuccess eventSuccessData) {
        print('[WiseTrack]: Event tracking success!');

        if (eventSuccessData.eventToken != null) {
          print('[WiseTrack]: Event token: ' + eventSuccessData.eventToken!);
        }
        if (eventSuccessData.message != null) {
          print('[WiseTrack]: Message: ' + eventSuccessData.message!);
        }
        if (eventSuccessData.timestamp != null) {
          print('[WiseTrack]: Timestamp: ' + eventSuccessData.timestamp!);
        }
        if (eventSuccessData.adid != null) {
          print('[WiseTrack]: Adid: ' + eventSuccessData.adid!);
        }
        if (eventSuccessData.callbackId != null) {
          print('[WiseTrack]: Callback ID: ' + eventSuccessData.callbackId!);
        }
        if (eventSuccessData.jsonResponse != null) {
          print('[WiseTrack]: JSON response: ' + eventSuccessData.jsonResponse!);
        }
      };

      config.eventFailureCallback = (WiseTrackEventFailure eventFailureData) {
        print('[WiseTrack]: Event tracking failure!');

        if (eventFailureData.eventToken != null) {
          print('[WiseTrack]: Event token: ' + eventFailureData.eventToken!);
        }
        if (eventFailureData.message != null) {
          print('[WiseTrack]: Message: ' + eventFailureData.message!);
        }
        if (eventFailureData.timestamp != null) {
          print('[WiseTrack]: Timestamp: ' + eventFailureData.timestamp!);
        }
        if (eventFailureData.adid != null) {
          print('[WiseTrack]: Adid: ' + eventFailureData.adid!);
        }
        if (eventFailureData.callbackId != null) {
          print('[WiseTrack]: Callback ID: ' + eventFailureData.callbackId!);
        }
        if (eventFailureData.willRetry != null) {
          print('[WiseTrack]: Will retry: ' +
              eventFailureData.willRetry.toString());
        }
        if (eventFailureData.jsonResponse != null) {
          print('[WiseTrack]: JSON response: ' + eventFailureData.jsonResponse!);
        }
      };

      config.deferredDeeplinkCallback = (String? uri) {
        print('[WiseTrack]: Received deferred deeplink: ' + uri!);
      };

      config.skanUpdatedCallback = (Map<String, String> skanUpdateData) {
        print('[WiseTrack]: Received SKAN update information!');
        if (skanUpdateData["conversion_value"] != null) {
          print('[WiseTrack]: Conversion value: ' +
              skanUpdateData["conversion_value"]!);
        }
        if (skanUpdateData["coarse_value"] != null) {
          print('[WiseTrack]: Coarse value: ' + skanUpdateData["coarse_value"]!);
        }
        if (skanUpdateData["lock_window"] != null) {
          print('[WiseTrack]: Lock window: ' + skanUpdateData["lock_window"]!);
        }
        if (skanUpdateData["error"] != null) {
          print('[WiseTrack]: Error: ' + skanUpdateData["error"]!);
        }
      };

      // Add session callback parameters.
      WiseTrack.addGlobalCallbackParameter('scp_foo_1', 'scp_bar');
      WiseTrack.addGlobalCallbackParameter('scp_foo_2', 'scp_value');

      // Add session Partner parameters.
      WiseTrack.addGlobalPartnerParameter('spp_foo_1', 'spp_bar');
      WiseTrack.addGlobalPartnerParameter('spp_foo_2', 'spp_value');

      // Remove session callback parameters.
      WiseTrack.removeGlobalCallbackParameter('scp_foo_1');
      WiseTrack.removeGlobalPartnerParameter('spp_foo_1');

      // Clear all session callback parameters.
      WiseTrack.removeGlobalCallbackParameters();

      // Clear all session partner parameters.
      WiseTrack.removeGlobalPartnerParameters();

      // Ask for tracking consent.
      WiseTrack.requestAppTrackingAuthorization().then((status) {
        print('[WiseTrack]: Authorization status update!');
        switch (status) {
          case 0:
            print(
                '[WiseTrack]: Authorization status update: ATTrackingManagerAuthorizationStatusNotDetermined');
            break;
          case 1:
            print(
                '[WiseTrack]: Authorization status update: ATTrackingManagerAuthorizationStatusRestricted');
            break;
          case 2:
            print(
                '[WiseTrack]: Authorization status update: ATTrackingManagerAuthorizationStatusDenied');
            break;
          case 3:
            print(
                '[WiseTrack]: Authorization status update: ATTrackingManagerAuthorizationStatusAuthorized');
            break;
        }
      });

      // start SDK
      WiseTrack.initSdk(config);
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Event Details'),
      ),
      body: Padding(
        padding: const EdgeInsets.all(16.0),
        child: Form(
          key: _formKey,
          child: Column(
            crossAxisAlignment: CrossAxisAlignment.start,
            children: <Widget>[
              TextFormField(
                controller: _eventTokenController,
                decoration: const InputDecoration(
                  labelText: 'Event Token',
                ),
                validator: (value) {

                  return null;
                },
              ),
              const SizedBox(height: 16.0),
              TextFormField(
                controller: _eventNameController,
                decoration: const InputDecoration(
                  labelText: 'Event Name',
                ),
                validator: (value) {
                  if (value == null || value.isEmpty) {
                    return 'Please enter event name';
                  }
                  return null;
                },
              ),
              const SizedBox(height: 16.0),
              TextFormField(
                controller: _eventPriceController,
                decoration: const InputDecoration(
                  labelText: 'Event Price',
                ),
                keyboardType: TextInputType.number,
                validator: (value) {
                },
              ),
              const SizedBox(height: 16.0),

              DropdownButton<String>(
                value: _selectedCurrency,
                items: [
                  'USD',
                  'EUR',
                  'JPY',
                  'GBP',
                  'AUD',
                  'CAD',
                  'CHF',
                  'CNY',
                  'SEK',
                  'NZD',
                  'MXN',
                  'SGD',
                  'HKD',
                  'NOK',
                  'KRW',
                  'TRY',
                  'RUB',
                  'INR',
                  'BRL',
                  'ZAR',
                  'IRR',
                  'AED',
                  'IQD',
                  'SAR',
                  'OMR',
                  'BTC',
                  'EHT',
                  'LTC'
                ]
                    .map((env) => DropdownMenuItem(
                          value: env,
                          child: Text(env),
                        ))
                    .toList(),
                onChanged: (value) {
                  setState(() {
                    _selectedCurrency = value!;
                  });
                },
              ),

              const SizedBox(height: 24.0),
              ElevatedButton(
                onPressed: () {
                  if (_formKey.currentState!.validate()) {
                    // Process data here
                    String eventToken = _eventTokenController.text;
                    String eventName = _eventNameController.text;
                    String eventPrice = _eventPriceController.text;
                    String eventCurrency = _eventCurrencyController.text;

                    WiseTrackEvent event = WiseTrackEvent(eventToken);
                    if (eventName.isNotEmpty) {
                      event.setEventName(eventName);
                    }


                    // Default currency
                    WiseTrackCurrency currency = WiseTrackCurrency.USD;

                    // Compare and assign the correct enum value
                    if (_selectedCurrency.contains('USD')) {
                      currency = WiseTrackCurrency.USD;
                    } else if (_selectedCurrency.contains('EUR')) {
                      currency = WiseTrackCurrency.EUR;
                    } else if (_selectedCurrency.contains('JPY')) {
                      currency = WiseTrackCurrency.JPY;
                    } else if (_selectedCurrency.contains('GBP')) {
                      currency = WiseTrackCurrency.GBP;
                    } else if (_selectedCurrency.contains('AUD')) {
                      currency = WiseTrackCurrency.AUD;
                    } else if (_selectedCurrency.contains('CAD')) {
                      currency = WiseTrackCurrency.CAD;
                    } else if (_selectedCurrency.contains('CHF')) {
                      currency = WiseTrackCurrency.CHF;
                    } else if (_selectedCurrency.contains('CNY')) {
                      currency = WiseTrackCurrency.CNY;
                    } else if (_selectedCurrency.contains('SEK')) {
                      currency = WiseTrackCurrency.SEK;
                    } else if (_selectedCurrency.contains('NZD')) {
                      currency = WiseTrackCurrency.NZD;
                    } else if (_selectedCurrency.contains('MXN')) {
                      currency = WiseTrackCurrency.MXN;
                    } else if (_selectedCurrency.contains('SGD')) {
                      currency = WiseTrackCurrency.SGD;
                    } else if (_selectedCurrency.contains('HKD')) {
                      currency = WiseTrackCurrency.HKD;
                    } else if (_selectedCurrency.contains('NOK')) {
                      currency = WiseTrackCurrency.NOK;
                    } else if (_selectedCurrency.contains('KRW')) {
                      currency = WiseTrackCurrency.KRW;
                    } else if (_selectedCurrency.contains('TRY')) {
                      currency = WiseTrackCurrency.TRY;
                    } else if (_selectedCurrency.contains('RUB')) {
                      currency = WiseTrackCurrency.RUB;
                    } else if (_selectedCurrency.contains('INR')) {
                      currency = WiseTrackCurrency.INR;
                    } else if (_selectedCurrency.contains('BRL')) {
                      currency = WiseTrackCurrency.BRL;
                    } else if (_selectedCurrency.contains('ZAR')) {
                      currency = WiseTrackCurrency.ZAR;
                    } else if (_selectedCurrency.contains('IRR')) {
                      currency = WiseTrackCurrency.IRR;
                    } else if (_selectedCurrency.contains('AED')) {
                      currency = WiseTrackCurrency.AED;
                    } else if (_selectedCurrency.contains('IQD')) {
                      currency = WiseTrackCurrency.IQD;
                    } else if (_selectedCurrency.contains('SAR')) {
                      currency = WiseTrackCurrency.SAR;
                    } else if (_selectedCurrency.contains('OMR')) {
                      currency = WiseTrackCurrency.OMR;
                    } else if (_selectedCurrency.contains('BTC')) {
                      currency = WiseTrackCurrency.BTC;
                    } else if (_selectedCurrency.contains('EHT')) {
                      currency = WiseTrackCurrency.EHT;
                    } else if (_selectedCurrency.contains('LTC')) {
                      currency = WiseTrackCurrency.LTC;
                    }

                    if (eventPrice.isNotEmpty && eventPrice.isNotEmpty) {
                      event.setRevenue(int.parse(eventPrice), currency);
                    }


                    WiseTrack.trackEvent(event);


                  }
                },
                child: const Text('Send'),
              ),
            ],
          ),
        ),
      ),
    );
  }

/*  _showIsSdkEnabled() {
    try {
      WiseTrack.isEnabled().then((isEnabled) {
        _isSdkEnabled = isEnabled;
        _showDialogMessage('SDK Enabled?', 'WiseTrack is enabled = $isEnabled');
      });
    } on PlatformException {
      _showDialogMessage(
          'SDK Enabled?', 'No such method found in plugin: isEnabled');
    }
  }

  void _showDialogMessage(String title, String text,
      [bool printToConsoleAlso = true]) {
    if (printToConsoleAlso) {
      print(text);
    }

    showDialog<void>(
      context: context,
      builder: (BuildContext context) {
        return new CupertinoAlertDialog(
          title: Text(title),
          content: Text(text),
          actions: <Widget>[
            new CupertinoDialogAction(
              child: const Text('OK'),
              onPressed: () {
                Navigator.pop(context, 'OK');
              },
            )
          ],
        );
      },
    );
  }*/
}