Flutter SDK (demo)

1                         Consent Backend
2                               |
3                +--------------+--------------+
4                |                             |
5        Android Native SDK             iOS Native SDK
6     (consent logic, storage,      (consent logic, storage,
7      consent UI, networking)       consent UI, networking)
8                |                             |
9        +-------+-------+             +-------+-------+
10        |               |             |               |
11     Flutter      React Native     Flutter      React Native
12     plugin       native module    plugin       native module
13    (Kotlin)        (Kotlin)       (Swift)        (Swift)
14        |               |             |               |
15        +-------+-------+-------------+-------+-------+
16                |                             |
17          Dart API (Flutter)        TypeScript API (React Native)
18                |                             |
19                +--------- Host application --+

1# pubspec.yaml of your app
2dependencies:
3  flutter:
4    sdk: flutter
5  # DEMO / FICTIONAL package
6  digital_anumati_consent: ^1.0.0

1// android/build.gradle (plugin) — pulls in the native SDK
2dependencies {
3    implementation "com.digitalanumati:consent-sdk:1.0.0" // DEMO / FICTIONAL
4    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0"
5}

1# ios/digital_anumati_consent.podspec — pulls in the native SDK
2Pod::Spec.new do |s|
3  s.name             = 'digital_anumati_consent'
4  s.version          = '1.0.0'
5  s.summary          = 'DEMO / FICTIONAL Flutter bridge for the Digital Anumati consent SDK.'
6  s.homepage         = 'https://github.com/example/digital_anumati_consent'
7  s.license          = { :type => 'MIT' }
8  s.author           = 'Demo'
9  s.source           = { :path => '.' }
10  s.source_files     = 'Classes/**/*'
11  s.platform         = :ios, '15.0'
12  s.swift_version    = '5.9'
13  s.dependency 'Flutter'
14  s.dependency 'DigitalAnumatiConsent', '~> 1.0' # DEMO / FICTIONAL
15end

1import 'package:digital_anumati_consent/digital_anumati_consent.dart';
2 
3// 1. Initialize once, at app start.
4await DigitalAnumatiConsent.initialize(
5  siteKey: 'demo-site-key-123',
6  applicationId: 'demo-mobile-app-123',
7  environment: Environment.uat,
8);
9 
10// 2. Listen to SDK events.
11DigitalAnumatiConsent.events.listen((event) {
12  if (event.type == 'CONSENT_ERROR') {
13    debugPrint('Consent error: ' + event.error!.code);
14  }
15});
16 
17// 3. Ask for consent if the user hasn't decided yet.
18if (await DigitalAnumatiConsent.getConsentStatus() == ConsentStatus.notDetermined) {
19  final result = await DigitalAnumatiConsent.showConsent();
20  debugPrint('Consent status: ' + result.status.wire);
21}
22 
23// 4. Read or change preferences, or revoke.
24final preferences = await DigitalAnumatiConsent.getConsentPreferences();
25await DigitalAnumatiConsent.updateConsent(const ConsentPreferences(analytics: true));
26await DigitalAnumatiConsent.revokeConsent();

1final subscription = DigitalAnumatiConsent.events.listen((event) {
2  switch (event.type) {
3    case 'CONSENT_ACCEPTED':
4    case 'CONSENT_REJECTED':
5    case 'CONSENT_UPDATED':
6      debugPrint('New status: ' + event.result!.status.wire);
7    case 'CONSENT_REVOKED':
8      debugPrint('Consent revoked');
9    case 'CONSENT_ERROR':
10      debugPrint('Consent error: ' + event.error!.message);
11  }
12});
13 
14// Later, e.g. in dispose():
15await subscription.cancel();

