feat: good luck remi

app/android/app/src/main/AndroidManifest.xml

@@ -4,6 +4,9 @@
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.VIBRATE"/>
    <uses-permission android:name="android.permission.CAMERA" />
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+    <uses-permission android:name="android.permission.ACTIVITY_RECOGNITION" />
+    <uses-permission android:name="com.google.android.gms.permission.ACTIVITY_RECOGNITION" />
    <application
         android:label="PhysiGo"
         android:name="${applicationName}"

app/lib/main.dart

@@ -30,12 +30,16 @@ class PhysiGo extends StatelessWidget {
       ),
       initialRoute: '/',
       routes: {
-        '/': (context) => MyHomePage(title: '',),
+        '/': (context) => MyHomePage(
+              title: '',
+            ),
         '/register': (context) => SignupPage(),
         //'/register2': (context) => RegisterScreen2(title: ''),
         //'/register3': (context) => RegisterScreen3(title: ''),
         '/login': (context) => LogIn(title: ''),
-        '/profilePage': (context) => ProfilePage(title: '',),
+        '/profilePage': (context) => ProfilePage(
+              title: '',
+            ),
         '/mainPage': (context) => MainPage()
       },
       //home: const MyHomePage(title: 'Flutter Demo Home Page'),

app/lib/walking/walking_page.dart

@@ -0,0 +1,129 @@
+import 'dart:async';
+
+import 'package:flutter/material.dart';
+import 'package:flutter_activity_recognition/flutter_activity_recognition.dart';
+import 'package:geolocator/geolocator.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();
+  num distance = 0;
+  Position? lastPosition;
+  @override
+  void dispose() {
+    _streamController.close();
+    super.dispose();
+  }
+
+  @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: [
+            FutureBuilder<bool>(
+              future: isPermissionGrants(),
+              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 {
+                  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;
+                  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();
+                }
+              },
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+
+  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.');
+    }
+  }
+}

app/pubspec.lock

@@ -160,6 +160,13 @@ packages:
     description: flutter
     source: sdk
     version: "0.0.0"
+  flutter_activity_recognition:
+    dependency: "direct main"
+    description:
+      name: flutter_activity_recognition
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "1.3.0"
   flutter_compass:
     dependency: transitive
     description:
@@ -199,12 +206,12 @@ packages:
     source: sdk
     version: "0.0.0"
   geolocator:
-    dependency: transitive
+    dependency: "direct main"
     description:
       name: geolocator
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "8.2.0"
+    version: "8.2.1"
   geolocator_android:
     dependency: transitive
     description:

app/pubspec.yaml

@@ -46,6 +46,8 @@ dependencies:
   firebase_messaging: ^11.4.0
   awesome_notifications: ^0.6.21
   firebase_auth: ^3.3.17
+  flutter_activity_recognition: ^1.3.0
+  geolocator: ^8.2.1
 
 dev_dependencies:
   flutter_test: