ViewModel really solves a lot of problems I have encountered while working without one. I used to implement various hacks to pass data between Fragments or between Activity and Fragments. With ViewModel, it's no longer necessary to manually implement the Observer pattern.

The Preferences should have the option to set this hyper parameter.

the camera should obviously be able to zoom. Although the range is constant, the default zoom setting is probably not the optimal setting for our use case.

Current State

In some rare cases, the Serial Bluetooth connection has disconnected in the past. Why exactly this happens can be hard to determine, I haven't been able to reproduce this bug. The problem is most likely the microcontroller. (Hardware problem ;)
If that ever happens during tournament, I want to have backup plan. Too much depends on this connection.

Solution

Backup Plan: Recovery

Implement a recovery sequence that starts if the Bluetooth connection drops.

1. Pop the TerminalFragment from the backstack,
2. This results in coming back to the previous Fragment and then it should automatically reconnect, because that Fragment has that ability in onResume

For this to work, the device has to be uniquely identified (MAC-Address).

Edit: I now have a recovery sequence

Note: this is different depending on whether or not the auto-rotate is enabled on the phone
It also directly influences the API, which assumes the rotation is correct.

That is a good idea. It's always possible that something breaks. If the C++ Layer throws an Exception, the Java Application likely crashes

https://stackoverflow.com/questions/8415032/catching-exceptions-thrown-from-native-code-running-on-android

It is best practice to delete global references in C++ when the application shutdowns.

env->DeleteGlobalRef(...) for all global variables!

General idea:

Thread 1:
After the API-Button is clicked, it should take a photo and wait for it to save.
(maybe remember it's name latestName so we know exactly which one it is.)
possible implementation: Callable the kotlin equivalent

Thread 2:
Join Thread 1. We can be sure image is saved. Now it it's time to actually do the request and pass the link to the file as a parameter to RetrofitWrapper. The link itself will probably be queried form the database, something like SELECT Plant where name = latestName

-> Executors for this? There will be multiple images in a row, at least 5.

idea: To save the global state, use a text file. In this text file, there is a boolean value RUNNING_FIRST_TIME = true; which can be used to automatically re-direct to MainActivity2 in case of a native layer crash.

Just convenient. This can be implemented quickly, so you don't have to scroll and search in all Bluetooth devices

The NanodetncnnActivity is in a sense the central piece of the app. It has experienced lots of change over the months, and as a result, it's complexity has dramatically increased.

To address this issue, I will combine NanodetncnnActivity with QrCodeActivity into a single Unit. Additionally, this mitigates the awkwardness of inter-Activity communication. . .

The counter will be reset every n Milliseconds. n is variable, can be changed through shared prefs.

We will add a new Fragment. This Fragment will be inside the Camera Activity.

Check out how other apps are doing it, for example magisk

I'm pretty sure this can only be done once, and that's enough. Cache the result as 'jmethodID instanceMethod_CallInJava'

This is a very simple idea: Vibrate when a plant is detected (allows for easier testing)

https://stackoverflow.com/questions/31922708/android-change-priority-application-for-rooted-device
This will require a rooted device, but might even more increase performance.
Even better: Kill all processes which are not system critical

This can be done using an image comparision algorithm -> does not necessarily have to be on device.

This will require a shared interface.

I currenly use this code to manually get a reference to the instance of the Fragment:

        val navHostFragment = binding.fragmentContainer.getFragment<NavHostFragment>()
        val fragment: Fragment = navHostFragment.childFragmentManager.fragments[0]
        val intermediateFragment = fragment as IntermediateFragment

        intermediateFragment.navigateToCameraFragment()

This works fine. It's however quite the opposite of elegant.
It is possible to achieve the same by just using a ViewModel. This approach is better because is less complex, needs less code.
Just use the GlobalStateViewModel to actually start the Fragment Transition to CameraFragment

The class MainActivityNanodetNCNN has a method plantVaseDetectedCallback which makes use of a local variable count to track the number of confirmations from the object detection model.

To prevent this counter from accumulating, I suppose it's a good idea to reset it after a few seconds (let's say two seconds)

This can be done with a simple flag in the GlobalStateViewModel

In case of a crash, I want to be able to view the logs. The most reasonable approach is to use existing solutions.

See the Java Native Interface Specification

Important Note

Wifi Mac-Address and Bluetooth Mac-Adress are in fact not the same in ESP32 microcontroller!!

Of course crashes have to be avoided at all costs (as for example this issue #9) , but I don't want to bet on it to never happen. If a crash ever happens, implement a base Activity, which automatically start a new Instance of NanodetActivity. in onCreate()

This is kind off a hack, but it's certainly faster than taking a picture with the Camera2 api at full resolution.
Resolution does not matter that much, speed does.

It might be handy in the future to be able to toggle this off as well.

The general idea is to orchestrate communication using the Observer Pattern.

1. If we receive signal start over Bluetooth, TerminalFragment changes the state in the associated ViewModel.
2. That ViewModel is observed in the HostActivity, NanodetncnnActivity in this case.
3. Code in the HostActivity can start a Network thread to update the timer

Extend the MainActivity. Need more space to test things out.
I will choose fragments over activites whenever possible

State

Currently, I am calling the send method from NanodetncnnActivity That method is used to send commands over Bluetooth.

Problem

The problem is that it is a unsafe call.
The send method is in fact an instance method of the TerminalFragment. I'm calling method of fragment from it's HostActivity. The current solution is kind of a hack. First of all, that reference might be null. This is unacceptable, we have to find a better solution.

Solution

To avoid calling a function on a Nullable object, create a new ViewModel. This ViewModel will be used in only one direction, TerminalFragment is only observing changes.

I don't want to use the existing GlobalStateViewModel because there would be a feedback loop. The value it would change would also be observed at the same place.

The objects plant / vase are sometimes detected for a split second. It would be interesting to know the probability.

For this I will have to modify NanoDet::invoke_class_from_static which forwards this probability form NDK to the Android Code.