1digital_anumati_consent/            # DEMO / FICTIONAL Flutter plugin
2├── lib/
3│   ├── digital_anumati_consent.dart          # public exports
4│   └── src/
5│       ├── channels.dart                     # channel names
6│       ├── models.dart                       # ConsentStatus, ConsentPreferences, ConsentResult, ConsentError, ConsentEvent, Environment
7│       └── digital_anumati_consent.dart      # DigitalAnumatiConsent API (MethodChannel + EventChannel)
8├── android/
9│   ├── build.gradle                          # depends on com.digitalanumati:consent-sdk
10│   └── src/main/kotlin/com/digitalanumati/consent/flutter/
11│       └── DigitalAnumatiConsentPlugin.kt    # Kotlin bridge
12├── ios/
13│   ├── digital_anumati_consent.podspec       # depends on DigitalAnumatiConsent
14│   └── Classes/
15│       └── DigitalAnumatiConsentPlugin.swift # Swift bridge
16├── example/                                  # anumati_flutter_demo
17│   ├── lib/main.dart
18│   ├── android/
19│   └── ios/
20├── test/
21│   └── digital_anumati_consent_test.dart
22├── pubspec.yaml
23└── README.md

1name: digital_anumati_consent
2description: DEMO / FICTIONAL Flutter plugin that wraps the Digital Anumati native consent SDKs.
3version: 1.0.0
4publish_to: none # demo only — not published on pub.dev
5 
6environment:
7  sdk: ">=3.3.0 <4.0.0"
8  flutter: ">=3.19.0"
9 
10dependencies:
11  flutter:
12    sdk: flutter
13 
14dev_dependencies:
15  flutter_test:
16    sdk: flutter
17 
18flutter:
19  plugin:
20    platforms:
21      android:
22        package: com.digitalanumati.consent.flutter
23        pluginClass: DigitalAnumatiConsentPlugin
24      ios:
25        pluginClass: DigitalAnumatiConsentPlugin

1// lib/digital_anumati_consent.dart
2export 'src/digital_anumati_consent.dart';
3export 'src/models.dart';

1// lib/src/channels.dart
2import 'package:flutter/services.dart';
3 
4/// Commands: request/response calls into the native SDK.
5const methodChannel = MethodChannel('com.digitalanumati/consent');
6 
7/// Events: a continuous stream pushed from the native SDK.
8const eventChannel = EventChannel('com.digitalanumati/consent/events');

1// lib/src/models.dart — plain data types. No consent rules live here.
2import 'package:flutter/services.dart';
3 
4enum Environment {
5  uat('uat'),
6  production('production');
7 
8  const Environment(this.wire);
9  final String wire;
10}
11 
12enum ConsentStatus {
13  notDetermined('NOT_DETERMINED'),
14  granted('GRANTED'),
15  denied('DENIED'),
16  partial('PARTIAL');
17 
18  const ConsentStatus(this.wire);
19  final String wire;
20 
21  static ConsentStatus fromWire(String value) => values.firstWhere(
22        (status) => status.wire == value,
23        orElse: () => ConsentStatus.notDetermined,
24      );
25}
26 
27enum ConsentCategory { necessary, analytics, personalization, advertising }
28 
29class ConsentPreferences {
30  const ConsentPreferences({
31    this.analytics = false,
32    this.personalization = false,
33    this.advertising = false,
34  });
35 
36  /// Always on; the native SDK enforces this.
37  bool get necessary => true;
38  final bool analytics;
39  final bool personalization;
40  final bool advertising;
41 
42  factory ConsentPreferences.fromMap(Map<Object?, Object?> map) => ConsentPreferences(
43        analytics: map['analytics'] as bool? ?? false,
44        personalization: map['personalization'] as bool? ?? false,
45        advertising: map['advertising'] as bool? ?? false,
46      );
47 
48  Map<String, Object> toMap() => {
49        'analytics': analytics,
50        'personalization': personalization,
51        'advertising': advertising,
52      };
53}
54 
55class ConsentResult {
56  const ConsentResult({
57    required this.status,
58    required this.preferences,
59    required this.timestamp,
60  });
61 
62  final ConsentStatus status;
63  final ConsentPreferences preferences;
64  final DateTime timestamp;
65 
66  factory ConsentResult.fromMap(Map<Object?, Object?> map) => ConsentResult(
67        status: ConsentStatus.fromWire(map['status'] as String),
68        preferences: ConsentPreferences.fromMap(map['preferences'] as Map<Object?, Object?>),
69        timestamp: DateTime.fromMillisecondsSinceEpoch(map['timestamp'] as int),
70      );
71}
72 
73class ConsentError implements Exception {
74  const ConsentError(this.code, this.message);
75 
76  /// One of the error-contract codes, e.g. NETWORK_ERROR or USER_CANCELLED.
77  final String code;
78  final String message;
79 
80  factory ConsentError.fromPlatformException(PlatformException e) =>
81      ConsentError(e.code, e.message ?? 'Unknown error');
82 
83  @override
84  String toString() => 'ConsentError($code): $message';
85}
86 
87class ConsentEvent {
88  const ConsentEvent({required this.type, this.result, this.error});
89 
90  /// SDK_INITIALIZED, CONSENT_SHOWN, CONSENT_ACCEPTED, CONSENT_REJECTED,
91  /// CONSENT_UPDATED, CONSENT_REVOKED or CONSENT_ERROR.
92  final String type;
93  final ConsentResult? result;
94  final ConsentError? error;
95 
96  factory ConsentEvent.fromMap(Map<Object?, Object?> map) {
97    final result = map['result'] as Map<Object?, Object?>?;
98    final error = map['error'] as Map<Object?, Object?>?;
99    return ConsentEvent(
100      type: map['type'] as String,
101      result: result == null ? null : ConsentResult.fromMap(result),
102      error: error == null ? null : ConsentError(error['code'] as String, error['message'] as String),
103    );
104  }
105}

