hlcaptain / jay-android Goto Github PK

Hide name, email and phone from Profile screen behind proper authentication, like biometric auth or pin.

Comply with attribution rules. When using Mapbox Map or Search, add the neccessary labels to the app.

During closed testing, some issues have come up and I decided to patch them up in an issue. Also some legal concerns are being assessed as well with data collection.

Extend setup documentation with paying attention to Gradle JVM versions (can cause problems when syncing using the JVM Toolchain).

Write some basic documentation regarding new features, showcase functionality with media, like pictrues, gifs and video. Be thorough, but don't go in-depth too much.

When Jay suddenly crashes, on next startup, try to close any dangling sessions, not stopped yet. When there are ongoing sessions without a running service, stop those sessions by reading the last sensor event or location event associated with them.

System for handling history, favorite and search suggestion records are not made for multi user use. The interface don't filter out others' results. Show records on a per user basis. Implement it via Firestore if needed, replacing the current Mapbox implementation.

There is a strange problem when running unit tests in ServiceInteractorTest.kt. The test sometimes passes, sometimes failes depending on how the tests are run, ie. running all tests in illyan.jay.interactor.ServiceInteractorTest.kt, or running tests in illyan.jay package or running tests in illyan.jay.interactor.

Start measuring performance via Firebase Performance and/or implement Baseline Profiles. Keep in mind to avoid premature optimizations. This issue's primary forcus is performance monitoring.

Utilize Timber and its capabilities by not only log to Logcat, but log to Firebase Analytics as well.

If it makes sense, place more logging information in the code.

With robust testing libraries, such as Mockk and JUnit5, write a basic unit test suite for domain and sub-domain (data access) classes.

For UI tests, use Espresso.

Local owned sessions are not disappearing when user signed out.

Mapbox needs a different build setup from Google Maps'.

Should remove local.properties and place the right keys into gradle.properties to build successfully.

Refactor handling of sessions, so syncing with local and cloud databases will be easier to do. May poke around store logic for sessions. Assign a unique identifier for each one, for example.

UI has taken some heavy punches as development was more functionality driven than usability driven. Redesign bad looking UI Composables with Figma, a great time to try out the newly released Relay Plugin as well. Implement theming into Jay and have a dark great dark mode experience.

Implement a CICD pipeline which automatically runs tests, as well as statically analizes the code via SonarCloud.

Enable Path to filter more information with the use of the gradient. E.g. having the speed of the vehicle shown as a gradient on the path, or the accuracy of the GPS signal during the Session.

Use Firebase to give personalized key to encode data for each user using a certain device. This is done to reduce unauthenticated access to locally cached data. Implementation can change drastically, this issue is kind of a Proof-of-Concept (POC).

Implement the usage of MLKit and machine learning models in the app to process raw data collected on-device.

Enable users to authenticate themselves via their Google accounts using Firebase Authentication.

Permission Dispatcher is using a deprecated method of acquiring permissions. Should look out for another method of requesting permissions which utilize the more robust Activity Result API.

Not enough Exception is being thrown currently which means, there might be bugs sneaking by silently. When assuming a state, don't just return when something is wrong, but actively throw an exception to find out what caused the wrong state in the first place.

Add privacy policy, list additional libraries, list main developers, add the ad button.

Firestore operations can be interrupted, which might destroy consistency. With transactions and batches, operations which are already run are reverted if a failure happens during a transaction.

The UI should not depend on classes, other than custom, self wrote state data classes. In Search.kt, there are multiple instances when we are depending from Mapbox's implementation and data classes of favorite and search history items. Create a model package inside multiple UI elements which should depend on custom UI state data classes, so they become Previewable.

Implement data sync to the cloud of Sessions and location data related to them. Modify current Composables listing these elements to reflect the option to sync when signed in.

Leverage the power of Material Design 3 Motion documents and enhance, theme current animations:

• AnimatedVisibility
• Transitions when navigating in app
• Animations of changing variables

Try to make use of Bill of Material type libraries, because only one BOM library needs to be implemented instead of 5+ when using multiple sublibraries of a tech. They also tent to be well tested together and more stable than linking other libraries with different versions.

As I transition from RainbowCake to MVVM, I decided to rename domain and data layer classes to use cases and repositories. Final decisions may vary.

Make sessions selectable and enable making individual actions using a gesture, be it a long press or swipe, etc.

Auto sign out may be a great feature for enterprise users, as multiple users may use a singular device with multiple accounts. When auto sign out is enabled, privacy of others may be preserved, when they forget to log out, as the system automatically does it for them.

Make a method of waiting for all writes to finish before commiting a batch. Current method is kind of hardcoded and could be improved.

Implement MapBox's search API into Jay.

Currently not all flows are StateFlow and that limits flexibility when a state must be returned immediately.

Migrate all existing flows using map, mapLatest, flatMapLatest, etc. functions using stateIn at the end to convert flow to stateFlow again.

Does not use Firebase Performance when the app is in DEBUG mode. It can be misleading during development, before release.

Try to make data storing more efficient. Convert doubles to floats, reduce sensor updates, etc. Make cloud sync more efficient and cost and storage effective, more scalable.

Reduce collected data sizes using serialization, compression. Use Kotlin's Serialization library and ZLIB/GZIP if necessary. Experiment, test out new ways of compressing the data.

Use the new Firestore feature where flows can be used instead of listeners. Explore when it would be useful and how to use it with cache as well.

Fuse data from IMU and GPS sensors together with an extended kalman filter, or similar.

Migrate to using Mapbox instead of Google Maps because it is more versatile.

Place a Start and End pin on Path. Start can be a green, or white colored one, End should be a finish line, flag or something checked.

When a Viewmodel calls an async method to retrieve data from a database, usually it is done using Dispatchers.IO. As in Interactor classes, replace these hardcoded dispatchers using Dependency Injection, as with Interactor classes.

Make a screen which lists user preferences, has an about section, licences, privacy policy, etc.

Duplicate sessions in cloud. Sessions not loading from cloud. Kinda URGENT.

• Don't make mapbox search queries when there is no internet
• Show the user that there is no internet connection

Create model classes for Firestore documents to eliminate getting resources from raw string references. This enables us to be more flexible when handling data transactions.

Current code:

val pathSnapshotListener = firestore
    .collection(PathsCollectionPath)
    .whereEqualTo("ownerUUID", authInteractor.userUUID)
    .addSnapshotListener { pathSnapshot, pathError ->
        if (pathError != null) {
            Timber.e(pathError, "Error while deleting user data: ${pathError.message}")
        } else if (!arePathsDeleted.value) {
            Timber.d("Delete ${pathSnapshot!!.documents.size} path data for user ${authInteractor.userUUID?.take(4)}")
            pathSnapshot.documents.forEach {
                it.reference.delete()
            }
            arePathsDeleted.value = true
        }
    }

New code should try to eliminate using raw strings, like "ownerUUID" and PathsCollectionPath.

Implement basic functionality and proper navigation flow into Jay.

The user should be flawlessly turn on navigation and Jay tracks their phone's sensors.
The solution must be UX friendly. Location of the phone should be taken into consideration.
Permissions must be handled properly when needed.

Make use of Compose Preview by making Composables independent from the viewModel injected by Hilt.

Here are some official Google code examples showcasing possible solutions.

I plan to support Compose instead of XML, as well as redesign the UI to be more user friendly and less MVP-like.