feat: calculate points based on distance

app/lib/walking/models/score.dart

@@ -0,0 +1,10 @@
+class Score {
+  int points;
+  int distance;
+
+  Score({required this.points, required this.distance});
+
+  Map<String, dynamic> toMap(){
+      return{"points" : points, "distance": distance};
+  }
+}

app/lib/walking/services/walking_services.dart

@@ -0,0 +1,16 @@
+import 'package:cloud_firestore/cloud_firestore.dart';
+
+import '../models/score.dart';
+
+class WalkingServices {
+  static final db = FirebaseFirestore.instance;
+
+  static dynamic addScore(Score score) {
+    // final user = {"score": score.points, "distance": score.distance};
+    db
+        .collection("scores")
+        .add(score.toMap())
+        .then((DocumentReference doc) => print('DocumentSnapshot added with ID: ${doc.id}'));
+  }
+
+}

app/lib/walking/walking_page.dart

@@ -2,7 +2,11 @@ import 'dart:async';
 
 import 'package:flutter/material.dart';
 import 'package:flutter_activity_recognition/flutter_activity_recognition.dart';
-import 'package:geolocator/geolocator.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);
@@ -14,14 +18,33 @@ class WalkingPage extends StatefulWidget {
 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) {
@@ -33,42 +56,42 @@ class _WalkingPageState extends State<WalkingPage> {
         child: Column(
           mainAxisAlignment: MainAxisAlignment.center,
           children: [
-            FutureBuilder<bool>(
-              future: isPermissionGrants(),
+            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 && snapshot.data!) {
-                  return StreamBuilder<Activity>(
-                    stream: activityRecognition.activityStream,
-                    builder: (context, snapshot) {
-                      if (snapshot.hasData) {
-                        return Text("${snapshot.data!.type}, ${snapshot.data!.confidence}");
-                      } else {
-                        return CircularProgressIndicator();
-                      }
-                    },
-                  );
-                } else {
+                if (!snapshot.hasData) {
                   return CircularProgressIndicator();
                 }
-              },
-            ),
-            StreamBuilder<Position>(
-              stream: _streamController.stream,
-              builder: (context, snapshot) {
-                if (snapshot.hasData) {
-                  final position = snapshot.data!;
-                  final latitude = position.latitude;
-                  final longitude = position.longitude;
-                  final currentActivity = activityRecognition.activityStream.last;
+                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);
                   }
-                  lastPosition = position;
-                  return Text("${latitude}, ${longitude}, DISTANCE: ${distance.round()}");
-                } else {
-                  return CircularProgressIndicator();
                 }
+                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");
               },
             ),
           ],
@@ -127,3 +150,18 @@ class _WalkingPageState extends State<WalkingPage> {
     }
   }
 }
+
+/*
+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]--