1// lib/src/digital_anumati_consent.dart
2import 'package:flutter/services.dart';
3 
4import 'channels.dart';
5import 'models.dart';
6 
7/// DEMO / FICTIONAL — a thin wrapper over the native SDKs. It only converts types and errors;
8/// consent storage, rules, validation and networking all stay in the native SDK.
9class DigitalAnumatiConsent {
10  DigitalAnumatiConsent._();
11 
12  /// SDK events. Broadcast stream: listen from as many places as you need.
13  static final Stream<ConsentEvent> events = eventChannel
14      .receiveBroadcastStream()
15      .map((event) => ConsentEvent.fromMap(event as Map<Object?, Object?>));
16 
17  static Future<void> initialize({
18    required String siteKey,
19    required String applicationId,
20    Environment environment = Environment.uat,
21  }) =>
22      _invoke<void>('initialize', {
23        'siteKey': siteKey,
24        'applicationId': applicationId,
25        'environment': environment.wire,
26      });
27 
28  /// Shows the native, SDK-owned consent screen and returns the user's choice.
29  static Future<ConsentResult> showConsent() async =>
30      ConsentResult.fromMap((await _invoke<Map<Object?, Object?>>('showConsent'))!);
31 
32  static Future<ConsentStatus> getConsentStatus() async =>
33      ConsentStatus.fromWire((await _invoke<String>('getConsentStatus'))!);
34 
35  static Future<ConsentPreferences> getConsentPreferences() async =>
36      ConsentPreferences.fromMap((await _invoke<Map<Object?, Object?>>('getConsentPreferences'))!);
37 
38  static Future<ConsentResult> updateConsent(ConsentPreferences preferences) async =>
39      ConsentResult.fromMap(
40        (await _invoke<Map<Object?, Object?>>('updateConsent', preferences.toMap()))!,
41      );
42 
43  static Future<void> revokeConsent() => _invoke<void>('revokeConsent');
44 
45  static Future<bool> isInitialized() async => (await _invoke<bool>('isInitialized')) ?? false;
46 
47  static Future<T?> _invoke<T>(String method, [Map<String, Object>? arguments]) async {
48    try {
49      return await methodChannel.invokeMethod<T>(method, arguments);
50    } on PlatformException catch (e) {
51      throw ConsentError.fromPlatformException(e);
52    }
53  }
54}

