PhysiGo/app/lib/walking/walking_page.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 WalkingPage extends StatefulWidget {
  WalkingPage({Key? key}) : super(key: key);

  @override
  State<WalkingPage> createState() => _WalkingPageState();
}

class _WalkingPageState extends State<WalkingPage> {
  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);
    _activityPositionStream = CombineLatestStream.combine2(
      _simulatedActivityController.stream,
      Geolocator.getPositionStream(locationSettings: LocationSettings(distanceFilter: 5)),
      (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: 1)).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.RUNNING || activity == ActivityType.WALKING) {
                  if (lastPosition != null) {
                    distance += Geolocator.distanceBetween(
                        lastPosition!.latitude, lastPosition!.longitude, position.latitude, position.longitude);
                  }
                }
                else{
                  if(distance>0){
                    var points=distance/10;
                    WalkingServices.addScore(Score(points: points.floor(), distance: distance.floor()));
                    distance=0;
                  }
                }
                lastPosition = position;
                print(distance);
                return Text("$distance");
              },
            ),
          ],
        ),
      ),
    );
  }

  Future<bool> isPermissionGrants() async {
    // Check if the user has granted permission. If not, request permission.
    PermissionRequestResult reqResult;
    reqResult = await activityRecognition.checkPermission();
    if (reqResult == PermissionRequestResult.PERMANENTLY_DENIED) {
      print('Permission is permanently denied.');
      return false;
    } else if (reqResult == PermissionRequestResult.DENIED) {
      reqResult = await activityRecognition.requestPermission();
      if (reqResult != PermissionRequestResult.GRANTED) {
        print('Permission is denied.');
        return false;
      }
    }

    return true;
  }

  Future<void> _getPermissions() async {
    bool serviceEnabled;
    LocationPermission permission;

    // Test if location services are enabled.
    serviceEnabled = await Geolocator.isLocationServiceEnabled();
    if (!serviceEnabled) {
      // Location services are not enabled don't continue
      // accessing the position and request users of the
      // App to enable the location services.
      return Future.error('Location services are disabled.');
    }

    permission = await Geolocator.checkPermission();
    if (permission == LocationPermission.denied) {
      permission = await Geolocator.requestPermission();
      if (permission == LocationPermission.denied) {
        // Permissions are denied, next time you could try
        // requesting permissions again (this is also where
        // Android's shouldShowRequestPermissionRationale
        // returned true. According to Android guidelines
        // your App should show an explanatory UI now.
        return Future.error('Location permissions are denied');
      }
    }

    if (permission == LocationPermission.deniedForever) {
      // Permissions are denied forever, handle appropriately.
      return Future.error('Location permissions are permanently denied, we cannot request permissions.');
    }
  }
}

/*
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]--