pslab-app/lib/providers/board_state_provider.dart at 5936ac6aae1961c6b2feacf2ed55065a20d207e8 · prajakta128/pslab-app · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
import 'dart:async';

import 'package:flutter/foundation.dart';

import 'package:connectivity_plus/connectivity_plus.dart';
import 'package:pslab/communication/science_lab.dart';
import 'package:pslab/l10n/app_localizations.dart';
import 'package:pslab/others/logger_service.dart';
import 'package:pslab/providers/locator.dart';
import 'package:pslab/providers/settings_config_provider.dart';
import 'package:usb_serial/usb_serial.dart';

import 'package:pslab/others/science_lab_common.dart';

class BoardStateProvider extends ChangeNotifier {
  late SettingsConfigProvider configProvider;
  AppLocalizations get appLocalizations => getIt.get<AppLocalizations>();
  bool initialisationStatus = false;
  bool pslabIsConnected = false;
  bool hasPermission = false;
  late ScienceLabCommon scienceLabCommon;
  String pslabVersionID = 'Not Connected';
  String pslabVersionIDV6 = 'PSLab V6';
  String pslabVersionIDV5 = 'PSLab V5';
  int pslabVersion = 0;
  int pslabFirmwareVersion = 0;
  bool _isProcessing = false;
  StreamSubscription<UsbEvent>? _usbSubscription;
  StreamSubscription<List<ConnectivityResult>>? _connectivitySubscription;

  final ValueNotifier<String?> legacyFirmwareNotifier = ValueNotifier(null);

  BoardStateProvider() {
    scienceLabCommon = getIt.get<ScienceLabCommon>();
    configProvider = SettingsConfigProvider();
  }

  Future<void> initialize() async {
    if (_isProcessing) return;
    _isProcessing = true;
    if (!scienceLabCommon.isConnected()) {
      await scienceLabCommon.initialize();
      pslabIsConnected = await scienceLabCommon.openDevice();
      await setPSLabVersionIDs();
      await fetchFirmwareVersion();
    }
    _isProcessing = false;

    if (configProvider.config.autoStart) {
      if (!kIsWeb && defaultTargetPlatform == TargetPlatform.android) {
        _usbSubscription = UsbSerial.usbEventStream?.listen(
          (UsbEvent usbEvent) async {
            if (usbEvent.event == UsbEvent.ACTION_USB_ATTACHED) {
              if (_isProcessing) return;
              _isProcessing = true;
              if (!scienceLabCommon.isConnected() &&
                  await attemptToConnectPSLab()) {
                pslabIsConnected = await scienceLabCommon.openDevice();
                await setPSLabVersionIDs();
                await fetchFirmwareVersion();
                _isProcessing = false;
              }
            } else if (usbEvent.event == UsbEvent.ACTION_USB_DETACHED &&
                !scienceLabCommon.isWiFiConnected()) {
              scienceLabCommon.setConnected(false);
              pslabIsConnected = false;
              pslabVersionID = 'Not Connected';
              notifyListeners();
            }
          },
        );
      }
    }

    _connectivitySubscription = Connectivity()
        .onConnectivityChanged
        .listen((List<ConnectivityResult> results) {
      if (results.contains(ConnectivityResult.none)) {
        scienceLabCommon.setWiFiConnected(false);
        pslabIsConnected = false;
        pslabVersionID = 'Not Connected';
        notifyListeners();
      }
    });
  }

  Future<void> initializeWiFi() async {
    if (!pslabIsConnected) {
      pslabIsConnected = await scienceLabCommon.openWiFiDevice();
      await setPSLabVersionIDs();
      await fetchFirmwareVersion();
    }
  }

  Future<void> setPSLabVersionIDs() async {
    pslabVersionID = await getIt.get<ScienceLab>().getVersion();
    if (pslabVersionID == pslabVersionIDV6) {
      pslabVersion = 6;
    } else if (pslabVersionID == pslabVersionIDV5) {
      pslabVersion = 5;
    }
    notifyListeners();
  }

  Future<void> fetchFirmwareVersion() async {
    if (getIt.get<ScienceLab>().isConnected()) {
      pslabFirmwareVersion =
          await getIt.get<ScienceLab>().mPacketHandler.getFirmwareVersion();
    }
    if (pslabFirmwareVersion < 3 && pslabFirmwareVersion != 0) {
      legacyFirmwareNotifier.value = "LegacyFirmwareDetected";
    }
    notifyListeners();
  }

  Future<bool> attemptToConnectPSLab() async {
    if (scienceLabCommon.isConnected()) {
      logger.d("Device Connected Successfully");
    } else {
      await scienceLabCommon.initialize();
      if (scienceLabCommon.isDeviceFound()) {
        return true;
      }
    }
    return false;
  }

  @override
  void dispose() {
    _usbSubscription?.cancel();
    _connectivitySubscription?.cancel();
    legacyFirmwareNotifier.dispose();
    super.dispose();
  }
}