1// android/src/main/kotlin/com/digitalanumati/consent/flutter/DigitalAnumatiConsentPlugin.kt
2package com.digitalanumati.consent.flutter
3 
4import android.app.Activity
5import android.content.Context
6import com.digitalanumati.consent.ConsentError
7import com.digitalanumati.consent.ConsentErrorCode
8import com.digitalanumati.consent.ConsentEvent
9import com.digitalanumati.consent.ConsentListener
10import com.digitalanumati.consent.ConsentPreferences
11import com.digitalanumati.consent.ConsentResult
12import com.digitalanumati.consent.DigitalAnumati
13import com.digitalanumati.consent.Environment
14import io.flutter.embedding.engine.plugins.FlutterPlugin
15import io.flutter.embedding.engine.plugins.activity.ActivityAware
16import io.flutter.embedding.engine.plugins.activity.ActivityPluginBinding
17import io.flutter.plugin.common.EventChannel
18import io.flutter.plugin.common.MethodCall
19import io.flutter.plugin.common.MethodChannel
20import kotlinx.coroutines.CoroutineScope
21import kotlinx.coroutines.Dispatchers
22import kotlinx.coroutines.SupervisorJob
23import kotlinx.coroutines.cancel
24import kotlinx.coroutines.launch
25 
26/** DEMO / FICTIONAL — translates channel calls to the native SDK. No consent logic here. */
27class DigitalAnumatiConsentPlugin :
28    FlutterPlugin, MethodChannel.MethodCallHandler, EventChannel.StreamHandler, ActivityAware {
29 
30    private lateinit var methodChannel: MethodChannel
31    private lateinit var eventChannel: EventChannel
32    private lateinit var context: Context
33    private var activity: Activity? = null
34    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
35 
36    override fun onAttachedToEngine(binding: FlutterPlugin.FlutterPluginBinding) {
37        context = binding.applicationContext
38        methodChannel = MethodChannel(binding.binaryMessenger, "com.digitalanumati/consent")
39        methodChannel.setMethodCallHandler(this)
40        eventChannel = EventChannel(binding.binaryMessenger, "com.digitalanumati/consent/events")
41        eventChannel.setStreamHandler(this)
42    }
43 
44    override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
45        methodChannel.setMethodCallHandler(null)
46        eventChannel.setStreamHandler(null)
47        DigitalAnumati.setEventListener(null)
48        scope.cancel()
49    }
50 
51    // Flutter calls this on the platform (main) thread.
52    override fun onMethodCall(call: MethodCall, result: MethodChannel.Result) {
53        reportErrors(result) {
54            when (call.method) {
55                "initialize" -> {
56                    DigitalAnumati.initialize(
57                        context = context,
58                        siteKey = call.argument<String>("siteKey").orEmpty(),
59                        applicationId = call.argument<String>("applicationId").orEmpty(),
60                        environment = if (call.argument<String>("environment") == "production") {
61                            Environment.PRODUCTION
62                        } else {
63                            Environment.UAT
64                        },
65                    )
66                    result.success(null)
67                }
68                "isInitialized" -> result.success(DigitalAnumati.isInitialized())
69                "getConsentStatus" -> result.success(DigitalAnumati.getConsentStatus().name)
70                "getConsentPreferences" -> result.success(DigitalAnumati.getConsentPreferences().toMap())
71                "showConsent" -> showConsent(result)
72                "updateConsent" -> scope.launch {
73                    reportErrors(result) {
74                        result.success(DigitalAnumati.updateConsent(call.toPreferences()).toMap())
75                    }
76                }
77                "revokeConsent" -> scope.launch {
78                    reportErrors(result) {
79                        DigitalAnumati.revokeConsent()
80                        result.success(null)
81                    }
82                }
83                else -> result.notImplemented()
84            }
85        }
86    }
87 
88    private fun showConsent(result: MethodChannel.Result) {
89        val current = activity ?: return result.error(
90            ConsentErrorCode.UNKNOWN_ERROR.name,
91            "No foreground activity to present the consent screen.",
92            null,
93        )
94        DigitalAnumati.showConsent(current, object : ConsentListener {
95            override fun onConsentCompleted(consent: ConsentResult) = result.success(consent.toMap())
96            override fun onError(error: ConsentError) = result.error(error.code.name, error.message, null)
97        })
98    }
99 
100    /** Native ConsentError -> PlatformException(code, message) on the Dart side. */
101    private inline fun reportErrors(result: MethodChannel.Result, block: () -> Unit) {
102        try {
103            block()
104        } catch (e: ConsentError) {
105            result.error(e.code.name, e.message, null)
106        } catch (e: Exception) {
107            result.error(ConsentErrorCode.UNKNOWN_ERROR.name, e.message, null)
108        }
109    }
110 
111    // EventChannel: forward every native SDK event to Dart (the SDK emits on the main thread).
112    override fun onListen(arguments: Any?, events: EventChannel.EventSink) {
113        DigitalAnumati.setEventListener { event -> events.success(event.toMap()) }
114    }
115 
116    override fun onCancel(arguments: Any?) {
117        DigitalAnumati.setEventListener(null)
118    }
119 
120    override fun onAttachedToActivity(binding: ActivityPluginBinding) {
121        activity = binding.activity
122    }
123 
124    override fun onDetachedFromActivityForConfigChanges() {
125        activity = null
126    }
127 
128    override fun onReattachedToActivityForConfigChanges(binding: ActivityPluginBinding) {
129        activity = binding.activity
130    }
131 
132    override fun onDetachedFromActivity() {
133        activity = null
134    }
135}
136 
137// ---- Type conversions (native -> channel) -------------------------------------------------
138 
139private fun ConsentPreferences.toMap(): Map<String, Boolean> = mapOf(
140    "necessary" to necessary,
141    "analytics" to analytics,
142    "personalization" to personalization,
143    "advertising" to advertising,
144)
145 
146private fun ConsentResult.toMap(): Map<String, Any> = mapOf(
147    "status" to status.name,            // enum -> "GRANTED"
148    "preferences" to preferences.toMap(),
149    "timestamp" to timestamp,           // Long epoch millis -> Dart int
150)
151 
152private fun ConsentEvent.toMap(): Map<String, Any?> = mapOf(
153    "type" to type.name,
154    "result" to result?.toMap(),
155    "error" to error?.let { mapOf("code" to it.code.name, "message" to it.message) },
156)
157 
158private fun MethodCall.toPreferences() = ConsentPreferences(
159    analytics = argument<Boolean>("analytics") ?: false,
160    personalization = argument<Boolean>("personalization") ?: false,
161    advertising = argument<Boolean>("advertising") ?: false,
162)

