permission + running's points

app/lib/walking/walking_counter.dart

@@ -0,0 +1,143 @@
+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);
+                  }
+                // } else if (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]--

app/lib/walking/walking_page.dart

@@ -1,167 +0,0 @@
-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]--

app/lib/walking/walking_permission.dart

@@ -0,0 +1,79 @@
+import 'package:flutter/cupertino.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_activity_recognition/flutter_activity_recognition.dart';
+import 'package:flutter_activity_recognition/models/permission_request_result.dart';
+import 'package:geolocator/geolocator.dart';
+import 'package:physigo/walking/walking_counter.dart';
+
+class WalkingPermission extends StatelessWidget {
+  WalkingPermission({Key? key}) : super(key: key);
+  final FlutterActivityRecognition activityRecognition =
+      FlutterActivityRecognition.instance;
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      body: FutureBuilder(
+        future: Future.wait([isPermissionGrants(), _getPermissions()]),
+        builder: (context, snapshot) {
+          if (snapshot.connectionState == ConnectionState.waiting) {
+            return CircularProgressIndicator();
+          } else if (snapshot.hasError) {
+            return Text("ca morch pa gros con");
+          } else {
+            return WalkingCounter();
+          }
+        },
+      ),
+    );
+  }
+
+  Future<void> 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 Future.error('Activity permissions are denied');
+    } else if (reqResult == PermissionRequestResult.DENIED) {
+      reqResult = await activityRecognition.requestPermission();
+      if (reqResult != PermissionRequestResult.GRANTED) {
+        print('Permission is denied.');
+        return Future.error('Activity permissions are denied');
+      }
+    }
+  }
+
+  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.');
+    }
+  }
+}