PhysiGo/app/lib/walking/walking_counter.dart

import 'dart:async';
import 'package:flutter/material.dart';
import 'package:flutter_activity_recognition/flutter_activity_recognition.dart';
import 'package:geolocator/geolocator.dart' hide ActivityType;
import 'package:rxdart/rxdart.dart';
import 'models/score.dart';
import 'services/walking_services.dart';

class WalkingCounter extends StatefulWidget {
  WalkingCounter({Key? key}) : super(key: key);

  @override
  State<WalkingCounter> createState() => _WalkingCounterState();
}

class _WalkingCounterState extends State<WalkingCounter> {
  final FlutterActivityRecognition activityRecognition =
      FlutterActivityRecognition.instance;
  final StreamController<Position> _streamController =
      StreamController.broadcast();
  final StreamController<ActivityType> _simulatedActivityController =
      StreamController.broadcast();
  late Stream<dynamic> _activityPositionStream;

  num distance = 0;
  Position? lastPosition;

  @override
  void initState() {
    // _simulatedActivityController.stream.listen(print);
    // activityRecognition.activityStream.listen((event) {
    //   print(event.type);
    // });
    _activityPositionStream = CombineLatestStream.combine2(
      _simulatedActivityController.stream,
      Geolocator.getPositionStream(
          locationSettings: LocationSettings(distanceFilter: 0)),
      (ActivityType a, Position b) => [a, b],
    );
    super.initState();
  }

  @override
  void dispose() {
    _streamController.close();
    super.dispose();
  }

  void addScore() {
    WalkingServices.addScore(Score(points: 45, distance: 500));
  }

  @override
  Widget build(BuildContext context) {
    Geolocator.getPositionStream(
            locationSettings: LocationSettings(distanceFilter: 0))
        .listen((position) {
      _streamController.add(position);
      print(position);
    });
    return Scaffold(
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            ElevatedButton(
              onPressed: () =>
                  _simulatedActivityController.add(ActivityType.WALKING),
              child: Text("WALKING"),
            ),
            ElevatedButton(
              onPressed: () =>
                  _simulatedActivityController.add(ActivityType.RUNNING),
              child: Text("RUNNING"),
            ),
            ElevatedButton(
              onPressed: () =>
                  _simulatedActivityController.add(ActivityType.STILL),
              child: Text("STILL"),
            ),
            StreamBuilder<dynamic>(
              stream: _activityPositionStream,
              builder: (context, snapshot) {
                if (!snapshot.hasData) {
                  return CircularProgressIndicator();
                }
                var activity = snapshot.data![0];
                var position = snapshot.data![1];
                if (activity == ActivityType.WALKING || activity == ActivityType.RUNNING) {
                  if (lastPosition != null) {
                    distance += Geolocator.distanceBetween(
                        lastPosition!.latitude,
                        lastPosition!.longitude,
                        position.latitude,
                        position.longitude);
                  }
                }
                if (distance > 0 && activity == ActivityType.WALKING) {
                  var points = distance / 10;
                  WalkingServices.addScore(Score(
                      points: points.floor(), distance: distance.floor()));
                }
                else if (distance > 0 && activity == ActivityType.RUNNING){
                  var points = distance / 8;
                  WalkingServices.addScore(Score(
                      points: points.floor(), distance: distance.floor()));
                }

                lastPosition = position;
                print(distance);
                return Text("$distance");
              },
            ),
          ],
        ),
      ),
    );
  }
}

/*
Get distance only when walking or running

if (walking || running) {
  calculateScore()
}
*/

// --W---R----W----S----W------

// --P--P--P--P--P--P

// --[W,P]--[W,P]--[R,P]--