1// ios/Classes/DigitalAnumatiConsentPlugin.swift
2import Flutter
3import UIKit
4import DigitalAnumatiConsent
5 
6/// DEMO / FICTIONAL — translates channel calls to the native SDK. No consent logic here.
7public final class DigitalAnumatiConsentPlugin: NSObject, FlutterPlugin, FlutterStreamHandler {
8 
9    public static func register(with registrar: FlutterPluginRegistrar) {
10        let instance = DigitalAnumatiConsentPlugin()
11        let methods = FlutterMethodChannel(
12            name: "com.digitalanumati/consent",
13            binaryMessenger: registrar.messenger()
14        )
15        registrar.addMethodCallDelegate(instance, channel: methods)
16        let events = FlutterEventChannel(
17            name: "com.digitalanumati/consent/events",
18            binaryMessenger: registrar.messenger()
19        )
20        events.setStreamHandler(instance)
21    }
22 
23    // Flutter calls this on the main thread.
24    public func handle(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
25        let args = call.arguments as? [String: Any] ?? [:]
26 
27        switch call.method {
28        case "initialize":
29            do {
30                try DigitalAnumati.initialize(
31                    siteKey: args["siteKey"] as? String ?? "",
32                    applicationId: args["applicationId"] as? String ?? "",
33                    environment: args["environment"] as? String == "production" ? .production : .uat
34                )
35                result(nil)
36            } catch {
37                result(flutterError(from: error))
38            }
39 
40        case "isInitialized":
41            result(DigitalAnumati.isInitialized)
42 
43        case "getConsentStatus":
44            result(DigitalAnumati.getConsentStatus().rawValue)
45 
46        case "getConsentPreferences":
47            result(DigitalAnumati.getConsentPreferences().asDictionary)
48 
49        case "showConsent":
50            Task { @MainActor in
51                guard let presenter = topViewController() else {
52                    result(FlutterError(code: "UNKNOWN_ERROR", message: "No view controller to present from.", details: nil))
53                    return
54                }
55                do {
56                    result(try await DigitalAnumati.showConsent(from: presenter).asDictionary)
57                } catch {
58                    result(flutterError(from: error))
59                }
60            }
61 
62        case "updateConsent":
63            let preferences = ConsentPreferences(
64                analytics: args["analytics"] as? Bool ?? false,
65                personalization: args["personalization"] as? Bool ?? false,
66                advertising: args["advertising"] as? Bool ?? false
67            )
68            Task { @MainActor in
69                do {
70                    result(try await DigitalAnumati.updateConsent(preferences).asDictionary)
71                } catch {
72                    result(flutterError(from: error))
73                }
74            }
75 
76        case "revokeConsent":
77            Task { @MainActor in
78                do {
79                    try await DigitalAnumati.revokeConsent()
80                    result(nil)
81                } catch {
82                    result(flutterError(from: error))
83                }
84            }
85 
86        default:
87            result(FlutterMethodNotImplemented)
88        }
89    }
90 
91    // EventChannel: forward every native SDK event to Dart (the SDK emits on the main thread).
92    public func onListen(withArguments arguments: Any?, eventSink events: @escaping FlutterEventSink) -> FlutterError? {
93        DigitalAnumati.setEventHandler { event in
94            events(event.asDictionary)
95        }
96        return nil
97    }
98 
99    public func onCancel(withArguments arguments: Any?) -> FlutterError? {
100        DigitalAnumati.setEventHandler(nil)
101        return nil
102    }
103}
104 
105// ---- Helpers and type conversions (native -> channel) --------------------------------------
106 
107/// Native ConsentError -> FlutterError(code, message) -> PlatformException in Dart.
108private func flutterError(from error: Error) -> FlutterError {
109    let consentError = error as? ConsentError
110    return FlutterError(
111        code: consentError?.code.rawValue ?? "UNKNOWN_ERROR",
112        message: consentError?.message ?? error.localizedDescription,
113        details: nil
114    )
115}
116 
117@MainActor
118private func topViewController() -> UIViewController? {
119    let scene = UIApplication.shared.connectedScenes
120        .compactMap { $0 as? UIWindowScene }
121        .first { $0.activationState == .foregroundActive }
122    var top = scene?.windows.first { $0.isKeyWindow }?.rootViewController
123    while let presented = top?.presentedViewController {
124        top = presented
125    }
126    return top
127}
128 
129private extension ConsentPreferences {
130    var asDictionary: [String: Bool] {
131        [
132            "necessary": necessary,
133            "analytics": analytics,
134            "personalization": personalization,
135            "advertising": advertising,
136        ]
137    }
138}
139 
140private extension ConsentResult {
141    var asDictionary: [String: Any] {
142        [
143            "status": status.rawValue,                                   // "GRANTED"
144            "preferences": preferences.asDictionary,
145            "timestamp": Int(timestamp.timeIntervalSince1970 * 1000),    // Date -> epoch millis
146        ]
147    }
148}
149 
150private extension ConsentEvent {
151    var asDictionary: [String: Any] {
152        var map: [String: Any] = ["type": type.rawValue]
153        if let result { map["result"] = result.asDictionary }
154        if let error { map["error"] = ["code": error.code.rawValue, "message": error.message] }
155        return map
156    }
157}

1// example/lib/main.dart — anumati_flutter_demo
2import 'dart:async';
3 
4import 'package:digital_anumati_consent/digital_anumati_consent.dart';
5import 'package:flutter/foundation.dart';
6import 'package:flutter/material.dart';
7 
8void main() => runApp(const AnumatiFlutterDemo());
9 
10class AnumatiFlutterDemo extends StatelessWidget {
11  const AnumatiFlutterDemo({super.key});
12 
13  @override
14  Widget build(BuildContext context) => MaterialApp(
15        title: 'Anumati Flutter Demo',
16        theme: ThemeData(colorSchemeSeed: Colors.blue, useMaterial3: true),
17        home: const HomeScreen(),
18      );
19}
20 
21class HomeScreen extends StatefulWidget {
22  const HomeScreen({super.key});
23 
24  @override
25  State<HomeScreen> createState() => _HomeScreenState();
26}
27 
28class _HomeScreenState extends State<HomeScreen> {
29  bool _initialized = false;
30  ConsentStatus _status = ConsentStatus.notDetermined;
31  ConsentPreferences? _preferences;
32  String? _message;
33  StreamSubscription<ConsentEvent>? _events;
34 
35  @override
36  void initState() {
37    super.initState();
38    _events = DigitalAnumatiConsent.events.listen((event) {
39      final result = event.result;
40      if (result != null && mounted) {
41        setState(() {
42          _status = result.status;
43          _preferences = result.preferences;
44        });
45      }
46      if (event.type == 'CONSENT_REVOKED') _refresh();
47    });
48    _initialize();
49  }
50 
51  @override
52  void dispose() {
53    _events?.cancel();
54    super.dispose();
55  }
56 
57  Future<void> _initialize() => _run(() async {
58        await DigitalAnumatiConsent.initialize(
59          siteKey: 'demo-site-key-123',
60          applicationId: 'demo-mobile-app-123',
61          environment: kReleaseMode ? Environment.production : Environment.uat,
62        );
63        await _refresh();
64        // First launch (or after a revoke): ask before continuing.
65        if (_status == ConsentStatus.notDetermined) {
66          await DigitalAnumatiConsent.showConsent();
67        }
68      });
69 
70  Future<void> _refresh() async {
71    final initialized = await DigitalAnumatiConsent.isInitialized();
72    if (!initialized) {
73      if (mounted) setState(() => _initialized = false);
74      return;
75    }
76    final status = await DigitalAnumatiConsent.getConsentStatus();
77    final preferences = await DigitalAnumatiConsent.getConsentPreferences();
78    if (!mounted) return;
79    setState(() {
80      _initialized = true;
81      _status = status;
82      _preferences = preferences;
83    });
84  }
85 
86  Future<void> _run(Future<void> Function() action) async {
87    try {
88      await action();
89      if (mounted) setState(() => _message = null);
90    } on ConsentError catch (error) {
91      // USER_CANCELLED only means the screen was closed; keep the previous state.
92      if (error.code != 'USER_CANCELLED' && mounted) {
93        setState(() => _message = error.message);
94      }
95    }
96  }
97 
98  @override
99  Widget build(BuildContext context) {
100    final sdkLabel = _initialized ? 'Initialized' : 'Not initialized';
101    final consentLabel = _status.wire;
102    final preferences = _preferences;
103 
104    return Scaffold(
105      appBar: AppBar(title: const Text('Anumati Flutter Demo')),
106      body: ListView(
107        padding: const EdgeInsets.all(24),
108        children: [
109          Text('SDK status: $sdkLabel', style: Theme.of(context).textTheme.titleMedium),
110          const SizedBox(height: 8),
111          Text('Consent: $consentLabel', style: Theme.of(context).textTheme.titleMedium),
112          if (preferences != null) ...[
113            const SizedBox(height: 16),
114            Text('Preferences', style: Theme.of(context).textTheme.titleSmall),
115            _preferenceRow('Necessary', preferences.necessary),
116            _preferenceRow('Analytics', preferences.analytics),
117            _preferenceRow('Personalization', preferences.personalization),
118            _preferenceRow('Advertising', preferences.advertising),
119          ],
120          if (_message != null) ...[
121            const SizedBox(height: 16),
122            Text(_message!, style: TextStyle(color: Theme.of(context).colorScheme.error)),
123          ],
124          const SizedBox(height: 24),
125          FilledButton(onPressed: _initialize, child: const Text('Initialize SDK')),
126          const SizedBox(height: 8),
127          FilledButton.tonal(
128            onPressed: _initialized ? () => _run(DigitalAnumatiConsent.showConsent) : null,
129            child: const Text('Manage Consent'),
130          ),
131          const SizedBox(height: 8),
132          OutlinedButton(
133            onPressed: _initialized ? () => _run(_refresh) : null,
134            child: const Text('Refresh Status'),
135          ),
136          const SizedBox(height: 8),
137          OutlinedButton(
138            onPressed: _initialized && _status != ConsentStatus.notDetermined
139                ? () => _run(DigitalAnumatiConsent.revokeConsent)
140                : null,
141            child: const Text('Revoke Consent'),
142          ),
143        ],
144      ),
145    );
146  }
147 
148  Widget _preferenceRow(String label, bool allowed) => ListTile(
149        dense: true,
150        contentPadding: EdgeInsets.zero,
151        title: Text(label),
152        trailing: Icon(
153          allowed ? Icons.check_circle : Icons.cancel_outlined,
154          color: allowed ? Colors.green : Colors.grey,
155        ),
156      );
157}

1Android: native SDK throws ConsentError(code = NETWORK_ERROR)
2      → Kotlin plugin: result.error("NETWORK_ERROR", message, null)
3      → MethodChannel
4      → Dart: PlatformException(code: "NETWORK_ERROR")
5      → DigitalAnumatiConsent throws ConsentError("NETWORK_ERROR", message)
6 
7iOS:     native SDK throws ConsentError(code: .networkError)
8      → Swift plugin: FlutterError(code: "NETWORK_ERROR", message: ...)
9      → MethodChannel
10      → Dart: PlatformException → ConsentError("NETWORK_ERROR", message)

1Flutter app starts
2        ↓
3Dart: DigitalAnumatiConsent.initialize(siteKey, applicationId, environment)
4        ↓
5MethodChannel "com.digitalanumati/consent" → method "initialize" + arguments map
6        ↓
7Android: DigitalAnumatiConsentPlugin.onMethodCall   |   iOS: DigitalAnumatiConsentPlugin.handle
8        ↓
9Native SDK: DigitalAnumati.initialize(...)  → emits SDK_INITIALIZED on the EventChannel
10        ↓
11result.success(null)  → Future completes in Dart
12   or result.error(code, message)  → PlatformException → ConsentError thrown in Dart

1// test/digital_anumati_consent_test.dart — unit tests for the Dart wrapper (no device needed)
2import 'package:digital_anumati_consent/digital_anumati_consent.dart';
3import 'package:flutter/services.dart';
4import 'package:flutter_test/flutter_test.dart';
5 
6void main() {
7  TestWidgetsFlutterBinding.ensureInitialized();
8  const channel = MethodChannel('com.digitalanumati/consent');
9  final messenger = TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger;
10 
11  tearDown(() => messenger.setMockMethodCallHandler(channel, null));
12 
13  test('getConsentStatus maps the wire value to the enum', () async {
14    messenger.setMockMethodCallHandler(channel, (call) async => 'PARTIAL');
15    expect(await DigitalAnumatiConsent.getConsentStatus(), ConsentStatus.partial);
16  });
17 
18  test('initialize sends the channel-contract arguments', () async {
19    MethodCall? received;
20    messenger.setMockMethodCallHandler(channel, (call) async {
21      received = call;
22      return null;
23    });
24    await DigitalAnumatiConsent.initialize(
25      siteKey: 'demo-site-key-123',
26      applicationId: 'demo-mobile-app-123',
27    );
28    expect(received?.method, 'initialize');
29    expect(received?.arguments, {
30      'siteKey': 'demo-site-key-123',
31      'applicationId': 'demo-mobile-app-123',
32      'environment': 'uat',
33    });
34  });
35 
36  test('updateConsent sends preferences and parses the result', () async {
37    MethodCall? received;
38    messenger.setMockMethodCallHandler(channel, (call) async {
39      received = call;
40      return {
41        'status': 'PARTIAL',
42        'preferences': {
43          'necessary': true,
44          'analytics': true,
45          'personalization': false,
46          'advertising': false,
47        },
48        'timestamp': 1759054500000,
49      };
50    });
51    final result = await DigitalAnumatiConsent.updateConsent(
52      const ConsentPreferences(analytics: true),
53    );
54    expect(received?.arguments, {'analytics': true, 'personalization': false, 'advertising': false});
55    expect(result.status, ConsentStatus.partial);
56    expect(result.preferences.analytics, isTrue);
57  });
58 
59  test('native errors surface as ConsentError with the same code', () async {
60    messenger.setMockMethodCallHandler(channel, (call) async {
61      throw PlatformException(code: 'NETWORK_ERROR', message: 'offline');
62    });
63    expect(
64      DigitalAnumatiConsent.revokeConsent(),
65      throwsA(isA<ConsentError>().having((e) => e.code, 'code', 'NETWORK_ERROR')),
66    );
67  });
68}