From 443af25fce39ed0b4aab6f61e2995709f270e2e7 Mon Sep 17 00:00:00 2001 From: darken Date: Tue, 28 Dec 2021 17:11:50 +0100 Subject: [PATCH] POC, decoding works. --- .gitignore | 3 + README.md | 38 +- app/.gitignore | 1 + app/build.gradle | 230 ++++++++++++ app/proguard-rules-debug.pro | 1 + app/proguard/proguard-rules.pro | 21 ++ app/src/main/AndroidManifest.xml | 57 +++ app/src/main/java/eu/darken/cap/App.kt | 49 +++ .../cap/bugreporting/BugReportSettings.kt | 20 + .../eu/darken/cap/bugreporting/BugReporter.kt | 57 +++ .../java/eu/darken/cap/bugreporting/Bugs.kt | 21 ++ .../eu/darken/cap/common/BuildConfigWrap.kt | 16 + .../java/eu/darken/cap/common/BuildWrap.kt | 16 + .../darken/cap/common/ByteArrayExtensions.kt | 14 + .../eu/darken/cap/common/ContextExtensions.kt | 40 ++ .../java/eu/darken/cap/common/InstallId.kt | 42 +++ .../darken/cap/common/LiveDataExtensions.kt | 23 ++ .../darken/cap/common/bluetooth/BleScanner.kt | 68 ++++ .../cap/common/bluetooth/BluetoothDevice2.kt | 14 + .../bluetooth/BluetoothDeviceExtensions.kt | 8 + .../cap/common/bluetooth/BluetoothManager2.kt | 145 ++++++++ .../cap/common/bluetooth/BluetoothProfile2.kt | 23 ++ .../cap/common/collections/MapExtensions.kt | 5 + .../cap/common/coroutine/AppCoroutineScope.kt | 19 + .../cap/common/coroutine/CoroutineModule.kt | 19 + .../coroutine/DefaultDispatcherProvider.kt | 7 + .../common/coroutine/DispatcherProvider.kt | 21 ++ .../darken/cap/common/dagger/AndroidModule.kt | 36 ++ .../debug/bugsnag/BugsnagErrorHandler.kt | 56 +++ .../cap/common/debug/bugsnag/BugsnagLogger.kt | 47 +++ .../debug/bugsnag/NOPBugsnagErrorHandler.kt | 19 + .../cap/common/debug/logging/LogCatLogger.kt | 49 +++ .../cap/common/debug/logging/LogExtensions.kt | 10 + .../cap/common/debug/logging/Logging.kt | 132 +++++++ .../eu/darken/cap/common/error/ErrorDialog.kt | 18 + .../cap/common/error/ErrorEventSource.kt | 7 + .../darken/cap/common/error/LocalizedError.kt | 36 ++ .../cap/common/error/ThrowableExtensions.kt | 42 +++ .../cap/common/flow/DynamicStateFlow.kt | 149 ++++++++ .../common/flow/DynamicStateFlowExtensions.kt | 3 + .../cap/common/flow/FlowCombineExtensions.kt | 213 +++++++++++ .../darken/cap/common/flow/FlowExtensions.kt | 74 ++++ .../eu/darken/cap/common/lists/BaseAdapter.kt | 58 +++ .../eu/darken/cap/common/lists/BindableVH.kt | 14 + .../eu/darken/cap/common/lists/DataAdapter.kt | 13 + .../eu/darken/cap/common/lists/ListItem.kt | 3 + .../common/lists/RecyclerViewExtensions.kt | 13 + .../cap/common/lists/differ/AsyncDiffer.kt | 43 +++ .../lists/differ/AsyncDifferExtensions.kt | 15 + .../cap/common/lists/differ/DifferItem.kt | 10 + .../cap/common/lists/differ/HasAsyncDiffer.kt | 10 + .../common/lists/modular/ModularAdapter.kt | 95 +++++ .../cap/common/lists/modular/mods/ClickMod.kt | 12 + .../lists/modular/mods/DataBinderMod.kt | 17 + .../lists/modular/mods/SimpleVHCreatorMod.kt | 15 + .../common/lists/modular/mods/StableIdMod.kt | 21 ++ .../lists/modular/mods/TypedVHCreatorMod.kt | 29 ++ .../cap/common/livedata/SingleLiveEvent.kt | 76 ++++ .../common/navigation/FragmentExtensions.kt | 38 ++ .../common/navigation/NavArgsExtensions.kt | 20 + .../navigation/NavControllerExtensions.kt | 22 ++ .../navigation/NavDestinationExtensions.kt | 9 + .../navigation/NavDirectionsExtensions.kt | 13 + .../cap/common/permissions/Permission.kt | 32 ++ .../cap/common/preferences/FlowPreference.kt | 90 +++++ .../preferences/SharedPreferenceExtensions.kt | 16 + .../smart/Smart2BottomSheetDialogFragment.kt | 95 +++++ .../darken/cap/common/smart/Smart2Fragment.kt | 53 +++ .../eu/darken/cap/common/smart/Smart2VM.kt | 34 ++ .../darken/cap/common/smart/SmartActivity.kt | 39 ++ .../darken/cap/common/smart/SmartFragment.kt | 80 ++++ .../darken/cap/common/smart/SmartService.kt | 52 +++ .../eu/darken/cap/common/smart/SmartVM.kt | 64 ++++ .../viewbinding/ViewBindingExtensions.kt | 93 +++++ .../eu/darken/cap/common/viewmodel/SmartVM.kt | 15 + .../java/eu/darken/cap/common/viewmodel/VM.kt | 20 + .../common/viewmodel/ViewModelLazyKeyed.kt | 174 +++++++++ .../cap/common/worker/WorkerExtensions.kt | 31 ++ .../eu/darken/cap/main/ui/MainActivity.kt | 24 ++ .../eu/darken/cap/main/ui/MainActivityVM.kt | 16 + .../java/eu/darken/cap/main/ui/MainAdapter.kt | 39 ++ .../eu/darken/cap/main/ui/MainFragment.kt | 56 +++ .../eu/darken/cap/main/ui/MainFragmentVM.kt | 68 ++++ .../cap/main/ui/cards/PermissionCardVH.kt | 34 ++ .../darken/cap/main/ui/cards/ToggleCardVH.kt | 35 ++ .../cap/monitor/core/MonitorComponent.kt | 18 + .../cap/monitor/core/MonitorCoroutineScope.kt | 11 + .../darken/cap/monitor/core/MonitorModule.kt | 16 + .../darken/cap/monitor/core/MonitorScope.kt | 8 + .../eu/darken/cap/monitor/core/PodMonitor.kt | 30 ++ .../core/receiver/BluetoothEventReceiver.kt | 67 ++++ .../cap/monitor/core/worker/MonitorControl.kt | 51 +++ .../cap/monitor/core/worker/MonitorWorker.kt | 121 ++++++ .../core/worker/MonitorWorkerEntryPoint.kt | 14 + .../cap/monitor/ui/MonitorNotifications.kt | 92 +++++ .../java/eu/darken/cap/pods/core/PodDevice.kt | 12 + .../eu/darken/cap/pods/core/PodFactory.kt | 36 ++ .../cap/pods/core/airpods/AirPodsDevice.kt | 191 ++++++++++ .../cap/pods/core/airpods/AirPodsFactory.kt | 110 ++++++ .../darken/cap/pods/core/airpods/ApplePods.kt | 14 + .../pods/core/airpods/ContinuityProtocol.kt | 66 ++++ .../cap/pods/core/airpods/ProximityPairing.kt | 60 +++ .../pods/core/airpods/models/AirPodsGen1.kt | 13 + .../pods/core/airpods/models/AirPodsGen2.kt | 13 + .../pods/core/airpods/models/AirPodsMax.kt | 10 + .../pods/core/airpods/models/AirPodsPro.kt | 14 + .../core/airpods/models/UnknownAppleDevice.kt | 10 + .../drawable-v24/ic_launcher_foreground.xml | 30 ++ .../main/res/drawable/ic_baseline_add_24.xml | 10 + .../res/drawable/ic_launcher_background.xml | 170 +++++++++ .../ic_notification_device_status_icon.xml | 10 + app/src/main/res/drawable/launch_screen.xml | 10 + app/src/main/res/layout/main_activity.xml | 20 + app/src/main/res/layout/main_fragment.xml | 37 ++ .../main/res/layout/main_permission_item.xml | 66 ++++ app/src/main/res/layout/main_toggle_item.xml | 41 ++ .../res/mipmap-anydpi-v26/ic_launcher.xml | 5 + .../mipmap-anydpi-v26/ic_launcher_round.xml | 5 + app/src/main/res/mipmap-hdpi/ic_launcher.png | Bin 0 -> 3593 bytes .../res/mipmap-hdpi/ic_launcher_round.png | Bin 0 -> 5339 bytes app/src/main/res/mipmap-mdpi/ic_launcher.png | Bin 0 -> 2636 bytes .../res/mipmap-mdpi/ic_launcher_round.png | Bin 0 -> 3388 bytes app/src/main/res/mipmap-xhdpi/ic_launcher.png | Bin 0 -> 4926 bytes .../res/mipmap-xhdpi/ic_launcher_round.png | Bin 0 -> 7472 bytes .../main/res/mipmap-xxhdpi/ic_launcher.png | Bin 0 -> 7909 bytes .../res/mipmap-xxhdpi/ic_launcher_round.png | Bin 0 -> 11873 bytes .../main/res/mipmap-xxxhdpi/ic_launcher.png | Bin 0 -> 10652 bytes .../res/mipmap-xxxhdpi/ic_launcher_round.png | Bin 0 -> 16570 bytes app/src/main/res/navigation/nav_graph.xml | 15 + app/src/main/res/values-night/themes.xml | 32 ++ app/src/main/res/values/colors.xml | 57 +++ app/src/main/res/values/strings.xml | 10 + app/src/main/res/values/styles.xml | 9 + app/src/main/res/values/themes.xml | 32 ++ .../cap/common/flow/DynamicStateFlowTest.kt | 351 ++++++++++++++++++ .../pods/core/airpods/AirPodsFactoryTest.kt | 290 +++++++++++++++ .../cap/pods/core/airpods/BaseAirPodsTest.kt | 58 +++ .../core/airpods/models/AirPodsGen1Test.kt | 42 +++ .../core/airpods/models/AirPodsGen2Test.kt | 41 ++ .../core/airpods/models/AirPodsProTest.kt | 194 ++++++++++ app/src/test/java/testhelper/BaseTest.kt | 29 ++ .../coroutine/CoroutinesTestExtension.kt | 26 ++ .../coroutine/TestDispatcherProvider.kt | 23 ++ .../testhelper/coroutine/TestExtensions.kt | 49 +++ app/src/test/java/testhelper/flow/FlowTest.kt | 101 +++++ .../livedata/InstantExecutorExtension.kt | 26 ++ .../preferences/MockSharedPreferencesTest.kt | 22 ++ .../testhelpers/BaseTestInstrumentation.kt | 29 ++ .../java/testhelpers/IsAUnitTest.kt | 3 + .../java/testhelpers/logging/JUnitLogger.kt | 13 + .../preferences/MockFlowPreference.kt | 21 ++ .../preferences/MockSharedPreferences.kt | 99 +++++ build.gradle | 55 +++ gradle.properties | 19 + gradle/wrapper/gradle-wrapper.jar | Bin 0 -> 54329 bytes gradle/wrapper/gradle-wrapper.properties | 6 + gradlew | 172 +++++++++ gradlew.bat | 84 +++++ local.properties | 10 + settings.gradle | 2 + 160 files changed, 6875 insertions(+), 1 deletion(-) create mode 100644 .gitignore create mode 100644 app/.gitignore create mode 100644 app/build.gradle create mode 100644 app/proguard-rules-debug.pro create mode 100644 app/proguard/proguard-rules.pro create mode 100644 app/src/main/AndroidManifest.xml create mode 100644 app/src/main/java/eu/darken/cap/App.kt create mode 100644 app/src/main/java/eu/darken/cap/bugreporting/BugReportSettings.kt create mode 100644 app/src/main/java/eu/darken/cap/bugreporting/BugReporter.kt create mode 100644 app/src/main/java/eu/darken/cap/bugreporting/Bugs.kt create mode 100644 app/src/main/java/eu/darken/cap/common/BuildConfigWrap.kt create mode 100644 app/src/main/java/eu/darken/cap/common/BuildWrap.kt create mode 100644 app/src/main/java/eu/darken/cap/common/ByteArrayExtensions.kt create mode 100644 app/src/main/java/eu/darken/cap/common/ContextExtensions.kt create mode 100644 app/src/main/java/eu/darken/cap/common/InstallId.kt create mode 100644 app/src/main/java/eu/darken/cap/common/LiveDataExtensions.kt create mode 100644 app/src/main/java/eu/darken/cap/common/bluetooth/BleScanner.kt create mode 100644 app/src/main/java/eu/darken/cap/common/bluetooth/BluetoothDevice2.kt create mode 100644 app/src/main/java/eu/darken/cap/common/bluetooth/BluetoothDeviceExtensions.kt create mode 100644 app/src/main/java/eu/darken/cap/common/bluetooth/BluetoothManager2.kt create mode 100644 app/src/main/java/eu/darken/cap/common/bluetooth/BluetoothProfile2.kt create mode 100644 app/src/main/java/eu/darken/cap/common/collections/MapExtensions.kt create mode 100644 app/src/main/java/eu/darken/cap/common/coroutine/AppCoroutineScope.kt create mode 100644 app/src/main/java/eu/darken/cap/common/coroutine/CoroutineModule.kt create mode 100644 app/src/main/java/eu/darken/cap/common/coroutine/DefaultDispatcherProvider.kt create mode 100644 app/src/main/java/eu/darken/cap/common/coroutine/DispatcherProvider.kt create mode 100644 app/src/main/java/eu/darken/cap/common/dagger/AndroidModule.kt create mode 100644 app/src/main/java/eu/darken/cap/common/debug/bugsnag/BugsnagErrorHandler.kt create mode 100644 app/src/main/java/eu/darken/cap/common/debug/bugsnag/BugsnagLogger.kt create mode 100644 app/src/main/java/eu/darken/cap/common/debug/bugsnag/NOPBugsnagErrorHandler.kt create mode 100644 app/src/main/java/eu/darken/cap/common/debug/logging/LogCatLogger.kt create mode 100644 app/src/main/java/eu/darken/cap/common/debug/logging/LogExtensions.kt create mode 100644 app/src/main/java/eu/darken/cap/common/debug/logging/Logging.kt create mode 100644 app/src/main/java/eu/darken/cap/common/error/ErrorDialog.kt create mode 100644 app/src/main/java/eu/darken/cap/common/error/ErrorEventSource.kt create mode 100644 app/src/main/java/eu/darken/cap/common/error/LocalizedError.kt create mode 100644 app/src/main/java/eu/darken/cap/common/error/ThrowableExtensions.kt create mode 100644 app/src/main/java/eu/darken/cap/common/flow/DynamicStateFlow.kt create mode 100644 app/src/main/java/eu/darken/cap/common/flow/DynamicStateFlowExtensions.kt create mode 100644 app/src/main/java/eu/darken/cap/common/flow/FlowCombineExtensions.kt create mode 100644 app/src/main/java/eu/darken/cap/common/flow/FlowExtensions.kt create mode 100644 app/src/main/java/eu/darken/cap/common/lists/BaseAdapter.kt create mode 100644 app/src/main/java/eu/darken/cap/common/lists/BindableVH.kt create mode 100644 app/src/main/java/eu/darken/cap/common/lists/DataAdapter.kt create mode 100644 app/src/main/java/eu/darken/cap/common/lists/ListItem.kt create mode 100644 app/src/main/java/eu/darken/cap/common/lists/RecyclerViewExtensions.kt create mode 100644 app/src/main/java/eu/darken/cap/common/lists/differ/AsyncDiffer.kt create mode 100644 app/src/main/java/eu/darken/cap/common/lists/differ/AsyncDifferExtensions.kt create mode 100644 app/src/main/java/eu/darken/cap/common/lists/differ/DifferItem.kt create mode 100644 app/src/main/java/eu/darken/cap/common/lists/differ/HasAsyncDiffer.kt create mode 100644 app/src/main/java/eu/darken/cap/common/lists/modular/ModularAdapter.kt create mode 100644 app/src/main/java/eu/darken/cap/common/lists/modular/mods/ClickMod.kt create mode 100644 app/src/main/java/eu/darken/cap/common/lists/modular/mods/DataBinderMod.kt create mode 100644 app/src/main/java/eu/darken/cap/common/lists/modular/mods/SimpleVHCreatorMod.kt create mode 100644 app/src/main/java/eu/darken/cap/common/lists/modular/mods/StableIdMod.kt create mode 100644 app/src/main/java/eu/darken/cap/common/lists/modular/mods/TypedVHCreatorMod.kt create mode 100644 app/src/main/java/eu/darken/cap/common/livedata/SingleLiveEvent.kt create mode 100644 app/src/main/java/eu/darken/cap/common/navigation/FragmentExtensions.kt create mode 100644 app/src/main/java/eu/darken/cap/common/navigation/NavArgsExtensions.kt create mode 100644 app/src/main/java/eu/darken/cap/common/navigation/NavControllerExtensions.kt create mode 100644 app/src/main/java/eu/darken/cap/common/navigation/NavDestinationExtensions.kt create mode 100644 app/src/main/java/eu/darken/cap/common/navigation/NavDirectionsExtensions.kt create mode 100644 app/src/main/java/eu/darken/cap/common/permissions/Permission.kt create mode 100644 app/src/main/java/eu/darken/cap/common/preferences/FlowPreference.kt create mode 100644 app/src/main/java/eu/darken/cap/common/preferences/SharedPreferenceExtensions.kt create mode 100644 app/src/main/java/eu/darken/cap/common/smart/Smart2BottomSheetDialogFragment.kt create mode 100644 app/src/main/java/eu/darken/cap/common/smart/Smart2Fragment.kt create mode 100644 app/src/main/java/eu/darken/cap/common/smart/Smart2VM.kt create mode 100644 app/src/main/java/eu/darken/cap/common/smart/SmartActivity.kt create mode 100644 app/src/main/java/eu/darken/cap/common/smart/SmartFragment.kt create mode 100644 app/src/main/java/eu/darken/cap/common/smart/SmartService.kt create mode 100644 app/src/main/java/eu/darken/cap/common/smart/SmartVM.kt create mode 100644 app/src/main/java/eu/darken/cap/common/viewbinding/ViewBindingExtensions.kt create mode 100644 app/src/main/java/eu/darken/cap/common/viewmodel/SmartVM.kt create mode 100644 app/src/main/java/eu/darken/cap/common/viewmodel/VM.kt create mode 100644 app/src/main/java/eu/darken/cap/common/viewmodel/ViewModelLazyKeyed.kt create mode 100644 app/src/main/java/eu/darken/cap/common/worker/WorkerExtensions.kt create mode 100644 app/src/main/java/eu/darken/cap/main/ui/MainActivity.kt create mode 100644 app/src/main/java/eu/darken/cap/main/ui/MainActivityVM.kt create mode 100644 app/src/main/java/eu/darken/cap/main/ui/MainAdapter.kt create mode 100644 app/src/main/java/eu/darken/cap/main/ui/MainFragment.kt create mode 100644 app/src/main/java/eu/darken/cap/main/ui/MainFragmentVM.kt create mode 100644 app/src/main/java/eu/darken/cap/main/ui/cards/PermissionCardVH.kt create mode 100644 app/src/main/java/eu/darken/cap/main/ui/cards/ToggleCardVH.kt create mode 100644 app/src/main/java/eu/darken/cap/monitor/core/MonitorComponent.kt create mode 100644 app/src/main/java/eu/darken/cap/monitor/core/MonitorCoroutineScope.kt create mode 100644 app/src/main/java/eu/darken/cap/monitor/core/MonitorModule.kt create mode 100644 app/src/main/java/eu/darken/cap/monitor/core/MonitorScope.kt create mode 100644 app/src/main/java/eu/darken/cap/monitor/core/PodMonitor.kt create mode 100644 app/src/main/java/eu/darken/cap/monitor/core/receiver/BluetoothEventReceiver.kt create mode 100644 app/src/main/java/eu/darken/cap/monitor/core/worker/MonitorControl.kt create mode 100644 app/src/main/java/eu/darken/cap/monitor/core/worker/MonitorWorker.kt create mode 100644 app/src/main/java/eu/darken/cap/monitor/core/worker/MonitorWorkerEntryPoint.kt create mode 100644 app/src/main/java/eu/darken/cap/monitor/ui/MonitorNotifications.kt create mode 100644 app/src/main/java/eu/darken/cap/pods/core/PodDevice.kt create mode 100644 app/src/main/java/eu/darken/cap/pods/core/PodFactory.kt create mode 100644 app/src/main/java/eu/darken/cap/pods/core/airpods/AirPodsDevice.kt create mode 100644 app/src/main/java/eu/darken/cap/pods/core/airpods/AirPodsFactory.kt create mode 100644 app/src/main/java/eu/darken/cap/pods/core/airpods/ApplePods.kt create mode 100644 app/src/main/java/eu/darken/cap/pods/core/airpods/ContinuityProtocol.kt create mode 100644 app/src/main/java/eu/darken/cap/pods/core/airpods/ProximityPairing.kt create mode 100644 app/src/main/java/eu/darken/cap/pods/core/airpods/models/AirPodsGen1.kt create mode 100644 app/src/main/java/eu/darken/cap/pods/core/airpods/models/AirPodsGen2.kt create mode 100644 app/src/main/java/eu/darken/cap/pods/core/airpods/models/AirPodsMax.kt create mode 100644 app/src/main/java/eu/darken/cap/pods/core/airpods/models/AirPodsPro.kt create mode 100644 app/src/main/java/eu/darken/cap/pods/core/airpods/models/UnknownAppleDevice.kt create mode 100644 app/src/main/res/drawable-v24/ic_launcher_foreground.xml create mode 100644 app/src/main/res/drawable/ic_baseline_add_24.xml create mode 100644 app/src/main/res/drawable/ic_launcher_background.xml create mode 100644 app/src/main/res/drawable/ic_notification_device_status_icon.xml create mode 100644 app/src/main/res/drawable/launch_screen.xml create mode 100644 app/src/main/res/layout/main_activity.xml create mode 100644 app/src/main/res/layout/main_fragment.xml create mode 100644 app/src/main/res/layout/main_permission_item.xml create mode 100644 app/src/main/res/layout/main_toggle_item.xml create mode 100644 app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml create mode 100644 app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml create mode 100644 app/src/main/res/mipmap-hdpi/ic_launcher.png create mode 100644 app/src/main/res/mipmap-hdpi/ic_launcher_round.png create mode 100644 app/src/main/res/mipmap-mdpi/ic_launcher.png create mode 100644 app/src/main/res/mipmap-mdpi/ic_launcher_round.png create mode 100644 app/src/main/res/mipmap-xhdpi/ic_launcher.png create mode 100644 app/src/main/res/mipmap-xhdpi/ic_launcher_round.png create mode 100644 app/src/main/res/mipmap-xxhdpi/ic_launcher.png create mode 100644 app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png create mode 100644 app/src/main/res/mipmap-xxxhdpi/ic_launcher.png create mode 100644 app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png create mode 100644 app/src/main/res/navigation/nav_graph.xml create mode 100644 app/src/main/res/values-night/themes.xml create mode 100644 app/src/main/res/values/colors.xml create mode 100644 app/src/main/res/values/strings.xml create mode 100644 app/src/main/res/values/styles.xml create mode 100644 app/src/main/res/values/themes.xml create mode 100644 app/src/test/java/eu/darken/cap/common/flow/DynamicStateFlowTest.kt create mode 100644 app/src/test/java/eu/darken/cap/pods/core/airpods/AirPodsFactoryTest.kt create mode 100644 app/src/test/java/eu/darken/cap/pods/core/airpods/BaseAirPodsTest.kt create mode 100644 app/src/test/java/eu/darken/cap/pods/core/airpods/models/AirPodsGen1Test.kt create mode 100644 app/src/test/java/eu/darken/cap/pods/core/airpods/models/AirPodsGen2Test.kt create mode 100644 app/src/test/java/eu/darken/cap/pods/core/airpods/models/AirPodsProTest.kt create mode 100644 app/src/test/java/testhelper/BaseTest.kt create mode 100644 app/src/test/java/testhelper/coroutine/CoroutinesTestExtension.kt create mode 100644 app/src/test/java/testhelper/coroutine/TestDispatcherProvider.kt create mode 100644 app/src/test/java/testhelper/coroutine/TestExtensions.kt create mode 100644 app/src/test/java/testhelper/flow/FlowTest.kt create mode 100644 app/src/test/java/testhelper/livedata/InstantExecutorExtension.kt create mode 100644 app/src/test/java/testhelper/preferences/MockSharedPreferencesTest.kt create mode 100644 app/src/testShared/java/testhelpers/BaseTestInstrumentation.kt create mode 100644 app/src/testShared/java/testhelpers/IsAUnitTest.kt create mode 100644 app/src/testShared/java/testhelpers/logging/JUnitLogger.kt create mode 100644 app/src/testShared/java/testhelpers/preferences/MockFlowPreference.kt create mode 100644 app/src/testShared/java/testhelpers/preferences/MockSharedPreferences.kt create mode 100644 build.gradle create mode 100644 gradle.properties create mode 100644 gradle/wrapper/gradle-wrapper.jar create mode 100644 gradle/wrapper/gradle-wrapper.properties create mode 100755 gradlew create mode 100644 gradlew.bat create mode 100644 local.properties create mode 100644 settings.gradle diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..5f81826f --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +.idea +.gradle +build/ \ No newline at end of file diff --git a/README.md b/README.md index 96472c71..aff118d1 100644 --- a/README.md +++ b/README.md @@ -1 +1,37 @@ -# android-airpods-companion \ No newline at end of file +# Companion App for AirPods (CAP) + +A companion app that adds support for AirPod specific features to Android. + +Supported models: + +* AirPods Gen1 +* AirPods Gen2 +* AirPods Pro + +## Support the project + +* Buy the CAP Pro In-App purchase on [Google Play](https://play.google.com/store/apps/details?id=eu.darken.cap) +* [Buy me a coffee](https://www.buymeacoffee.com/tydarken) +* Help translate CAP [on Crowdin](https://crowdin.com/project/airpod-companion) + +## Download + +* [Google Play](https://play.google.com/store/apps/details?id=eu.darken.cap) +* [GitHub](https://github.com/d4rken/android-airpods-companion/releases/latest) + +## Get help + +* [Github Issues](https://github.com/d4rken/android-airpods-companion/issues) +* [Discord](https://discord.gg/vHubYPp) + +## Screenshots + +## License + +CAP's code is available under a GPL v3 license, this excludes: + +* CAP icons, logos, mascots and marketing materials. +* CAP animations and videos. +* CAP documentation. +* Google Play store screenshots. +* Google Play store texts & descriptions. \ No newline at end of file diff --git a/app/.gitignore b/app/.gitignore new file mode 100644 index 00000000..42afabfd --- /dev/null +++ b/app/.gitignore @@ -0,0 +1 @@ +/build \ No newline at end of file diff --git a/app/build.gradle b/app/build.gradle new file mode 100644 index 00000000..71f5651d --- /dev/null +++ b/app/build.gradle @@ -0,0 +1,230 @@ +plugins { + id 'com.android.application' + id 'kotlin-android' + id 'kotlin-kapt' + id 'kotlin-parcelize' + id 'androidx.navigation.safeargs.kotlin' + id 'com.bugsnag.android.gradle' + id 'dagger.hilt.android.plugin' +} + +def gitSha = 'git rev-parse --short HEAD'.execute([], project.rootDir).text.trim() +def buildTime = new Date().format("yyyy-MM-dd'T'HH:mm:ss'Z'", TimeZone.getTimeZone("GMT+1")) + +android { + def packageName = "eu.darken.cap" + + compileSdkVersion buildConfig.compileSdk + + defaultConfig { + applicationId "${packageName}" + + minSdkVersion buildConfig.minSdk + targetSdkVersion buildConfig.targetSdk + + versionCode buildConfig.version.code + versionName buildConfig.version.name + + testInstrumentationRunner "eu.darken.cap.HiltTestRunner" + + buildConfigField "String", "GITSHA", "\"${gitSha}\"" + buildConfigField "String", "BUILDTIME", "\"${buildTime}\"" + } + + signingConfigs { + release {} + } + def signingPropFile = new File(System.properties['user.home'], ".appconfig/${packageName}/signing.properties") + if (signingPropFile.canRead()) { + Properties signingProps = new Properties() + signingProps.load(new FileInputStream(signingPropFile)) + signingConfigs { + release { + storeFile new File(signingProps['release.storePath']) + keyAlias signingProps['release.keyAlias'] + storePassword signingProps['release.storePassword'] + keyPassword signingProps['release.keyPassword'] + } + } + } + + buildTypes { + def proguardRulesRelease = fileTree(dir: "../proguard", include: ["*.pro"]).asList().toArray() + debug { + ext.enableBugsnag = false + minifyEnabled false + shrinkResources false + proguardFiles getDefaultProguardFile('proguard-android-optimize.txt') + proguardFiles proguardRulesRelease + proguardFiles 'proguard-rules-debug.pro' + } + release { + signingConfig signingConfigs.release + lintOptions { + abortOnError true + fatal 'StopShip' + } + ext.enableBugsnag = true + minifyEnabled true + shrinkResources true + proguardFiles getDefaultProguardFile('proguard-android-optimize.txt') + proguardFiles proguardRulesRelease + } + applicationVariants.all { variant -> + if (variant.buildType.name == "debug") { + variant.mergedFlavor.resourceConfigurations.clear() + variant.mergedFlavor.resourceConfigurations.add("en") + variant.mergedFlavor.resourceConfigurations.add("de") + } else if (variant.buildType.name != "debug") { + variant.outputs.each { output -> + output.outputFileName = "${packageName}-v" + defaultConfig.versionName + "(" + defaultConfig.versionCode + ")-" + variant.buildType.name.toUpperCase() + "-" + gitSha + ".apk" + } + } + } + } + + compileOptions { + sourceCompatibility JavaVersion.VERSION_1_8 + targetCompatibility JavaVersion.VERSION_1_8 + } + + kotlinOptions { + jvmTarget = '1.8' + } + + buildFeatures { + viewBinding true + } + + tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all { + kotlinOptions { + jvmTarget = "1.8" + + freeCompilerArgs += [ + "-Xuse-experimental=kotlinx.coroutines.ExperimentalCoroutinesApi", + "-Xuse-experimental=kotlinx.coroutines.FlowPreview", + "-Xuse-experimental=kotlin.time.ExperimentalTime", + "-Xuse-experimental=kotlin.ExperimentalUnsignedTypes", + "-Xopt-in=kotlin.RequiresOptIn" + ] + } + } + + testOptions { + unitTests.all { + useJUnitPlatform() + } + unitTests { + includeAndroidResources = true + } + } + + sourceSets { + test { + java.srcDirs += "$projectDir/src/testShared/java" + } + androidTest { + java.srcDirs += "$projectDir/src/testShared/java" + androidTest.assets.srcDirs += files("$projectDir/schemas".toString()) + } + } +} + +dependencies { + // Kotlin + implementation "org.jetbrains.kotlin:kotlin-stdlib:${versions.kotlin.core}" + implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:${versions.kotlin.coroutines}" + implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:${versions.kotlin.coroutines}" + + testImplementation "org.jetbrains.kotlin:kotlin-reflect:${versions.kotlin.core}" + testImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:${versions.kotlin.coroutines}" + androidTestImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:${versions.kotlin.coroutines}") { + // conflicts with mockito due to direct inclusion of byte buddy + exclude group: "org.jetbrains.kotlinx", module: "kotlinx-coroutines-debug" + } + + // Debugging + implementation ('com.bugsnag:bugsnag-android:5.9.2') + implementation 'com.getkeepsafe.relinker:relinker:1.4.3' + + // DI + implementation "com.google.dagger:dagger:${versions.dagger.core}" + implementation "com.google.dagger:dagger-android:${versions.dagger.core}" + + kapt "com.google.dagger:dagger-compiler:${versions.dagger.core}" + kapt "com.google.dagger:dagger-android-processor:${versions.dagger.core}" + + implementation "com.google.dagger:hilt-android:${versions.dagger.core}" + kapt "com.google.dagger:hilt-android-compiler:${versions.dagger.core}" + + testImplementation "com.google.dagger:hilt-android-testing:${versions.dagger.core}" + kaptTest "com.google.dagger:hilt-android-compiler:${versions.dagger.core}" + + androidTestImplementation "com.google.dagger:hilt-android-testing:${versions.dagger.core}" + kaptAndroidTest "com.google.dagger:hilt-android-compiler:${versions.dagger.core}" + + kapt "androidx.hilt:hilt-compiler:1.0.0" + implementation 'androidx.hilt:hilt-common:1.0.0' + + // Support libs + implementation 'androidx.core:core-ktx:1.7.0' + implementation 'androidx.appcompat:appcompat:1.4.0' + implementation 'androidx.annotation:annotation:1.3.0' + + implementation 'androidx.activity:activity-ktx:1.4.0' + implementation 'androidx.fragment:fragment-ktx:1.4.0' + + implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0' + implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.4.0' + implementation 'androidx.lifecycle:lifecycle-viewmodel-savedstate:2.4.0' + implementation 'androidx.lifecycle:lifecycle-common-java8:2.4.0' + implementation 'androidx.lifecycle:lifecycle-process:2.4.0' + implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.4.0' + + implementation "androidx.navigation:navigation-fragment-ktx:2.3.5" + implementation "androidx.navigation:navigation-ui-ktx:2.3.5" + + def work_version = "2.7.1" + implementation "androidx.work:work-runtime:${work_version}" + testImplementation "androidx.work:work-testing:${work_version}" + implementation "androidx.work:work-runtime-ktx:${work_version}" + implementation 'androidx.hilt:hilt-work:1.0.0' + + // UI + implementation 'androidx.constraintlayout:constraintlayout:2.1.2' + implementation 'com.google.android.material:material:1.6.0-alpha01' + + // Testing + testImplementation 'junit:junit:4.13.2' + testImplementation "org.junit.vintage:junit-vintage-engine:5.7.1" + testImplementation "androidx.test:core-ktx:1.4.0" + + testImplementation "io.mockk:mockk:1.12.1" + androidTestImplementation "io.mockk:mockk-android:1.11.0" + + testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:5.7.1" + testImplementation "org.junit.jupiter:junit-jupiter-api:5.7.1" + testImplementation "org.junit.jupiter:junit-jupiter-params:5.7.1" + + androidTestImplementation "androidx.navigation:navigation-testing:2.3.5" + + testImplementation "io.kotest:kotest-runner-junit5:4.6.2" + testImplementation "io.kotest:kotest-assertions-core-jvm:4.6.2" + testImplementation "io.kotest:kotest-property-jvm:4.6.2" + androidTestImplementation "io.kotest:kotest-assertions-core-jvm:4.6.2" + androidTestImplementation "io.kotest:kotest-property-jvm:4.6.2" + + testImplementation 'android.arch.core:core-testing:1.1.1' + androidTestImplementation 'android.arch.core:core-testing:1.1.1' + debugImplementation 'androidx.test:core-ktx:1.4.0' + + androidTestImplementation 'androidx.test.ext:junit:1.1.3' + androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0' + + androidTestImplementation 'androidx.test:runner:1.4.0' + androidTestImplementation 'androidx.test:rules:1.4.0' + androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0' + androidTestImplementation 'androidx.test.espresso:espresso-contrib:3.4.0' + androidTestImplementation 'androidx.test.espresso:espresso-intents:3.4.0' + androidTestImplementation 'androidx.test.espresso.idling:idling-concurrent:3.4.0' +} \ No newline at end of file diff --git a/app/proguard-rules-debug.pro b/app/proguard-rules-debug.pro new file mode 100644 index 00000000..0674e774 --- /dev/null +++ b/app/proguard-rules-debug.pro @@ -0,0 +1 @@ +-dontobfuscate \ No newline at end of file diff --git a/app/proguard/proguard-rules.pro b/app/proguard/proguard-rules.pro new file mode 100644 index 00000000..481bb434 --- /dev/null +++ b/app/proguard/proguard-rules.pro @@ -0,0 +1,21 @@ +# Add project specific ProGuard rules here. +# You can control the set of applied configuration files using the +# proguardFiles setting in build.gradle. +# +# For more details, see +# http://developer.android.com/guide/developing/tools/proguard.html + +# If your project uses WebView with JS, uncomment the following +# and specify the fully qualified class name to the JavaScript interface +# class: +#-keepclassmembers class fqcn.of.javascript.interface.for.webview { +# public *; +#} + +# Uncomment this to preserve the line number information for +# debugging stack traces. +#-keepattributes SourceFile,LineNumberTable + +# If you keep the line number information, uncomment this to +# hide the original source file name. +#-renamesourcefileattribute SourceFile \ No newline at end of file diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml new file mode 100644 index 00000000..dfe72160 --- /dev/null +++ b/app/src/main/AndroidManifest.xml @@ -0,0 +1,57 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/App.kt b/app/src/main/java/eu/darken/cap/App.kt new file mode 100644 index 00000000..2e38a57f --- /dev/null +++ b/app/src/main/java/eu/darken/cap/App.kt @@ -0,0 +1,49 @@ +package eu.darken.cap + +import android.app.Application +import androidx.hilt.work.HiltWorkerFactory +import androidx.work.Configuration +import com.getkeepsafe.relinker.ReLinker +import dagger.hilt.android.HiltAndroidApp +import eu.darken.cap.bugreporting.BugReporter +import eu.darken.cap.common.coroutine.AppScope +import eu.darken.cap.common.debug.logging.* +import eu.darken.cap.monitor.core.worker.MonitorControl +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.launch +import javax.inject.Inject + +@HiltAndroidApp +open class App : Application(), Configuration.Provider { + + @Inject lateinit var workerFactory: HiltWorkerFactory + @Inject lateinit var bugReporter: BugReporter + @Inject lateinit var monitorControl: MonitorControl + @Inject @AppScope lateinit var appScope: CoroutineScope + + override fun onCreate() { + super.onCreate() + if (BuildConfig.DEBUG) Logging.install(LogCatLogger()) + + ReLinker + .log { message -> log(TAG) { "ReLinker: $message" } } + .loadLibrary(this, "bugsnag-plugin-android-anr") + + bugReporter.setup() + + log(TAG) { "onCreate() done! ${Exception().asLog()}" } + + appScope.launch { + monitorControl.startMonitor(forceStart = true) + } + } + + override fun getWorkManagerConfiguration(): Configuration = Configuration.Builder() + .setMinimumLoggingLevel(android.util.Log.VERBOSE) + .setWorkerFactory(workerFactory) + .build() + + companion object { + internal val TAG = logTag("CAP") + } +} diff --git a/app/src/main/java/eu/darken/cap/bugreporting/BugReportSettings.kt b/app/src/main/java/eu/darken/cap/bugreporting/BugReportSettings.kt new file mode 100644 index 00000000..357494ad --- /dev/null +++ b/app/src/main/java/eu/darken/cap/bugreporting/BugReportSettings.kt @@ -0,0 +1,20 @@ +package eu.darken.cap.bugreporting + +import android.content.Context +import dagger.hilt.android.qualifiers.ApplicationContext +import eu.darken.cap.common.preferences.createFlowPreference +import javax.inject.Inject +import javax.inject.Singleton + +@Singleton +class BugReportSettings @Inject constructor( + @ApplicationContext private val context: Context, +) { + + private val prefs by lazy { + context.getSharedPreferences("bugreport_settings", Context.MODE_PRIVATE) + } + + val isEnabled = prefs.createFlowPreference("bugreport.automatic.enabled", true) + +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/bugreporting/BugReporter.kt b/app/src/main/java/eu/darken/cap/bugreporting/BugReporter.kt new file mode 100644 index 00000000..e3046110 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/bugreporting/BugReporter.kt @@ -0,0 +1,57 @@ +package eu.darken.cap.bugreporting + +import android.content.Context +import com.bugsnag.android.Bugsnag +import com.bugsnag.android.Configuration +import dagger.hilt.android.qualifiers.ApplicationContext +import eu.darken.cap.common.InstallId +import eu.darken.cap.common.debug.bugsnag.BugsnagErrorHandler +import eu.darken.cap.common.debug.bugsnag.BugsnagLogger +import eu.darken.cap.common.debug.bugsnag.NOPBugsnagErrorHandler +import eu.darken.cap.common.debug.logging.Logging +import eu.darken.cap.common.debug.logging.log +import eu.darken.cap.common.debug.logging.logTag +import javax.inject.Inject +import javax.inject.Provider +import javax.inject.Singleton + +@Singleton +class BugReporter @Inject constructor( + @ApplicationContext private val context: Context, + private val bugReportSettings: BugReportSettings, + private val installId: InstallId, + private val bugsnagLogger: Provider, + private val bugsnagErrorHandler: Provider, + private val nopBugsnagErrorHandler: Provider, +) { + + fun setup() { + val isEnabled = bugReportSettings.isEnabled.value + log(TAG) { "setup(): isEnabled=$isEnabled" } + + try { + val bugsnagConfig = Configuration.load(context).apply { + if (bugReportSettings.isEnabled.value) { + Logging.install(bugsnagLogger.get()) + setUser(installId.id, null, null) + autoTrackSessions = true + addOnError(bugsnagErrorHandler.get()) + log(TAG) { "Bugsnag setup done!" } + } else { + autoTrackSessions = false + addOnError(nopBugsnagErrorHandler.get()) + log(TAG) { "Installing Bugsnag NOP error handler due to user opt-out!" } + } + } + + Bugsnag.start(context, bugsnagConfig) + Bugs.ready = true + } catch (e: IllegalStateException) { + log(TAG) { "Bugsnag API Key not configured." } + } + } + + companion object { + private val TAG = logTag("BugReporter") + } +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/bugreporting/Bugs.kt b/app/src/main/java/eu/darken/cap/bugreporting/Bugs.kt new file mode 100644 index 00000000..51c43ba6 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/bugreporting/Bugs.kt @@ -0,0 +1,21 @@ +package eu.darken.cap.bugreporting + +import com.bugsnag.android.Bugsnag +import eu.darken.cap.common.debug.logging.Logging.Priority.VERBOSE +import eu.darken.cap.common.debug.logging.Logging.Priority.WARN +import eu.darken.cap.common.debug.logging.log +import eu.darken.cap.common.debug.logging.logTag + +object Bugs { + var ready = false + fun report(exception: Exception) { + log(TAG, VERBOSE) { "Reporting $exception" } + if (!ready) { + log(TAG, WARN) { "Bug tracking not initialized yet." } + return + } + Bugsnag.notify(exception) + } + + private val TAG = logTag("Bugs") +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/BuildConfigWrap.kt b/app/src/main/java/eu/darken/cap/common/BuildConfigWrap.kt new file mode 100644 index 00000000..697afaf7 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/BuildConfigWrap.kt @@ -0,0 +1,16 @@ +package eu.darken.cap.common + +import eu.darken.cap.BuildConfig + + +// Can't be const because that prevents them from being mocked in tests +@Suppress("MayBeConstant") +object BuildConfigWrap { + val APPLICATION_ID = BuildConfig.APPLICATION_ID + val DEBUG: Boolean = BuildConfig.DEBUG + val BUILD_TYPE: String = BuildConfig.BUILD_TYPE + + val VERSION_CODE: Long = BuildConfig.VERSION_CODE.toLong() + val VERSION_NAME: String = BuildConfig.VERSION_NAME + val GIT_SHA: String = BuildConfig.GITSHA +} diff --git a/app/src/main/java/eu/darken/cap/common/BuildWrap.kt b/app/src/main/java/eu/darken/cap/common/BuildWrap.kt new file mode 100644 index 00000000..f0051a7a --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/BuildWrap.kt @@ -0,0 +1,16 @@ +package eu.darken.cap.common + +import android.os.Build + +// Can't be const because that prevents them from being mocked in tests +@Suppress("MayBeConstant") +object BuildWrap { + + val VERSION = VersionWrap + + object VersionWrap { + val SDK_INT = Build.VERSION.SDK_INT + } +} + +fun hasApiLevel(level: Int): Boolean = BuildWrap.VERSION.SDK_INT >= level diff --git a/app/src/main/java/eu/darken/cap/common/ByteArrayExtensions.kt b/app/src/main/java/eu/darken/cap/common/ByteArrayExtensions.kt new file mode 100644 index 00000000..bce75756 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/ByteArrayExtensions.kt @@ -0,0 +1,14 @@ +package eu.darken.cap.common + +import java.util.* + +fun Byte.toHex(): String = String.format("%02X", this) +fun UByte.toHex(): String = this.toByte().toHex() + +val Byte.upperNibble get() = (this.toInt() shr 4 and 0b1111).toByte() +val Byte.lowerNibble get() = (this.toInt() and 0b1111).toByte() +val UByte.upperNibble get() = (this.toInt() shr 4 and 0b1111).toUByte() +val UByte.lowerNibble get() = (this.toInt() and 0b1111).toUByte() + +fun Byte.isBitSet(pos: Int): Boolean = BitSet.valueOf(arrayOf(this).toByteArray()).get(pos) +fun UByte.isBitSet(pos: Int): Boolean = this.toByte().isBitSet(pos) \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/ContextExtensions.kt b/app/src/main/java/eu/darken/cap/common/ContextExtensions.kt new file mode 100644 index 00000000..6c045ed8 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/ContextExtensions.kt @@ -0,0 +1,40 @@ +package eu.darken.cap.common + +import android.annotation.SuppressLint +import android.content.ComponentName +import android.content.Context +import android.content.Intent +import android.content.res.TypedArray +import androidx.annotation.AttrRes +import androidx.annotation.ColorInt +import androidx.annotation.ColorRes +import androidx.core.content.ContextCompat +import androidx.fragment.app.Fragment + + +@ColorInt +fun Context.getColorForAttr(@AttrRes attrId: Int): Int { + var typedArray: TypedArray? = null + try { + typedArray = this.theme.obtainStyledAttributes(intArrayOf(attrId)) + return typedArray.getColor(0, 0) + } finally { + typedArray?.recycle() + } +} + +@ColorInt +fun Fragment.getColorForAttr(@AttrRes attrId: Int): Int = requireContext().getColorForAttr(attrId) + +@ColorInt +fun Context.getCompatColor(@ColorRes attrId: Int): Int { + return ContextCompat.getColor(this, attrId) +} + +@ColorInt +fun Fragment.getCompatColor(@ColorRes attrId: Int): Int = requireContext().getCompatColor(attrId) + +@SuppressLint("NewApi") +fun Context.startServiceCompat(intent: Intent): ComponentName? { + return if (hasApiLevel(26)) startForegroundService(intent) else startService(intent) +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/InstallId.kt b/app/src/main/java/eu/darken/cap/common/InstallId.kt new file mode 100644 index 00000000..90796ccf --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/InstallId.kt @@ -0,0 +1,42 @@ +package eu.darken.cap.common + +import android.content.Context +import dagger.hilt.android.qualifiers.ApplicationContext +import eu.darken.cap.common.debug.logging.log +import eu.darken.cap.common.debug.logging.logTag +import java.io.File +import java.util.* +import java.util.regex.Pattern +import javax.inject.Inject +import javax.inject.Singleton + +@Singleton +class InstallId @Inject constructor( + @ApplicationContext private val context: Context, +) { + private val installIDFile = File(context.filesDir, INSTALL_ID_FILENAME) + val id: String by lazy { + val existing = if (installIDFile.exists()) { + installIDFile.readText().also { + if (!UUID_PATTERN.matcher(it).matches()) throw IllegalStateException("Invalid InstallID: $it") + } + } else { + null + } + + return@lazy existing ?: UUID.randomUUID().toString().also { + log(TAG) { "New install ID created: $it" } + installIDFile.writeText(it) + } + } + + companion object { + private val TAG: String = logTag("InstallID") + private val UUID_PATTERN = Pattern.compile( + "^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$" + ) + + private const val INSTALL_ID_FILENAME = "installid" + } +} + diff --git a/app/src/main/java/eu/darken/cap/common/LiveDataExtensions.kt b/app/src/main/java/eu/darken/cap/common/LiveDataExtensions.kt new file mode 100644 index 00000000..7d4aa746 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/LiveDataExtensions.kt @@ -0,0 +1,23 @@ +package eu.darken.cap.common + +import androidx.appcompat.app.AppCompatActivity +import androidx.fragment.app.Fragment +import androidx.lifecycle.LiveData +import androidx.viewbinding.ViewBinding + + +fun LiveData.observe2(fragment: Fragment, callback: (T) -> Unit) { + observe(fragment.viewLifecycleOwner) { callback.invoke(it) } +} + +inline fun LiveData.observe2( + fragment: Fragment, + ui: VB, + crossinline callback: VB.(T) -> Unit +) { + observe(fragment.viewLifecycleOwner) { callback.invoke(ui, it) } +} + +fun LiveData.observe2(activity: AppCompatActivity, callback: (T) -> Unit) { + observe(activity) { callback.invoke(it) } +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/bluetooth/BleScanner.kt b/app/src/main/java/eu/darken/cap/common/bluetooth/BleScanner.kt new file mode 100644 index 00000000..e6a9e650 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/bluetooth/BleScanner.kt @@ -0,0 +1,68 @@ +package eu.darken.cap.common.bluetooth + +import android.bluetooth.BluetoothManager +import android.bluetooth.le.ScanCallback +import android.bluetooth.le.ScanFilter +import android.bluetooth.le.ScanResult +import android.bluetooth.le.ScanSettings +import android.content.Context +import dagger.hilt.android.qualifiers.ApplicationContext +import eu.darken.cap.common.debug.logging.Logging.Priority.* +import eu.darken.cap.common.debug.logging.log +import eu.darken.cap.common.debug.logging.logTag +import eu.darken.cap.pods.core.airpods.ProximityPairing +import kotlinx.coroutines.channels.awaitClose +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.callbackFlow +import javax.inject.Inject +import javax.inject.Singleton + +@Singleton +class BleScanner @Inject constructor( + @ApplicationContext private val context: Context, + private val bluetoothManager: BluetoothManager, +) { + // TODO check Bluetooth available + // TODO check Bluetooth enabled + fun scan( + filter: Set = ProximityPairing.getBleScanFilter(), + mode: Int = ScanSettings.SCAN_MODE_LOW_LATENCY, + delay: Long = 1, + ): Flow> = callbackFlow { + val scanner = bluetoothManager.adapter.bluetoothLeScanner + + val callback = object : ScanCallback() { + override fun onScanResult(callbackType: Int, result: ScanResult) { + log(TAG, VERBOSE) { "onScanResult(callbackType=$callbackType, result=$result)" } + trySend(listOf(result)) + } + + override fun onBatchScanResults(results: MutableList) { + log(TAG, VERBOSE) { "onBatchScanResults(results=$results)" } + trySend(results) + } + + override fun onScanFailed(errorCode: Int) { + log(TAG, WARN) { "onScanFailed(errorCode=$errorCode)" } + } + } + + val settings = ScanSettings.Builder().apply { + setScanMode(mode) + setReportDelay(delay) + }.build() + + scanner.startScan(filter.toList(), settings, callback) + log(TAG, VERBOSE) { "BleScanner started (filter=$filter, settings=$settings)" } + + awaitClose { + log(TAG, INFO) { "BleScanner stopped" } + scanner.stopScan(callback) + } + } + + + companion object { + private val TAG = logTag("Bluetooth", "BleScanner") + } +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/bluetooth/BluetoothDevice2.kt b/app/src/main/java/eu/darken/cap/common/bluetooth/BluetoothDevice2.kt new file mode 100644 index 00000000..2714742b --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/bluetooth/BluetoothDevice2.kt @@ -0,0 +1,14 @@ +package eu.darken.cap.common.bluetooth + +import android.bluetooth.BluetoothDevice +import android.os.ParcelUuid +import android.os.Parcelable +import kotlinx.parcelize.Parcelize + +@Parcelize +data class BluetoothDevice2( + private val bluetoothDevice: BluetoothDevice +) : Parcelable { + + fun hasFeature(uuid: ParcelUuid): Boolean = bluetoothDevice.hasFeature(uuid) +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/bluetooth/BluetoothDeviceExtensions.kt b/app/src/main/java/eu/darken/cap/common/bluetooth/BluetoothDeviceExtensions.kt new file mode 100644 index 00000000..fbb772e8 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/bluetooth/BluetoothDeviceExtensions.kt @@ -0,0 +1,8 @@ +package eu.darken.cap.common.bluetooth + +import android.bluetooth.BluetoothDevice +import android.os.ParcelUuid + +fun BluetoothDevice.hasFeature(uuid: ParcelUuid): Boolean { + return uuids?.contains(uuid) ?: false +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/bluetooth/BluetoothManager2.kt b/app/src/main/java/eu/darken/cap/common/bluetooth/BluetoothManager2.kt new file mode 100644 index 00000000..036c1ddd --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/bluetooth/BluetoothManager2.kt @@ -0,0 +1,145 @@ +package eu.darken.cap.common.bluetooth + +import android.bluetooth.BluetoothAdapter +import android.bluetooth.BluetoothDevice +import android.bluetooth.BluetoothManager +import android.bluetooth.BluetoothProfile +import android.content.BroadcastReceiver +import android.content.Context +import android.content.Intent +import android.content.IntentFilter +import android.os.Handler +import android.os.HandlerThread +import dagger.hilt.android.qualifiers.ApplicationContext +import eu.darken.cap.common.coroutine.DispatcherProvider +import eu.darken.cap.common.debug.logging.Logging.Priority.* +import eu.darken.cap.common.debug.logging.log +import eu.darken.cap.common.debug.logging.logTag +import kotlinx.coroutines.channels.awaitClose +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.callbackFlow +import kotlinx.coroutines.launch +import kotlinx.coroutines.suspendCancellableCoroutine +import kotlinx.coroutines.withContext +import java.io.IOException +import java.util.concurrent.atomic.AtomicBoolean +import javax.inject.Inject +import javax.inject.Singleton +import kotlin.coroutines.resume + +@Singleton +class BluetoothManager2 @Inject constructor( + private val manager: BluetoothManager, + @ApplicationContext private val context: Context, + private val dispatcherProvider: DispatcherProvider, +) { + + val isBluetoothEnabled: Flow = callbackFlow { + send(manager.adapter?.isEnabled ?: false) + + val receiver = object : BroadcastReceiver() { + override fun onReceive(context: Context, intent: Intent) { + if (BluetoothAdapter.ACTION_STATE_CHANGED != intent.action) { + log(TAG) { "Unknown BluetoothAdapter action: $intent" } + return + } + + val value = when (intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, -1)) { + BluetoothAdapter.STATE_OFF -> false + BluetoothAdapter.STATE_ON -> true + else -> false + } + + trySend(value) + } + } + context.registerReceiver(receiver, IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED)) + awaitClose { context.unregisterReceiver(receiver) } + } + + suspend fun getBluetoothProfile( + profile: Int = BluetoothProfile.HEADSET + ): BluetoothProfile2 = withContext(dispatcherProvider.IO) { + log(TAG) { "getBluetoothProfile(profile=$profile)" } + + suspendCancellableCoroutine { + val connectionState = AtomicBoolean(false) + manager.adapter.getProfileProxy(context, object : BluetoothProfile.ServiceListener { + override fun onServiceConnected(profile: Int, proxy: BluetoothProfile) { + log(TAG, VERBOSE) { "onServiceConnected(profile=$profile, proxy=$proxy)" } + connectionState.set(true) + BluetoothProfile2( + profileType = profile, + profileProxy = proxy, + isConnectedAtomic = connectionState + ).run { it.resume(this) } + } + + override fun onServiceDisconnected(profile: Int) { + log(TAG, WARN) { "onServiceDisconnected(profile=$profile" } + connectionState.set(false) + it.cancel(IOException("BluetoothProfile service disconnected (profile=$profile)")) + } + + }, profile) + } + } + + fun connectedDevices(profile: Int = BluetoothProfile.HEADSET): Flow> = callbackFlow { + log(TAG) { "connectedDevices(profile=$profile) starting" } + trySend(getBluetoothProfile(profile).connectedDevices) + + val filter = IntentFilter().apply { + addAction(BluetoothDevice.ACTION_ACL_CONNECTED) + addAction(BluetoothDevice.ACTION_ACL_DISCONNECTED) + } + + val handlerThread = HandlerThread("BluetoothEventReceiver").apply { + start() + } + val handler = Handler(handlerThread.looper) + + val receiver: BroadcastReceiver = object : BroadcastReceiver() { + override fun onReceive(context: Context, intent: Intent) { + log(TAG, VERBOSE) { "Bluetooth event (intent=$intent, extras=${intent.extras})" } + val action = intent.action + if (action == null) { + log(TAG, ERROR) { "Bluetooth event without action, how did we get this?" } + return + } + val device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE)?.let { + BluetoothDevice2(it) + } + if (device == null) { + log(TAG, ERROR) { "Connection event is missing EXTRA_DEVICE: ${intent.extras}" } + return + } + + this@callbackFlow.launch { + val currentDevices = getBluetoothProfile(profile).connectedDevices + + when (action) { + BluetoothDevice.ACTION_ACL_CONNECTED -> { + log(TAG) { "Adding $device to current devices $currentDevices" } + trySend(currentDevices.plus(device)) + } + BluetoothDevice.ACTION_ACL_DISCONNECTED -> { + log(TAG) { "Removing $device from current devices $currentDevices" } + trySend(currentDevices.minus(device)) + } + } + } + } + } + context.registerReceiver(receiver, filter, null, handler) + + awaitClose { + log(TAG, VERBOSE) { "connectedDevices(profile=$profile) closed." } + context.unregisterReceiver(receiver) + } + } + + companion object { + private val TAG = logTag("Bluetooth", "Manager2") + } +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/bluetooth/BluetoothProfile2.kt b/app/src/main/java/eu/darken/cap/common/bluetooth/BluetoothProfile2.kt new file mode 100644 index 00000000..7e9af879 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/bluetooth/BluetoothProfile2.kt @@ -0,0 +1,23 @@ +package eu.darken.cap.common.bluetooth + +import android.bluetooth.BluetoothProfile +import java.util.concurrent.atomic.AtomicBoolean + +data class BluetoothProfile2( + private val profileType: Int, + private val profileProxy: BluetoothProfile, + private val isConnectedAtomic: AtomicBoolean, +) { + + val profile: BluetoothProfile + get() { + if (!isConnected) throw IllegalStateException("Proxy is not connected") + return profileProxy + } + + val connectedDevices: Set + get() = profile.connectedDevices.map { BluetoothDevice2(it) }.toSet() + + val isConnected: Boolean + get() = isConnectedAtomic.get() +} diff --git a/app/src/main/java/eu/darken/cap/common/collections/MapExtensions.kt b/app/src/main/java/eu/darken/cap/common/collections/MapExtensions.kt new file mode 100644 index 00000000..0cd0f1c6 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/collections/MapExtensions.kt @@ -0,0 +1,5 @@ +package eu.darken.cap.common.collections + +inline fun Map.mutate(block: MutableMap.() -> Unit): Map { + return toMutableMap().apply(block).toMap() +} diff --git a/app/src/main/java/eu/darken/cap/common/coroutine/AppCoroutineScope.kt b/app/src/main/java/eu/darken/cap/common/coroutine/AppCoroutineScope.kt new file mode 100644 index 00000000..19a818a3 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/coroutine/AppCoroutineScope.kt @@ -0,0 +1,19 @@ +package eu.darken.cap.common.coroutine + +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.SupervisorJob +import javax.inject.Inject +import javax.inject.Qualifier +import javax.inject.Singleton +import kotlin.coroutines.CoroutineContext + +@Singleton +class AppCoroutineScope @Inject constructor() : CoroutineScope { + override val coroutineContext: CoroutineContext = SupervisorJob() + Dispatchers.Default +} + +@Qualifier +@MustBeDocumented +@Retention(AnnotationRetention.RUNTIME) +annotation class AppScope diff --git a/app/src/main/java/eu/darken/cap/common/coroutine/CoroutineModule.kt b/app/src/main/java/eu/darken/cap/common/coroutine/CoroutineModule.kt new file mode 100644 index 00000000..e33b54db --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/coroutine/CoroutineModule.kt @@ -0,0 +1,19 @@ +package eu.darken.cap.common.coroutine + +import dagger.Binds +import dagger.Module +import dagger.hilt.InstallIn +import dagger.hilt.components.SingletonComponent +import kotlinx.coroutines.CoroutineScope + +@InstallIn(SingletonComponent::class) +@Module +abstract class CoroutineModule { + + @Binds + abstract fun dispatcherProvider(defaultProvider: DefaultDispatcherProvider): DispatcherProvider + + @Binds + @AppScope + abstract fun appscope(appCoroutineScope: AppCoroutineScope): CoroutineScope +} diff --git a/app/src/main/java/eu/darken/cap/common/coroutine/DefaultDispatcherProvider.kt b/app/src/main/java/eu/darken/cap/common/coroutine/DefaultDispatcherProvider.kt new file mode 100644 index 00000000..48f0a068 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/coroutine/DefaultDispatcherProvider.kt @@ -0,0 +1,7 @@ +package eu.darken.cap.common.coroutine + +import javax.inject.Inject +import javax.inject.Singleton + +@Singleton +class DefaultDispatcherProvider @Inject constructor() : DispatcherProvider diff --git a/app/src/main/java/eu/darken/cap/common/coroutine/DispatcherProvider.kt b/app/src/main/java/eu/darken/cap/common/coroutine/DispatcherProvider.kt new file mode 100644 index 00000000..6c0c4884 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/coroutine/DispatcherProvider.kt @@ -0,0 +1,21 @@ +package eu.darken.cap.common.coroutine + +import kotlinx.coroutines.Dispatchers +import kotlin.coroutines.CoroutineContext + +// Need this to improve testing +// Can currently only replace the main-thread dispatcher. +// https://github.com/Kotlin/kotlinx.coroutines/issues/1365 +@Suppress("PropertyName", "VariableNaming") +interface DispatcherProvider { + val Default: CoroutineContext + get() = Dispatchers.Default + val Main: CoroutineContext + get() = Dispatchers.Main + val MainImmediate: CoroutineContext + get() = Dispatchers.Main.immediate + val Unconfined: CoroutineContext + get() = Dispatchers.Unconfined + val IO: CoroutineContext + get() = Dispatchers.IO +} diff --git a/app/src/main/java/eu/darken/cap/common/dagger/AndroidModule.kt b/app/src/main/java/eu/darken/cap/common/dagger/AndroidModule.kt new file mode 100644 index 00000000..f85cc164 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/dagger/AndroidModule.kt @@ -0,0 +1,36 @@ +package eu.darken.cap.common.dagger + +import android.app.Application +import android.app.NotificationManager +import android.bluetooth.BluetoothManager +import android.content.Context +import androidx.work.WorkManager +import dagger.Module +import dagger.Provides +import dagger.hilt.InstallIn +import dagger.hilt.components.SingletonComponent +import javax.inject.Singleton + +@InstallIn(SingletonComponent::class) +@Module +class AndroidModule { + + @Provides + @Singleton + fun context(app: Application): Context = app.applicationContext + + @Provides + @Singleton + fun notificationManager(context: Context): NotificationManager = + context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager + + @Provides + @Singleton + fun bluetoothManager(context: Context): BluetoothManager = + context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager + + @Provides + @Singleton + fun workerManager(context: Context): WorkManager = + WorkManager.getInstance(context) +} diff --git a/app/src/main/java/eu/darken/cap/common/debug/bugsnag/BugsnagErrorHandler.kt b/app/src/main/java/eu/darken/cap/common/debug/bugsnag/BugsnagErrorHandler.kt new file mode 100644 index 00000000..66f6996a --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/debug/bugsnag/BugsnagErrorHandler.kt @@ -0,0 +1,56 @@ +package eu.darken.cap.common.debug.bugsnag + +import android.annotation.SuppressLint +import android.content.Context +import android.content.pm.PackageManager +import com.bugsnag.android.Event +import com.bugsnag.android.OnErrorCallback +import dagger.hilt.android.qualifiers.ApplicationContext +import eu.darken.cap.BuildConfig +import eu.darken.cap.common.debug.logging.Logging.Priority.WARN +import eu.darken.cap.common.debug.logging.asLog +import eu.darken.cap.common.debug.logging.log +import javax.inject.Inject +import javax.inject.Singleton + +@Singleton +class BugsnagErrorHandler @Inject constructor( + @ApplicationContext private val context: Context, + private val bugsnagLogger: BugsnagLogger, +) : OnErrorCallback { + + override fun onError(event: Event): Boolean { + bugsnagLogger.injectLog(event) + + TAB_APP.also { tab -> + event.addMetadata(tab, "gitSha", BuildConfig.GITSHA) + event.addMetadata(tab, "buildTime", BuildConfig.BUILDTIME) + + context.tryFormattedSignature()?.let { event.addMetadata(tab, "signatures", it) } + } + + return !BuildConfig.DEBUG + } + + companion object { + private const val TAB_APP = "app" + + @Suppress("DEPRECATION") + @SuppressLint("PackageManagerGetSignatures") + fun Context.tryFormattedSignature(): String? = try { + packageManager.getPackageInfo(packageName, PackageManager.GET_SIGNATURES).signatures?.let { sigs -> + val sb = StringBuilder("[") + for (i in sigs.indices) { + sb.append(sigs[i].hashCode()) + if (i + 1 != sigs.size) sb.append(", ") + } + sb.append("]") + sb.toString() + } + } catch (e: Exception) { + log(WARN) { e.asLog() } + null + } + } + +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/debug/bugsnag/BugsnagLogger.kt b/app/src/main/java/eu/darken/cap/common/debug/bugsnag/BugsnagLogger.kt new file mode 100644 index 00000000..4a36e4d1 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/debug/bugsnag/BugsnagLogger.kt @@ -0,0 +1,47 @@ +package eu.darken.cap.common.debug.bugsnag + +import com.bugsnag.android.Event +import eu.darken.cap.common.debug.logging.Logging +import eu.darken.cap.common.debug.logging.asLog +import java.lang.String.format +import java.util.* +import javax.inject.Inject +import javax.inject.Singleton + +@Singleton +class BugsnagLogger @Inject constructor() : Logging.Logger { + + // Adding one to the initial size accounts for the add before remove. + private val buffer: Deque = ArrayDeque(BUFFER_SIZE + 1) + + override fun log(priority: Logging.Priority, tag: String, message: String, metaData: Map?) { + val line = "${System.currentTimeMillis()} ${priority.toLabel()}/$tag: $message" + synchronized(buffer) { + buffer.addLast(line) + if (buffer.size > BUFFER_SIZE) { + buffer.removeFirst() + } + } + } + + fun injectLog(event: Event) { + synchronized(buffer) { + var i = 100 + buffer.forEach { event.addMetadata("Log", format(Locale.ROOT, "%03d", i++), it) } + event.addMetadata("Log", format(Locale.ROOT, "%03d", i), event.originalError?.asLog()) + } + } + + companion object { + private const val BUFFER_SIZE = 200 + + private fun Logging.Priority.toLabel(): String = when (this) { + Logging.Priority.VERBOSE -> "V" + Logging.Priority.DEBUG -> "D" + Logging.Priority.INFO -> "I" + Logging.Priority.WARN -> "W" + Logging.Priority.ERROR -> "E" + Logging.Priority.ASSERT -> "WTF" + } + } +} diff --git a/app/src/main/java/eu/darken/cap/common/debug/bugsnag/NOPBugsnagErrorHandler.kt b/app/src/main/java/eu/darken/cap/common/debug/bugsnag/NOPBugsnagErrorHandler.kt new file mode 100644 index 00000000..5366b43d --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/debug/bugsnag/NOPBugsnagErrorHandler.kt @@ -0,0 +1,19 @@ +package eu.darken.cap.common.debug.bugsnag + +import com.bugsnag.android.Event +import com.bugsnag.android.OnErrorCallback +import eu.darken.cap.common.debug.logging.Logging.Priority.WARN +import eu.darken.cap.common.debug.logging.asLog +import eu.darken.cap.common.debug.logging.log +import javax.inject.Inject +import javax.inject.Singleton + +@Singleton +class NOPBugsnagErrorHandler @Inject constructor() : OnErrorCallback { + + override fun onError(event: Event): Boolean { + log(WARN) { "Error, but skipping bugsnag due to user opt-out: ${event.originalError?.asLog()}" } + return false + } + +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/debug/logging/LogCatLogger.kt b/app/src/main/java/eu/darken/cap/common/debug/logging/LogCatLogger.kt new file mode 100644 index 00000000..696a1f27 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/debug/logging/LogCatLogger.kt @@ -0,0 +1,49 @@ +package eu.darken.cap.common.debug.logging + +import android.os.Build +import android.util.Log +import kotlin.math.min + +class LogCatLogger : Logging.Logger { + + override fun isLoggable(priority: Logging.Priority): Boolean = true + + override fun log(priority: Logging.Priority, tag: String, message: String, metaData: Map?) { + + val trimmedTag = if (tag.length <= MAX_TAG_LENGTH || Build.VERSION.SDK_INT >= 26) { + tag + } else { + tag.substring(0, MAX_TAG_LENGTH) + } + + if (message.length < MAX_LOG_LENGTH) { + writeToLogcat(priority.intValue, trimmedTag, message) + return + } + + // Split by line, then ensure each line can fit into Log's maximum length. + var i = 0 + val length = message.length + while (i < length) { + var newline = message.indexOf('\n', i) + newline = if (newline != -1) newline else length + do { + val end = min(newline, i + MAX_LOG_LENGTH) + val part = message.substring(i, end) + writeToLogcat(priority.intValue, trimmedTag, part) + i = end + } while (i < newline) + i++ + } + } + + private fun writeToLogcat(priority: Int, tag: String, part: String) = when (priority) { + Log.ASSERT -> Log.wtf(tag, part) + else -> Log.println(priority, tag, part) + } + + companion object { + private const val MAX_LOG_LENGTH = 4000 + private const val MAX_TAG_LENGTH = 23 + } +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/debug/logging/LogExtensions.kt b/app/src/main/java/eu/darken/cap/common/debug/logging/LogExtensions.kt new file mode 100644 index 00000000..cf594547 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/debug/logging/LogExtensions.kt @@ -0,0 +1,10 @@ +package eu.darken.cap.common.debug.logging + +fun logTag(vararg tags: String): String { + val sb = StringBuilder("CAP:") + for (i in tags.indices) { + sb.append(tags[i]) + if (i < tags.size - 1) sb.append(":") + } + return sb.toString() +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/debug/logging/Logging.kt b/app/src/main/java/eu/darken/cap/common/debug/logging/Logging.kt new file mode 100644 index 00000000..e861ea42 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/debug/logging/Logging.kt @@ -0,0 +1,132 @@ +package eu.darken.cap.common.debug.logging + +import java.io.PrintWriter +import java.io.StringWriter + +/** + * Inspired by + * https://github.com/PaulWoitaschek/Slimber + * https://github.com/square/logcat + * https://github.com/JakeWharton/timber + */ + +object Logging { + enum class Priority( + val intValue: Int, + val shortLabel: String + ) { + VERBOSE(2, "V"), + DEBUG(3, "D"), + INFO(4, "I"), + WARN(5, "W"), + ERROR(6, "E"), + ASSERT(7, "WTF"); + } + + interface Logger { + fun isLoggable(priority: Priority): Boolean = true + + fun log( + priority: Priority, + tag: String, + message: String, + metaData: Map? + ) + } + + private val internalLoggers = mutableListOf() + + val loggers: List + get() = synchronized(internalLoggers) { internalLoggers.toList() } + + val hasReceivers: Boolean + get() = synchronized(internalLoggers) { + internalLoggers.isNotEmpty() + } + + fun install(logger: Logger) { + synchronized(internalLoggers) { internalLoggers.add(logger) } + log { "Was installed $logger" } + } + + fun remove(logger: Logger) { + log { "Removing: $logger" } + synchronized(internalLoggers) { internalLoggers.remove(logger) } + } + + fun logInternal( + tag: String, + priority: Priority, + metaData: Map?, + message: String + ) { + val snapshot = synchronized(internalLoggers) { internalLoggers.toList() } + snapshot + .filter { it.isLoggable(priority) } + .forEach { + it.log( + priority = priority, + tag = tag, + metaData = metaData, + message = message + ) + } + } + + fun clearAll() { + log { "Clearing all loggers" } + synchronized(internalLoggers) { internalLoggers.clear() } + } +} + +inline fun Any.log( + priority: Logging.Priority = Logging.Priority.DEBUG, + metaData: Map? = null, + message: () -> String, +) { + if (Logging.hasReceivers) { + Logging.logInternal( + tag = "CAP:${logTagViaCallSite()}", + priority = priority, + metaData = metaData, + message = message(), + ) + } +} + +inline fun log( + tag: String, + priority: Logging.Priority = Logging.Priority.DEBUG, + metaData: Map? = null, + message: () -> String, +) { + if (Logging.hasReceivers) { + Logging.logInternal( + tag = tag, + priority = priority, + metaData = metaData, + message = message(), + ) + } +} + +fun Throwable.asLog(): String { + val stringWriter = StringWriter(256) + val printWriter = PrintWriter(stringWriter, false) + printStackTrace(printWriter) + printWriter.flush() + return stringWriter.toString() +} + +@PublishedApi +internal fun Any.logTagViaCallSite(): String { + val javaClass = this::class.java + val fullClassName = javaClass.name + val outerClassName = fullClassName.substringBefore('$') + val simplerOuterClassName = outerClassName.substringAfterLast('.') + return if (simplerOuterClassName.isEmpty()) { + fullClassName + } else { + simplerOuterClassName.removeSuffix("Kt") + } +} diff --git a/app/src/main/java/eu/darken/cap/common/error/ErrorDialog.kt b/app/src/main/java/eu/darken/cap/common/error/ErrorDialog.kt new file mode 100644 index 00000000..0301aae3 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/error/ErrorDialog.kt @@ -0,0 +1,18 @@ +package eu.darken.cap.common.error + +import android.content.Context +import com.google.android.material.dialog.MaterialAlertDialogBuilder + +fun Throwable.asErrorDialogBuilder( + context: Context +) = MaterialAlertDialogBuilder(context).apply { + val error = this@asErrorDialogBuilder + val localizedError = error.localized(context) + + setTitle(localizedError.label) + setMessage(localizedError.description) + + setPositiveButton(android.R.string.ok) { _, _ -> + + } +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/error/ErrorEventSource.kt b/app/src/main/java/eu/darken/cap/common/error/ErrorEventSource.kt new file mode 100644 index 00000000..3dedc6ae --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/error/ErrorEventSource.kt @@ -0,0 +1,7 @@ +package eu.darken.cap.common.error + +import eu.darken.cap.common.livedata.SingleLiveEvent + +interface ErrorEventSource { + val errorEvents: SingleLiveEvent +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/error/LocalizedError.kt b/app/src/main/java/eu/darken/cap/common/error/LocalizedError.kt new file mode 100644 index 00000000..2b66ef82 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/error/LocalizedError.kt @@ -0,0 +1,36 @@ +package eu.darken.cap.common.error + +import android.content.Context +import eu.darken.cap.R + +interface HasLocalizedError { + fun getLocalizedError(context: Context): LocalizedError +} + +data class LocalizedError( + val throwable: Throwable, + val label: String, + val description: String +) { + fun asText() = "$label:\n$description" +} + +fun Throwable.localized(c: Context): LocalizedError = when { + this is HasLocalizedError -> this.getLocalizedError(c) + localizedMessage != null -> LocalizedError( + throwable = this, + label = "${c.getString(R.string.general_error_label)}: ${this::class.simpleName!!}", + description = localizedMessage ?: getStackTracePeek() + ) + else -> LocalizedError( + throwable = this, + label = "${c.getString(R.string.general_error_label)}: ${this::class.simpleName!!}", + description = getStackTracePeek() + ) +} + +private fun Throwable.getStackTracePeek() = this.stackTraceToString() + .lines() + .filterIndexed { index, _ -> index > 1 } + .take(3) + .joinToString("\n") \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/error/ThrowableExtensions.kt b/app/src/main/java/eu/darken/cap/common/error/ThrowableExtensions.kt new file mode 100644 index 00000000..21f9662a --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/error/ThrowableExtensions.kt @@ -0,0 +1,42 @@ +package eu.darken.cap.common.error + +import java.io.PrintWriter +import java.io.StringWriter +import java.lang.reflect.InvocationTargetException +import kotlin.reflect.KClass + +val Throwable.causes: Sequence + get() = sequence { + var subCause = cause + while (subCause != null) { + yield(subCause) + subCause = subCause.cause + } + } + +fun Throwable.getRootCause(): Throwable { + var error = this + while (error.cause != null) { + error = error.cause!! + } + if (error is InvocationTargetException) { + error = error.targetException + } + return error +} + +fun Throwable.hasCause(exceptionClazz: KClass): Boolean { + if (exceptionClazz.isInstance(this)) return true + return exceptionClazz.isInstance(this.getRootCause()) +} + +fun Throwable.getStackTraceString(): String { + val sw = StringWriter(256) + val pw = PrintWriter(sw, false) + printStackTrace(pw) + pw.flush() + return sw.toString() +} + +fun Throwable.tryUnwrap(kClass: KClass = RuntimeException::class): Throwable = + if (!kClass.isInstance(this)) this else cause ?: this \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/flow/DynamicStateFlow.kt b/app/src/main/java/eu/darken/cap/common/flow/DynamicStateFlow.kt new file mode 100644 index 00000000..80e98d5b --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/flow/DynamicStateFlow.kt @@ -0,0 +1,149 @@ +package eu.darken.cap.common.flow + +import eu.darken.cap.common.debug.logging.Logging.Priority.VERBOSE +import eu.darken.cap.common.debug.logging.asLog +import eu.darken.cap.common.debug.logging.log +import kotlinx.coroutines.CancellationException +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.channels.BufferOverflow +import kotlinx.coroutines.flow.* +import kotlinx.coroutines.plus +import kotlinx.coroutines.runBlocking +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock +import kotlin.coroutines.CoroutineContext + +/** + * A thread safe stateful flow that can be updated blocking and async with a lazy initial value provider. + * + * @param loggingTag will be prepended to logging tag, i.e. "$loggingTag:HD" + * @param parentScope on which the update operations and callbacks will be executed on + * @param coroutineContext used in combination with [CoroutineScope] + * @param startValueProvider provides the first value, errors will be rethrown on [CoroutineScope] + */ +class DynamicStateFlow( + loggingTag: String? = null, + parentScope: CoroutineScope, + coroutineContext: CoroutineContext = parentScope.coroutineContext, + private val startValueProvider: suspend CoroutineScope.() -> T +) { + private val lTag = loggingTag?.let { "$it:DSFlow" } + + private val updateActions = MutableSharedFlow>( + replay = Int.MAX_VALUE, + extraBufferCapacity = Int.MAX_VALUE, + onBufferOverflow = BufferOverflow.SUSPEND + ) + private val valueGuard = Mutex() + + private val producer: Flow> = channelFlow { + var currentValue = valueGuard.withLock { + lTag?.let { log(it, VERBOSE) { "Providing startValue..." } } + + startValueProvider().also { startValue -> + val initializer = Update(onError = null, onModify = { startValue }) + send(State(value = startValue, updatedBy = initializer)) + lTag?.let { log(it, VERBOSE) { "...startValue provided and emitted." } } + } + } + + updateActions.collect { update -> + currentValue = valueGuard.withLock { + try { + update.onModify(currentValue).also { + send(State(value = it, updatedBy = update)) + } + } catch (e: Exception) { + lTag?.let { + log(it, VERBOSE) { "Data modifying failed (onError=${update.onError}): ${e.asLog()}" } + } + + if (update.onError != null) { + update.onError.invoke(e) + } else { + send(State(value = currentValue, error = e, updatedBy = update)) + } + + currentValue + } + } + } + + lTag?.let { log(it, VERBOSE) { "internal channelFlow finished." } } + } + + private val internalFlow = producer + .onStart { lTag?.let { log(it, VERBOSE) { "Internal onStart" } } } + .onCompletion { err -> + when { + err is CancellationException -> { + lTag?.let { log(it, VERBOSE) { "internal onCompletion() due to cancellation" } } + } + err != null -> { + lTag?.let { log(it, VERBOSE) { "internal onCompletion() due to error: ${err.asLog()}" } } + } + else -> { + lTag?.let { log(it, VERBOSE) { "internal onCompletion()" } } + } + } + } + .shareIn( + scope = parentScope + coroutineContext, + replay = 1, + started = SharingStarted.Lazily + ) + + val flow: Flow = internalFlow + .map { it.value } + .distinctUntilChanged() + + suspend fun value() = flow.first() + + /** + * Non blocking update method. + * Gets executed on the scope and context this instance was initialized with. + * + * @param onError if you don't provide this, and exception in [onUpdate] will the scope passed to this class + */ + fun updateAsync( + onError: (suspend (Exception) -> Unit) = { throw it }, + onUpdate: suspend T.() -> T, + ) { + val update: Update = Update( + onModify = onUpdate, + onError = onError + ) + runBlocking { updateActions.emit(update) } + } + + /** + * Blocking update method + * Gets executed on the scope and context this instance was initialized with. + * Waiting will happen on the callers scope. + * + * Any errors that occurred during [action] will be rethrown by this method. + */ + suspend fun updateBlocking(action: suspend T.() -> T): T { + val update: Update = Update(onModify = action) + updateActions.emit(update) + + lTag?.let { log(it, VERBOSE) { "Waiting for update." } } + val ourUpdate = internalFlow.first { it.updatedBy == update } + lTag?.let { log(it, VERBOSE) { "Finished waiting, got $ourUpdate" } } + + ourUpdate.error?.let { throw it } + + return ourUpdate.value + } + + private data class Update( + val onModify: suspend T.() -> T, + val onError: (suspend (Exception) -> Unit)? = null, + ) + + private data class State( + val value: T, + val error: Exception? = null, + val updatedBy: Update, + ) +} diff --git a/app/src/main/java/eu/darken/cap/common/flow/DynamicStateFlowExtensions.kt b/app/src/main/java/eu/darken/cap/common/flow/DynamicStateFlowExtensions.kt new file mode 100644 index 00000000..709f859e --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/flow/DynamicStateFlowExtensions.kt @@ -0,0 +1,3 @@ +package eu.darken.cap.common.flow + + diff --git a/app/src/main/java/eu/darken/cap/common/flow/FlowCombineExtensions.kt b/app/src/main/java/eu/darken/cap/common/flow/FlowCombineExtensions.kt new file mode 100644 index 00000000..bab5566e --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/flow/FlowCombineExtensions.kt @@ -0,0 +1,213 @@ +package eu.darken.cap.common.flow + +import kotlinx.coroutines.flow.Flow + + +//@Suppress("UNCHECKED_CAST", "LongParameterList") +//inline fun combine( +// flow: Flow, +// flow2: Flow, +// crossinline transform: suspend (T1, T2) -> R +//): Flow = kotlinx.coroutines.flow.combine( +// flow, +// flow2 +//) { args: Array<*> -> +// transform( +// args[0] as T1, +// args[1] as T2 +// ) +//} + +@Suppress("UNCHECKED_CAST", "LongParameterList") +inline fun combine( + flow: Flow, + flow2: Flow, + flow3: Flow, + crossinline transform: suspend (T1, T2, T3) -> R +): Flow = kotlinx.coroutines.flow.combine( + flow, + flow2, + flow3, +) { args: Array<*> -> + transform( + args[0] as T1, + args[1] as T2, + args[2] as T3, + ) +} + +@Suppress("UNCHECKED_CAST", "LongParameterList") +inline fun combine( + flow: Flow, + flow2: Flow, + flow3: Flow, + flow4: Flow, + flow5: Flow, + crossinline transform: suspend (T1, T2, T3, T4, T5) -> R +): Flow = kotlinx.coroutines.flow.combine( + flow, + flow2, + flow3, + flow4, + flow5 +) { args: Array<*> -> + transform( + args[0] as T1, + args[1] as T2, + args[2] as T3, + args[3] as T4, + args[4] as T5 + ) +} + +@Suppress("UNCHECKED_CAST", "LongParameterList") +inline fun combine( + flow: Flow, + flow2: Flow, + flow3: Flow, + flow4: Flow, + flow5: Flow, + flow6: Flow, + crossinline transform: suspend (T1, T2, T3, T4, T5, T6) -> R +): Flow = kotlinx.coroutines.flow.combine( + flow, + flow2, + flow3, + flow4, + flow5, + flow6 +) { args: Array<*> -> + transform( + args[0] as T1, + args[1] as T2, + args[2] as T3, + args[3] as T4, + args[4] as T5, + args[5] as T6 + ) +} + +@Suppress("UNCHECKED_CAST", "LongParameterList") +inline fun combine( + flow: Flow, + flow2: Flow, + flow3: Flow, + flow4: Flow, + flow5: Flow, + flow6: Flow, + flow7: Flow, + crossinline transform: suspend (T1, T2, T3, T4, T5, T6, T7) -> R +): Flow = kotlinx.coroutines.flow.combine( + flow, + flow2, + flow3, + flow4, + flow5, + flow6, + flow7 +) { args: Array<*> -> + transform( + args[0] as T1, + args[1] as T2, + args[2] as T3, + args[3] as T4, + args[4] as T5, + args[5] as T6, + args[6] as T7 + ) +} + +@Suppress("UNCHECKED_CAST", "LongParameterList") +inline fun combine( + flow: Flow, + flow2: Flow, + flow3: Flow, + flow4: Flow, + flow5: Flow, + flow6: Flow, + flow7: Flow, + flow8: Flow, + crossinline transform: suspend (T1, T2, T3, T4, T5, T6, T7, T8) -> R +): Flow = kotlinx.coroutines.flow.combine( + flow, + flow2, + flow3, + flow4, + flow5, + flow6, + flow7, + flow8 +) { args: Array<*> -> + transform( + args[0] as T1, + args[1] as T2, + args[2] as T3, + args[3] as T4, + args[4] as T5, + args[5] as T6, + args[6] as T7, + args[7] as T8 + ) +} + +@Suppress("UNCHECKED_CAST", "LongParameterList") +inline fun combine( + flow: Flow, + flow2: Flow, + flow3: Flow, + flow4: Flow, + flow5: Flow, + flow6: Flow, + flow7: Flow, + flow8: Flow, + flow9: Flow, + flow10: Flow, + crossinline transform: suspend (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R +): Flow = kotlinx.coroutines.flow.combine( + flow, flow2, flow3, flow4, flow5, flow6, flow7, flow8, flow9, flow10 +) { args: Array<*> -> + transform( + args[0] as T1, + args[1] as T2, + args[2] as T3, + args[3] as T4, + args[4] as T5, + args[5] as T6, + args[6] as T7, + args[7] as T8, + args[8] as T9, + args[9] as T10 + ) +} + +@Suppress("UNCHECKED_CAST", "LongParameterList") +inline fun combine( + flow: Flow, + flow2: Flow, + flow3: Flow, + flow4: Flow, + flow5: Flow, + flow6: Flow, + flow7: Flow, + flow8: Flow, + flow9: Flow, + flow10: Flow, + flow11: Flow, + crossinline transform: suspend (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R +): Flow = kotlinx.coroutines.flow.combine( + flow, flow2, flow3, flow4, flow5, flow6, flow7, flow8, flow9, flow10, flow11 +) { args: Array<*> -> + transform( + args[0] as T1, + args[1] as T2, + args[2] as T3, + args[3] as T4, + args[4] as T5, + args[5] as T6, + args[6] as T7, + args[7] as T8, + args[8] as T9, + args[9] as T10, + args[10] as T11 + ) +} diff --git a/app/src/main/java/eu/darken/cap/common/flow/FlowExtensions.kt b/app/src/main/java/eu/darken/cap/common/flow/FlowExtensions.kt new file mode 100644 index 00000000..4e450890 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/flow/FlowExtensions.kt @@ -0,0 +1,74 @@ +package eu.darken.cap.common.flow + +import eu.darken.cap.common.debug.logging.Logging.Priority.ERROR +import eu.darken.cap.common.debug.logging.Logging.Priority.VERBOSE +import eu.darken.cap.common.debug.logging.asLog +import eu.darken.cap.common.debug.logging.log +import eu.darken.cap.common.error.hasCause +import kotlinx.coroutines.CancellationException +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.flow.* +import kotlin.time.Duration + +/** + * Create a stateful flow, with the initial value of null, but never emits a null value. + * Helper method to create a new flow without suspending and without initial value + * The flow collector will just wait for the first value + */ +fun Flow.shareLatest( + tag: String? = null, + scope: CoroutineScope, + started: SharingStarted = SharingStarted.WhileSubscribed(replayExpirationMillis = 0) +) = this + .onStart { if (tag != null) log(tag) { "shareLatest(...) start" } } + .onEach { if (tag != null) log(tag) { "shareLatest(...) emission: $it" } } + .onCompletion { if (tag != null) log(tag) { "shareLatest(...) completed." } } + .catch { + if (tag != null) log(tag) { "shareLatest(...) catch(): ${it.asLog()}" } + throw it + } + .stateIn( + scope = scope, + started = started, + initialValue = null + ) + .filterNotNull() + +fun Flow.replayingShare(scope: CoroutineScope) = this.shareIn( + scope = scope, + replay = 1, + started = SharingStarted.WhileSubscribed(replayExpiration = Duration.ZERO) +) + +internal fun Flow.withPrevious(): Flow> = this + .scan(Pair(null, null)) { previous, current -> Pair(previous.second, current) } + .drop(1) + .map { + @Suppress("UNCHECKED_CAST") + it as Pair + } + + +fun Flow.onError(block: suspend (Throwable) -> Unit) = this.catch { + block(it) + throw it +} + +fun Flow.takeUntilAfter(predicate: suspend (T) -> Boolean) = transformWhile { + val fullfilled = predicate(it) + emit(it) + !fullfilled // We keep emitting until condition is fullfilled = true +} + +fun Flow.setupCommonEventHandlers(tag: String, identifier: () -> String) = this + .onStart { log(tag, VERBOSE) { "${identifier()}.onStart()" } } + .onEach { log(tag, VERBOSE) { "${identifier()}.onEach(): $it" } } + .onCompletion { log(tag, VERBOSE) { "${identifier()}.onCompletion()" } } + .catch { + if (it.hasCause(CancellationException::class)) { + log(tag, VERBOSE) { "${identifier()} cancelled" } + } else { + log(tag, ERROR) { "${identifier()} failed: ${it.asLog()}" } + throw it + } + } \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/lists/BaseAdapter.kt b/app/src/main/java/eu/darken/cap/common/lists/BaseAdapter.kt new file mode 100644 index 00000000..fc50dd0e --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/lists/BaseAdapter.kt @@ -0,0 +1,58 @@ +package eu.darken.cap.common.lists + +import android.content.Context +import android.content.res.Resources +import android.view.LayoutInflater +import android.view.ViewGroup +import androidx.annotation.* +import androidx.core.content.ContextCompat +import androidx.recyclerview.widget.RecyclerView +import eu.darken.cap.common.getColorForAttr + +abstract class BaseAdapter : RecyclerView.Adapter() { + + @CallSuper + final override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): T { + return onCreateBaseVH(parent, viewType) + } + + abstract fun onCreateBaseVH(parent: ViewGroup, viewType: Int): T + + @CallSuper + final override fun onBindViewHolder(holder: T, position: Int) { + onBindBaseVH(holder, position, mutableListOf()) + } + + @CallSuper + final override fun onBindViewHolder(holder: T, position: Int, payloads: MutableList) { + onBindBaseVH(holder, position, payloads) + } + + abstract fun onBindBaseVH(holder: T, position: Int, payloads: MutableList = mutableListOf()) + + abstract class VH(@LayoutRes layoutRes: Int, private val parent: ViewGroup) : RecyclerView.ViewHolder( + LayoutInflater.from(parent.context).inflate(layoutRes, parent, false) + ) { + + val context: Context + get() = parent.context + + val resources: Resources + get() = context.resources + + val layoutInflater: LayoutInflater + get() = LayoutInflater.from(context) + + fun getColor(@ColorRes colorRes: Int): Int = ContextCompat.getColor(context, colorRes) + + fun getColorForAttr(@AttrRes attrRes: Int): Int = context.getColorForAttr(attrRes) + + fun getString(@StringRes stringRes: Int, vararg args: Any): String = context.getString(stringRes, *args) + + fun getQuantityString(@PluralsRes pluralRes: Int, quantity: Int, vararg args: Any): String = + context.resources.getQuantityString(pluralRes, quantity, *args) + + fun getQuantityString(@PluralsRes pluralRes: Int, quantity: Int): String = + context.resources.getQuantityString(pluralRes, quantity, quantity) + } +} diff --git a/app/src/main/java/eu/darken/cap/common/lists/BindableVH.kt b/app/src/main/java/eu/darken/cap/common/lists/BindableVH.kt new file mode 100644 index 00000000..b5c64f20 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/lists/BindableVH.kt @@ -0,0 +1,14 @@ +package eu.darken.cap.common.lists + +import androidx.viewbinding.ViewBinding + +interface BindableVH { + + val viewBinding: Lazy + + val onBindData: ViewBindingT.(item: ItemT, payloads: List) -> Unit + + fun bind(item: ItemT, payloads: MutableList = mutableListOf()) = with(viewBinding.value) { + onBindData(item, payloads) + } +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/lists/DataAdapter.kt b/app/src/main/java/eu/darken/cap/common/lists/DataAdapter.kt new file mode 100644 index 00000000..57f66a5b --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/lists/DataAdapter.kt @@ -0,0 +1,13 @@ +package eu.darken.cap.common.lists + +import androidx.recyclerview.widget.RecyclerView + +interface DataAdapter { + val data: MutableList +} + +fun X.update(newData: List?, notify: Boolean = true) where X : DataAdapter, X : RecyclerView.Adapter<*> { + data.clear() + if (newData != null) data.addAll(newData) + if (notify) notifyDataSetChanged() +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/lists/ListItem.kt b/app/src/main/java/eu/darken/cap/common/lists/ListItem.kt new file mode 100644 index 00000000..efcd56d0 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/lists/ListItem.kt @@ -0,0 +1,3 @@ +package eu.darken.cap.common.lists + +interface ListItem \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/lists/RecyclerViewExtensions.kt b/app/src/main/java/eu/darken/cap/common/lists/RecyclerViewExtensions.kt new file mode 100644 index 00000000..16bd5cd3 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/lists/RecyclerViewExtensions.kt @@ -0,0 +1,13 @@ +package eu.darken.cap.common.lists + +import androidx.recyclerview.widget.DefaultItemAnimator +import androidx.recyclerview.widget.DividerItemDecoration +import androidx.recyclerview.widget.LinearLayoutManager +import androidx.recyclerview.widget.RecyclerView + +fun RecyclerView.setupDefaults(adapter: RecyclerView.Adapter<*>? = null, dividers: Boolean = true) = apply { + layoutManager = LinearLayoutManager(context) + itemAnimator = DefaultItemAnimator() + if (dividers) addItemDecoration(DividerItemDecoration(context, DividerItemDecoration.VERTICAL)) + if (adapter != null) this.adapter = adapter +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/lists/differ/AsyncDiffer.kt b/app/src/main/java/eu/darken/cap/common/lists/differ/AsyncDiffer.kt new file mode 100644 index 00000000..79d660dd --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/lists/differ/AsyncDiffer.kt @@ -0,0 +1,43 @@ +package eu.darken.cap.common.lists.differ + +import androidx.recyclerview.widget.AsyncListDiffer +import androidx.recyclerview.widget.DiffUtil +import eu.darken.cap.common.lists.modular.ModularAdapter +import eu.darken.cap.common.lists.modular.mods.StableIdMod + +class AsyncDiffer internal constructor( + adapter: A, + compareItem: (T, T) -> Boolean = { i1, i2 -> i1.stableId == i2.stableId }, + compareItemContent: (T, T) -> Boolean = { i1, i2 -> i1 == i2 }, + determinePayload: (T, T) -> Any? = { i1, i2 -> + when { + i1::class == i2::class -> i1.payloadProvider?.invoke(i1, i2) + else -> null + } + } +) where A : HasAsyncDiffer, A : ModularAdapter<*> { + private val callback = object : DiffUtil.ItemCallback() { + override fun areItemsTheSame(oldItem: T, newItem: T): Boolean = compareItem(oldItem, newItem) + override fun areContentsTheSame(oldItem: T, newItem: T): Boolean = compareItemContent(oldItem, newItem) + override fun getChangePayload(oldItem: T, newItem: T): Any? = determinePayload(oldItem, newItem) + } + + private val internalList = mutableListOf() + private val listDiffer = AsyncListDiffer(adapter, callback) + + val currentList: List + get() = synchronized(internalList) { internalList } + + init { + adapter.modules.add(0, StableIdMod(currentList)) + } + + fun submitUpdate(newData: List) { + listDiffer.submitList(newData) { + synchronized(internalList) { + internalList.clear() + internalList.addAll(newData) + } + } + } +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/lists/differ/AsyncDifferExtensions.kt b/app/src/main/java/eu/darken/cap/common/lists/differ/AsyncDifferExtensions.kt new file mode 100644 index 00000000..ee6f714c --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/lists/differ/AsyncDifferExtensions.kt @@ -0,0 +1,15 @@ +package eu.darken.cap.common.lists.differ + +import androidx.recyclerview.widget.RecyclerView +import eu.darken.cap.common.lists.modular.ModularAdapter + + +fun X.update(newData: List?) + where X : HasAsyncDiffer, X : RecyclerView.Adapter<*> { + + asyncDiffer.submitUpdate(newData ?: emptyList()) +} + +fun A.setupDiffer(): AsyncDiffer + where A : HasAsyncDiffer, A : ModularAdapter<*> = + AsyncDiffer(this) diff --git a/app/src/main/java/eu/darken/cap/common/lists/differ/DifferItem.kt b/app/src/main/java/eu/darken/cap/common/lists/differ/DifferItem.kt new file mode 100644 index 00000000..db01100a --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/lists/differ/DifferItem.kt @@ -0,0 +1,10 @@ +package eu.darken.cap.common.lists.differ + +import eu.darken.cap.common.lists.ListItem + +interface DifferItem : ListItem { + val stableId: Long + + val payloadProvider: ((DifferItem, DifferItem) -> DifferItem?)? + get() = null +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/lists/differ/HasAsyncDiffer.kt b/app/src/main/java/eu/darken/cap/common/lists/differ/HasAsyncDiffer.kt new file mode 100644 index 00000000..24d56919 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/lists/differ/HasAsyncDiffer.kt @@ -0,0 +1,10 @@ +package eu.darken.cap.common.lists.differ + +interface HasAsyncDiffer { + + val data: List + get() = asyncDiffer.currentList + + val asyncDiffer: AsyncDiffer<*, T> + +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/lists/modular/ModularAdapter.kt b/app/src/main/java/eu/darken/cap/common/lists/modular/ModularAdapter.kt new file mode 100644 index 00000000..83d8769c --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/lists/modular/ModularAdapter.kt @@ -0,0 +1,95 @@ +package eu.darken.cap.common.lists.modular + +import android.view.ViewGroup +import androidx.annotation.CallSuper +import androidx.annotation.LayoutRes +import androidx.recyclerview.widget.RecyclerView +import eu.darken.cap.common.lists.BaseAdapter + +abstract class ModularAdapter : BaseAdapter() { + val modules = mutableListOf() + + init { + modules.filterIsInstance().forEach { it.onAdapterReady(this) } + } + + override fun getItemId(position: Int): Long { + modules.filterIsInstance().forEach { + val id = it.getItemId(this, position) + if (id != null) return id + } + return super.getItemId(position) + } + + @CallSuper + override fun getItemViewType(position: Int): Int { + modules.filterIsInstance().forEach { + val type = it.onGetItemType(this, position) + if (type != null) return type + } + return super.getItemViewType(position) + } + + override fun onCreateBaseVH(parent: ViewGroup, viewType: Int): VH { + modules.filterIsInstance>().forEach { + val vh = it.onCreateModularVH(this, parent, viewType) + if (vh != null) return vh + } + throw IllegalStateException("Couldn't create VH for type $viewType with $parent") + } + + @CallSuper + override fun onBindBaseVH(holder: VH, position: Int, payloads: MutableList) { + modules.filterIsInstance>().forEach { + it.onBindModularVH(this, holder, position, payloads) + it.onPostBind(this, holder, position) + } + } + + @CallSuper + override fun onAttachedToRecyclerView(recyclerView: RecyclerView) { + modules.filterIsInstance().forEach { it.onAttachedToRecyclerView(recyclerView) } + super.onAttachedToRecyclerView(recyclerView) + } + + @CallSuper + override fun onDetachedFromRecyclerView(recyclerView: RecyclerView) { + modules.filterIsInstance().forEach { it.onDetachedFromRecyclerView(recyclerView) } + super.onDetachedFromRecyclerView(recyclerView) + } + + abstract class VH(@LayoutRes layoutRes: Int, parent: ViewGroup) : BaseAdapter.VH(layoutRes, parent) + + interface Module { + interface Setup { + fun onAdapterReady(adapter: ModularAdapter<*>) + } + + interface Creator : Module { + fun onCreateModularVH(adapter: ModularAdapter, parent: ViewGroup, viewType: Int): T? + } + + interface Binder : Module { + fun onBindModularVH(adapter: ModularAdapter, vh: T, pos: Int, payloads: MutableList) { + // NOOP + } + + fun onPostBind(adapter: ModularAdapter, vh: T, pos: Int) { + // NOOP + } + } + + interface Typing : Module { + fun onGetItemType(adapter: ModularAdapter<*>, pos: Int): Int? + } + + interface ItemId : Module { + fun getItemId(adapter: ModularAdapter<*>, position: Int): Long? + } + + interface RecyclerViewLifecycle : Module { + fun onDetachedFromRecyclerView(recyclerView: RecyclerView) + fun onAttachedToRecyclerView(recyclerView: RecyclerView) + } + } +} diff --git a/app/src/main/java/eu/darken/cap/common/lists/modular/mods/ClickMod.kt b/app/src/main/java/eu/darken/cap/common/lists/modular/mods/ClickMod.kt new file mode 100644 index 00000000..301347a4 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/lists/modular/mods/ClickMod.kt @@ -0,0 +1,12 @@ +package eu.darken.cap.common.lists.modular.mods + +import eu.darken.cap.common.lists.modular.ModularAdapter + +class ClickMod constructor( + private val listener: (VHT, Int) -> Unit +) : ModularAdapter.Module.Binder { + + override fun onBindModularVH(adapter: ModularAdapter, vh: VHT, pos: Int, payloads: MutableList) { + vh.itemView.setOnClickListener { listener.invoke(vh, pos) } + } +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/lists/modular/mods/DataBinderMod.kt b/app/src/main/java/eu/darken/cap/common/lists/modular/mods/DataBinderMod.kt new file mode 100644 index 00000000..947c8f59 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/lists/modular/mods/DataBinderMod.kt @@ -0,0 +1,17 @@ +package eu.darken.cap.common.lists.modular.mods + +import androidx.viewbinding.ViewBinding +import eu.darken.cap.common.lists.BindableVH +import eu.darken.cap.common.lists.modular.ModularAdapter + +class DataBinderMod constructor( + private val data: List, + private val customBinder: ( + (adapter: ModularAdapter, vh: HolderT, pos: Int, payload: MutableList) -> Unit + )? = null +) : ModularAdapter.Module.Binder where HolderT : BindableVH, HolderT : ModularAdapter.VH { + + override fun onBindModularVH(adapter: ModularAdapter, vh: HolderT, pos: Int, payloads: MutableList) { + customBinder?.invoke(adapter, vh, pos, mutableListOf()) ?: vh.bind(data[pos], payloads) + } +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/lists/modular/mods/SimpleVHCreatorMod.kt b/app/src/main/java/eu/darken/cap/common/lists/modular/mods/SimpleVHCreatorMod.kt new file mode 100644 index 00000000..1c814c8a --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/lists/modular/mods/SimpleVHCreatorMod.kt @@ -0,0 +1,15 @@ +package eu.darken.cap.common.lists.modular.mods + +import android.view.ViewGroup +import eu.darken.cap.common.lists.modular.ModularAdapter + +class SimpleVHCreatorMod constructor( + private val viewType: Int = 0, + private val factory: (ViewGroup) -> HolderT +) : ModularAdapter.Module.Creator where HolderT : ModularAdapter.VH { + + override fun onCreateModularVH(adapter: ModularAdapter, parent: ViewGroup, viewType: Int): HolderT? { + if (this.viewType != viewType) return null + return factory.invoke(parent) + } +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/lists/modular/mods/StableIdMod.kt b/app/src/main/java/eu/darken/cap/common/lists/modular/mods/StableIdMod.kt new file mode 100644 index 00000000..8017b157 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/lists/modular/mods/StableIdMod.kt @@ -0,0 +1,21 @@ +package eu.darken.cap.common.lists.modular.mods + +import androidx.recyclerview.widget.RecyclerView +import eu.darken.cap.common.lists.differ.DifferItem +import eu.darken.cap.common.lists.modular.ModularAdapter + +class StableIdMod constructor( + private val data: List, + private val customResolver: (position: Int) -> Long = { + (data[it] as? DifferItem)?.stableId ?: RecyclerView.NO_ID + } +) : ModularAdapter.Module.ItemId, ModularAdapter.Module.Setup { + + override fun onAdapterReady(adapter: ModularAdapter<*>) { + adapter.setHasStableIds(true) + } + + override fun getItemId(adapter: ModularAdapter<*>, position: Int): Long? { + return customResolver.invoke(position) + } +} diff --git a/app/src/main/java/eu/darken/cap/common/lists/modular/mods/TypedVHCreatorMod.kt b/app/src/main/java/eu/darken/cap/common/lists/modular/mods/TypedVHCreatorMod.kt new file mode 100644 index 00000000..5f0cf16c --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/lists/modular/mods/TypedVHCreatorMod.kt @@ -0,0 +1,29 @@ +package eu.darken.cap.common.lists.modular.mods + +import android.view.ViewGroup +import eu.darken.cap.common.lists.modular.ModularAdapter + +class TypedVHCreatorMod constructor( + private val typeResolver: (Int) -> Boolean, + private val factory: (ViewGroup) -> HolderT +) : ModularAdapter.Module.Typing, + ModularAdapter.Module.Creator where HolderT : ModularAdapter.VH { + + private fun ModularAdapter<*>.determineOurViewType(): Int { + val typingModules = modules.filterIsInstance(ModularAdapter.Module.Typing::class.java) + return typingModules.indexOf(this@TypedVHCreatorMod) + } + + override fun onGetItemType(adapter: ModularAdapter<*>, pos: Int): Int? { + return if (typeResolver.invoke(pos)) adapter.determineOurViewType() else null + } + + override fun onCreateModularVH( + adapter: ModularAdapter, + parent: ViewGroup, + viewType: Int + ): HolderT? { + if (adapter.determineOurViewType() != viewType) return null + return factory.invoke(parent) + } +} diff --git a/app/src/main/java/eu/darken/cap/common/livedata/SingleLiveEvent.kt b/app/src/main/java/eu/darken/cap/common/livedata/SingleLiveEvent.kt new file mode 100644 index 00000000..2fb97195 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/livedata/SingleLiveEvent.kt @@ -0,0 +1,76 @@ +package eu.darken.cap.common.livedata + +/* + * Copyright 2017 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +import androidx.annotation.MainThread +import androidx.annotation.Nullable +import androidx.lifecycle.LifecycleOwner +import androidx.lifecycle.MutableLiveData +import androidx.lifecycle.Observer +import eu.darken.cap.common.debug.logging.Logging.Priority.WARN +import eu.darken.cap.common.debug.logging.log +import java.util.concurrent.atomic.AtomicBoolean + +/** + * A lifecycle-aware observable that sends only new updates after subscription, used for events like + * navigation and Snackbar messages. + * + * + * This avoids a common problem with events: on configuration change (like rotation) an update + * can be emitted if the observer is active. This LiveData only calls the observable if there's an + * explicit call to setValue() or call(). + * + * + * Note that only one observer is going to be notified of changes. + * https://github.com/android/architecture-samples/blob/166ca3a93ad14c6e224a3ea9bfcbd773eb048fb0/todoapp/app/src/main/java/com/example/android/architecture/blueprints/todoapp/SingleLiveEvent.java + */ +class SingleLiveEvent : MutableLiveData() { + + private val pending = AtomicBoolean(false) + + @MainThread + override fun observe(owner: LifecycleOwner, observer: Observer) { + if (hasActiveObservers()) { + log(WARN) { "Multiple observers registered but only one will be notified of changes." } + } + + // Observe the internal MutableLiveData + super.observe( + owner, + { t -> + if (pending.compareAndSet(true, false)) { + observer.onChanged(t) + } + } + ) + } + + @MainThread + override fun setValue(@Nullable t: T?) { + pending.set(true) + super.setValue(t) + } + + /** + * Used for cases where T is Void, to make calls cleaner. + */ + @MainThread + fun call() { + value = null + } +} diff --git a/app/src/main/java/eu/darken/cap/common/navigation/FragmentExtensions.kt b/app/src/main/java/eu/darken/cap/common/navigation/FragmentExtensions.kt new file mode 100644 index 00000000..d8f26f89 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/navigation/FragmentExtensions.kt @@ -0,0 +1,38 @@ +package eu.darken.cap.common.navigation + +import android.app.Activity +import androidx.annotation.IdRes +import androidx.fragment.app.Fragment +import androidx.fragment.app.FragmentContainerView +import androidx.fragment.app.FragmentManager +import androidx.navigation.NavController +import androidx.navigation.NavDirections +import androidx.navigation.fragment.NavHostFragment +import androidx.navigation.fragment.findNavController +import eu.darken.cap.common.debug.logging.Logging.Priority.WARN +import eu.darken.cap.common.debug.logging.asLog +import eu.darken.cap.common.debug.logging.log + +fun Fragment.doNavigate(direction: NavDirections) = findNavController().doNavigate(direction) + +fun Fragment.popBackStack(): Boolean { + if (!isAdded) { + IllegalStateException("Fragment is not added").also { + log(WARN) { "Trying to pop backstack on Fragment that isn't added to an Activity: ${it.asLog()}" } + } + return false + } + return findNavController().popBackStack() +} + +/** + * [FragmentContainerView] does not access [NavController] in [Activity.onCreate] + * as workaround [FragmentManager] is used to get the [NavController] + * @param id [Int] NavFragment id + * @see issue-142847973 + */ +@Throws(IllegalStateException::class) +fun FragmentManager.findNavController(@IdRes id: Int): NavController { + val fragment = findFragmentById(id) ?: throw IllegalStateException("Fragment is not found for id:$id") + return NavHostFragment.findNavController(fragment) +} diff --git a/app/src/main/java/eu/darken/cap/common/navigation/NavArgsExtensions.kt b/app/src/main/java/eu/darken/cap/common/navigation/NavArgsExtensions.kt new file mode 100644 index 00000000..9f568dc6 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/navigation/NavArgsExtensions.kt @@ -0,0 +1,20 @@ +package eu.darken.cap.common.navigation + +import android.os.Bundle +import android.os.Parcelable +import androidx.lifecycle.SavedStateHandle +import androidx.navigation.NavArgs +import androidx.navigation.NavArgsLazy +import java.io.Serializable + +// TODO Remove with "androidx.navigation:navigation-safe-args-gradle-plugin:2.4.0-alpha/stable" +inline fun SavedStateHandle.navArgs() = NavArgsLazy(Args::class) { + Bundle().apply { + keys().forEach { + when (val value = get(it)) { + is Serializable -> putSerializable(it, value) + is Parcelable -> putParcelable(it, value) + } + } + } +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/navigation/NavControllerExtensions.kt b/app/src/main/java/eu/darken/cap/common/navigation/NavControllerExtensions.kt new file mode 100644 index 00000000..b676a9bd --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/navigation/NavControllerExtensions.kt @@ -0,0 +1,22 @@ +package eu.darken.cap.common.navigation + +import android.os.Bundle +import androidx.annotation.IdRes +import androidx.navigation.NavController +import androidx.navigation.NavDirections + +fun NavController.navigateIfNotThere(@IdRes resId: Int, args: Bundle? = null) { + if (currentDestination?.id == resId) return + navigate(resId, args) +} + +fun NavController.doNavigate(direction: NavDirections) { + currentDestination?.getAction(direction.actionId)?.let { navigate(direction) } +} + +fun NavController.isGraphSet(): Boolean = try { + graph + true +} catch (e: IllegalStateException) { + false +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/navigation/NavDestinationExtensions.kt b/app/src/main/java/eu/darken/cap/common/navigation/NavDestinationExtensions.kt new file mode 100644 index 00000000..7384a568 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/navigation/NavDestinationExtensions.kt @@ -0,0 +1,9 @@ +package eu.darken.cap.common.navigation + +import androidx.annotation.IdRes +import androidx.navigation.NavDestination + +fun NavDestination?.hasAction(@IdRes id: Int): Boolean { + if (this == null) return false + return getAction(id) != null +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/navigation/NavDirectionsExtensions.kt b/app/src/main/java/eu/darken/cap/common/navigation/NavDirectionsExtensions.kt new file mode 100644 index 00000000..d7d32c56 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/navigation/NavDirectionsExtensions.kt @@ -0,0 +1,13 @@ +package eu.darken.cap.common.navigation + +import androidx.lifecycle.MutableLiveData +import androidx.navigation.NavDirections +import eu.darken.cap.common.livedata.SingleLiveEvent + +fun NavDirections.navVia(pub: MutableLiveData) = pub.postValue(this) + +fun NavDirections.navVia(provider: NavEventSource) = this.navVia(provider.navEvents) + +interface NavEventSource { + val navEvents: SingleLiveEvent +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/permissions/Permission.kt b/app/src/main/java/eu/darken/cap/common/permissions/Permission.kt new file mode 100644 index 00000000..5665af56 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/permissions/Permission.kt @@ -0,0 +1,32 @@ +package eu.darken.cap.common.permissions + +import android.content.Context +import android.content.pm.PackageManager +import android.os.Build +import androidx.annotation.StringRes +import androidx.core.content.ContextCompat +import eu.darken.cap.R + +enum class Permission( + val minApiLevel: Int, + @StringRes val labelRes: Int, + @StringRes val descriptionRes: Int, + val permissionId: String, +) { + BLUETOOTH_CONNECT( + minApiLevel = Build.VERSION_CODES.S, + labelRes = R.string.permission_bluetooth_connect_label, + descriptionRes = R.string.permission_bluetooth_connect_description, + permissionId = "android.permission.BLUETOOTH_CONNECT", + ), + BLUETOOTH_SCAN( + minApiLevel = Build.VERSION_CODES.S, + labelRes = R.string.permission_bluetooth_scan_label, + descriptionRes = R.string.permission_bluetooth_scan_description, + permissionId = "android.permission.BLUETOOTH_SCAN", + ) +} + +fun Permission.isGranted(context: Context): Boolean { + return ContextCompat.checkSelfPermission(context, permissionId) == PackageManager.PERMISSION_GRANTED +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/preferences/FlowPreference.kt b/app/src/main/java/eu/darken/cap/common/preferences/FlowPreference.kt new file mode 100644 index 00000000..bd5cc641 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/preferences/FlowPreference.kt @@ -0,0 +1,90 @@ +package eu.darken.cap.common.preferences + +import android.content.SharedPreferences +import androidx.core.content.edit +import eu.darken.cap.common.debug.logging.Logging.Priority.* +import eu.darken.cap.common.debug.logging.log +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.MutableStateFlow + +class FlowPreference constructor( + private val preferences: SharedPreferences, + private val key: String, + private val reader: SharedPreferences.(key: String) -> T, + private val writer: SharedPreferences.Editor.(key: String, value: T) -> Unit +) { + + private val flowInternal = MutableStateFlow(internalValue) + val flow: Flow = flowInternal + + private val preferenceChangeListener = + SharedPreferences.OnSharedPreferenceChangeListener { changedPrefs, changedKey -> + if (changedKey != key) return@OnSharedPreferenceChangeListener + + val newValue = reader(changedPrefs, changedKey) + val currentvalue = flowInternal.value + if (currentvalue != newValue && flowInternal.compareAndSet(currentvalue, newValue)) { + log(VERBOSE) { "$changedPrefs:$changedKey changed to $newValue" } + } + } + + init { + preferences.registerOnSharedPreferenceChangeListener(preferenceChangeListener) + } + + private var internalValue: T + get() = reader(preferences, key) + set(newValue) { + preferences.edit { + writer(key, newValue) + } + flowInternal.value = internalValue + } + val value: T + get() = internalValue + + fun update(update: (T) -> T) { + internalValue = update(internalValue) + } + + companion object { + inline fun basicReader(defaultValue: T): SharedPreferences.(key: String) -> T = + { key -> + (this.all[key] ?: defaultValue) as T + } + + inline fun basicWriter(): SharedPreferences.Editor.(key: String, value: T) -> Unit = + { key, value -> + when (value) { + is Boolean -> putBoolean(key, value) + is String -> putString(key, value) + is Int -> putInt(key, value) + is Long -> putLong(key, value) + is Float -> putFloat(key, value) + null -> remove(key) + else -> throw NotImplementedError() + } + } + } +} + +inline fun SharedPreferences.createFlowPreference( + key: String, + defaultValue: T = null as T +) = FlowPreference( + preferences = this, + key = key, + reader = FlowPreference.basicReader(defaultValue), + writer = FlowPreference.basicWriter() +) + +inline fun SharedPreferences.createFlowPreference( + key: String, + noinline reader: SharedPreferences.(key: String) -> T, + noinline writer: SharedPreferences.Editor.(key: String, value: T) -> Unit +) = FlowPreference( + preferences = this, + key = key, + reader = reader, + writer = writer +) diff --git a/app/src/main/java/eu/darken/cap/common/preferences/SharedPreferenceExtensions.kt b/app/src/main/java/eu/darken/cap/common/preferences/SharedPreferenceExtensions.kt new file mode 100644 index 00000000..8e580e20 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/preferences/SharedPreferenceExtensions.kt @@ -0,0 +1,16 @@ +package eu.darken.cap.common.preferences + +import android.content.SharedPreferences +import androidx.core.content.edit +import eu.darken.cap.common.debug.logging.Logging.Priority.VERBOSE +import eu.darken.cap.common.debug.logging.log + +fun SharedPreferences.clearAndNotify() { + val currentKeys = this.all.keys.toSet() + log(VERBOSE) { "$this clearAndNotify(): $currentKeys" } + edit { + currentKeys.forEach { remove(it) } + } + // Clear does not notify anyone using registerOnSharedPreferenceChangeListener + edit(commit = true) { clear() } +} diff --git a/app/src/main/java/eu/darken/cap/common/smart/Smart2BottomSheetDialogFragment.kt b/app/src/main/java/eu/darken/cap/common/smart/Smart2BottomSheetDialogFragment.kt new file mode 100644 index 00000000..0f209156 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/smart/Smart2BottomSheetDialogFragment.kt @@ -0,0 +1,95 @@ +package eu.darken.cap.common.smart + +import android.content.Context +import android.content.Intent +import android.os.Bundle +import android.view.LayoutInflater +import android.view.View +import android.view.ViewGroup +import androidx.lifecycle.LiveData +import androidx.viewbinding.ViewBinding +import com.google.android.material.bottomsheet.BottomSheetDialogFragment +import eu.darken.cap.common.debug.logging.Logging.Priority.VERBOSE +import eu.darken.cap.common.debug.logging.log +import eu.darken.cap.common.debug.logging.logTag +import eu.darken.cap.common.error.asErrorDialogBuilder +import eu.darken.cap.common.navigation.doNavigate +import eu.darken.cap.common.navigation.popBackStack +import eu.darken.cap.common.observe2 + + +abstract class Smart2BottomSheetDialogFragment : BottomSheetDialogFragment() { + + abstract val ui: ViewBinding + abstract val vdc: Smart2VM + + internal val tag: String = + logTag("Fragment", "${this.javaClass.simpleName}(${Integer.toHexString(hashCode())})") + + override fun onAttach(context: Context) { + log(tag, VERBOSE) { "onAttach(context=$context)" } + super.onAttach(context) + } + + override fun onCreate(savedInstanceState: Bundle?) { + log(tag, VERBOSE) { "onCreate(savedInstanceState=$savedInstanceState)" } + super.onCreate(savedInstanceState) + } + + override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? { + log(tag, VERBOSE) { + "onCreateView(inflater=$inflater, container=$container, savedInstanceState=$savedInstanceState" + } + return super.onCreateView(inflater, container, savedInstanceState) + } + + override fun onViewCreated(view: View, savedInstanceState: Bundle?) { + log(tag, VERBOSE) { "onViewCreated(view=$view, savedInstanceState=$savedInstanceState)" } + super.onViewCreated(view, savedInstanceState) + + vdc.navEvents.observe2(this, ui) { dir -> dir?.let { doNavigate(it) } ?: popBackStack() } + vdc.errorEvents.observe2(this, ui) { it.asErrorDialogBuilder(requireContext()).show() } + } + + override fun onActivityCreated(savedInstanceState: Bundle?) { + log(tag, VERBOSE) { "onActivityCreated(savedInstanceState=$savedInstanceState)" } + super.onActivityCreated(savedInstanceState) + } + + override fun onResume() { + log(tag, VERBOSE) { "onResume()" } + super.onResume() + } + + override fun onPause() { + log(tag, VERBOSE) { "onPause()" } + super.onPause() + } + + override fun onDestroyView() { + log(tag, VERBOSE) { "onDestroyView()" } + super.onDestroyView() + } + + override fun onDetach() { + log(tag, VERBOSE) { "onDetach()" } + super.onDetach() + } + + override fun onDestroy() { + log(tag, VERBOSE) { "onDestroy()" } + super.onDestroy() + } + + override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) { + log(tag, VERBOSE) { "onActivityResult(requestCode=$requestCode, resultCode=$resultCode, data=$data)" } + super.onActivityResult(requestCode, resultCode, data) + } + + inline fun LiveData.observe2( + ui: VB, + crossinline callback: VB.(T) -> Unit + ) { + observe(viewLifecycleOwner) { callback.invoke(ui, it) } + } +} diff --git a/app/src/main/java/eu/darken/cap/common/smart/Smart2Fragment.kt b/app/src/main/java/eu/darken/cap/common/smart/Smart2Fragment.kt new file mode 100644 index 00000000..4cd94e9b --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/smart/Smart2Fragment.kt @@ -0,0 +1,53 @@ +package eu.darken.cap.common.smart + +import android.os.Bundle +import android.view.View +import androidx.annotation.LayoutRes +import androidx.lifecycle.LiveData +import androidx.viewbinding.ViewBinding +import eu.darken.cap.common.debug.logging.log +import eu.darken.cap.common.error.asErrorDialogBuilder +import eu.darken.cap.common.navigation.doNavigate +import eu.darken.cap.common.navigation.popBackStack + + +abstract class Smart2Fragment(@LayoutRes layoutRes: Int?) : SmartFragment(layoutRes) { + + constructor() : this(null) + + abstract val ui: ViewBinding? + abstract val vm: Smart2VM + + var onErrorEvent: ((Throwable) -> Boolean)? = null + + var onFinishEvent: (() -> Unit)? = null + + override fun onViewCreated(view: View, savedInstanceState: Bundle?) { + super.onViewCreated(view, savedInstanceState) + + vm.navEvents.observe2(ui) { + log { "navEvents: $it" } + + it?.run { doNavigate(this) } ?: onFinishEvent?.invoke() ?: popBackStack() + } + + vm.errorEvents.observe2(ui) { + val showDialog = onErrorEvent?.invoke(it) ?: true + if (showDialog) it.asErrorDialogBuilder(requireContext()).show() + } + } + + inline fun LiveData.observe2( + crossinline callback: (T) -> Unit + ) { + observe(viewLifecycleOwner) { callback.invoke(it) } + } + + inline fun LiveData.observe2( + ui: VB, + crossinline callback: VB.(T) -> Unit + ) { + observe(viewLifecycleOwner) { callback.invoke(ui, it) } + } + +} diff --git a/app/src/main/java/eu/darken/cap/common/smart/Smart2VM.kt b/app/src/main/java/eu/darken/cap/common/smart/Smart2VM.kt new file mode 100644 index 00000000..abad88d8 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/smart/Smart2VM.kt @@ -0,0 +1,34 @@ +package eu.darken.cap.common.smart + +import androidx.navigation.NavDirections +import eu.darken.cap.common.coroutine.DispatcherProvider +import eu.darken.cap.common.debug.logging.asLog +import eu.darken.cap.common.debug.logging.log +import eu.darken.cap.common.error.ErrorEventSource +import eu.darken.cap.common.flow.setupCommonEventHandlers +import eu.darken.cap.common.livedata.SingleLiveEvent +import eu.darken.cap.common.navigation.NavEventSource +import kotlinx.coroutines.CoroutineExceptionHandler +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.launchIn + + +abstract class Smart2VM( + dispatcherProvider: DispatcherProvider, +) : SmartVM(dispatcherProvider), NavEventSource, ErrorEventSource { + + override val navEvents = SingleLiveEvent() + override val errorEvents = SingleLiveEvent() + + init { + launchErrorHandler = CoroutineExceptionHandler { _, ex -> + log(TAG) { "Error during launch: ${ex.asLog()}" } + errorEvents.postValue(ex) + } + } + + override fun Flow.launchInViewModel() = this + .setupCommonEventHandlers(TAG) { "launchInViewModel()" } + .launchIn(vmScope) + +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/smart/SmartActivity.kt b/app/src/main/java/eu/darken/cap/common/smart/SmartActivity.kt new file mode 100644 index 00000000..2f564a76 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/smart/SmartActivity.kt @@ -0,0 +1,39 @@ +package eu.darken.cap.common.smart + +import android.content.Intent +import android.os.Bundle +import androidx.appcompat.app.AppCompatActivity +import eu.darken.cap.common.debug.logging.Logging.Priority.VERBOSE +import eu.darken.cap.common.debug.logging.log +import eu.darken.cap.common.debug.logging.logTag + +abstract class SmartActivity : AppCompatActivity() { + internal val tag: String = + logTag("Activity", this.javaClass.simpleName + "(" + Integer.toHexString(hashCode()) + ")") + + override fun onCreate(savedInstanceState: Bundle?) { + log(tag, VERBOSE) { "onCreate(savedInstanceState=$savedInstanceState)" } + super.onCreate(savedInstanceState) + } + + override fun onResume() { + log(tag, VERBOSE) { "onResume()" } + super.onResume() + } + + override fun onPause() { + log(tag, VERBOSE) { "onPause()" } + super.onPause() + } + + override fun onDestroy() { + log(tag, VERBOSE) { "onDestroy()" } + super.onDestroy() + } + + override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) { + log(tag, VERBOSE) { "onActivityResult(requestCode=$requestCode, resultCode=$resultCode, data=$data)" } + super.onActivityResult(requestCode, resultCode, data) + } + +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/smart/SmartFragment.kt b/app/src/main/java/eu/darken/cap/common/smart/SmartFragment.kt new file mode 100644 index 00000000..b63d979b --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/smart/SmartFragment.kt @@ -0,0 +1,80 @@ +package eu.darken.cap.common.smart + +import android.content.Context +import android.content.Intent +import android.os.Bundle +import android.view.LayoutInflater +import android.view.View +import android.view.ViewGroup +import androidx.annotation.LayoutRes +import androidx.fragment.app.Fragment +import eu.darken.cap.common.debug.logging.Logging.Priority.VERBOSE +import eu.darken.cap.common.debug.logging.log +import eu.darken.cap.common.debug.logging.logTag + + +abstract class SmartFragment(@LayoutRes val layoutRes: Int?) : Fragment(layoutRes ?: 0) { + + constructor() : this(null) + + internal val tag: String = + logTag("Fragment", "${this.javaClass.simpleName}(${Integer.toHexString(hashCode())})") + + override fun onAttach(context: Context) { + log(tag, VERBOSE) { "onAttach(context=$context)" } + super.onAttach(context) + } + + override fun onCreate(savedInstanceState: Bundle?) { + log(tag, VERBOSE) { "onCreate(savedInstanceState=$savedInstanceState)" } + super.onCreate(savedInstanceState) + } + + override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? { + log(tag, VERBOSE) { + "onCreateView(inflater=$inflater, container=$container, savedInstanceState=$savedInstanceState" + } + return layoutRes?.let { inflater.inflate(it, container, false) } + } + + override fun onViewCreated(view: View, savedInstanceState: Bundle?) { + log(tag, VERBOSE) { "onViewCreated(view=$view, savedInstanceState=$savedInstanceState)" } + super.onViewCreated(view, savedInstanceState) + } + + override fun onActivityCreated(savedInstanceState: Bundle?) { + log(tag, VERBOSE) { "onActivityCreated(savedInstanceState=$savedInstanceState)" } + super.onActivityCreated(savedInstanceState) + } + + override fun onResume() { + log(tag, VERBOSE) { "onResume()" } + super.onResume() + } + + override fun onPause() { + log(tag, VERBOSE) { "onPause()" } + super.onPause() + } + + override fun onDestroyView() { + log(tag, VERBOSE) { "onDestroyView()" } + super.onDestroyView() + } + + override fun onDetach() { + log(tag, VERBOSE) { "onDetach()" } + super.onDetach() + } + + override fun onDestroy() { + log(tag, VERBOSE) { "onDestroy()" } + super.onDestroy() + } + + override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) { + log(tag, VERBOSE) { "onActivityResult(requestCode=$requestCode, resultCode=$resultCode, data=$data)" } + super.onActivityResult(requestCode, resultCode, data) + } + +} diff --git a/app/src/main/java/eu/darken/cap/common/smart/SmartService.kt b/app/src/main/java/eu/darken/cap/common/smart/SmartService.kt new file mode 100644 index 00000000..a8645012 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/smart/SmartService.kt @@ -0,0 +1,52 @@ +package eu.darken.cap.common.smart + +import android.app.Service +import android.content.Intent +import android.content.res.Configuration +import eu.darken.cap.common.debug.logging.log +import eu.darken.cap.common.debug.logging.logTag + +abstract class SmartService : Service() { + private val tag: String = + logTag("Service", this.javaClass.simpleName + "(" + Integer.toHexString(this.hashCode()) + ")") + + override fun onCreate() { + log(tag) { "onCreate()" } + super.onCreate() + } + + override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int { + log(tag) { "onStartCommand(intent=$intent, flags=$flags startId=$startId)" } + return super.onStartCommand(intent, flags, startId) + } + + override fun onDestroy() { + log(tag) { "onDestroy()" } + super.onDestroy() + } + + override fun onConfigurationChanged(newConfig: Configuration) { + log(tag) { "onConfigurationChanged(newConfig=$newConfig)" } + super.onConfigurationChanged(newConfig) + } + + override fun onLowMemory() { + log(tag) { "onLowMemory()" } + super.onLowMemory() + } + + override fun onUnbind(intent: Intent): Boolean { + log(tag) { "onUnbind(intent=$intent)" } + return super.onUnbind(intent) + } + + override fun onRebind(intent: Intent) { + log(tag) { "onRebind(intent=$intent)" } + super.onRebind(intent) + } + + override fun onTaskRemoved(rootIntent: Intent) { + log(tag) { "onTaskRemoved(rootIntent=$rootIntent)" } + super.onTaskRemoved(rootIntent) + } +} diff --git a/app/src/main/java/eu/darken/cap/common/smart/SmartVM.kt b/app/src/main/java/eu/darken/cap/common/smart/SmartVM.kt new file mode 100644 index 00000000..2f8afeb0 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/smart/SmartVM.kt @@ -0,0 +1,64 @@ +package eu.darken.cap.common.smart + +import androidx.lifecycle.asLiveData +import androidx.lifecycle.viewModelScope +import eu.darken.cap.common.coroutine.DefaultDispatcherProvider +import eu.darken.cap.common.coroutine.DispatcherProvider +import eu.darken.cap.common.debug.logging.Logging.Priority.WARN +import eu.darken.cap.common.debug.logging.asLog +import eu.darken.cap.common.debug.logging.log +import eu.darken.cap.common.error.ErrorEventSource +import eu.darken.cap.common.flow.DynamicStateFlow +import eu.darken.cap.common.viewmodel.VM +import kotlinx.coroutines.* +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.launchIn +import kotlin.coroutines.CoroutineContext + + +abstract class SmartVM( + private val dispatcherProvider: DispatcherProvider = DefaultDispatcherProvider(), +) : VM() { + + val vmScope = viewModelScope + dispatcherProvider.Default + + var launchErrorHandler: CoroutineExceptionHandler? = null + + private fun getVDCContext(): CoroutineContext { + val dispatcher = dispatcherProvider.Default + return getErrorHandler()?.let { dispatcher + it } ?: dispatcher + } + + private fun getErrorHandler(): CoroutineExceptionHandler? { + val handler = launchErrorHandler + if (handler != null) return handler + + if (this is ErrorEventSource) { + return CoroutineExceptionHandler { _, ex -> + log(WARN) { "Error during launch: ${ex.asLog()}" } + errorEvents.postValue(ex) + } + } + + return null + } + + fun DynamicStateFlow.asLiveData2() = flow.asLiveData2() + + fun Flow.asLiveData2() = this.asLiveData(context = getVDCContext()) + + fun launch( + scope: CoroutineScope = viewModelScope, + context: CoroutineContext = getVDCContext(), + block: suspend CoroutineScope.() -> Unit + ) { + try { + scope.launch(context = context, block = block) + } catch (e: CancellationException) { + log(TAG, WARN) { "launch()ed coroutine was canceled (scope=$scope): ${e.asLog()}" } + } + } + + open fun Flow.launchInViewModel() = this.launchIn(vmScope) + +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/viewbinding/ViewBindingExtensions.kt b/app/src/main/java/eu/darken/cap/common/viewbinding/ViewBindingExtensions.kt new file mode 100644 index 00000000..a2ace067 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/viewbinding/ViewBindingExtensions.kt @@ -0,0 +1,93 @@ +package eu.darken.cap.common.viewbinding + +import android.os.Handler +import android.os.Looper +import android.view.View +import androidx.annotation.MainThread +import androidx.fragment.app.Fragment +import androidx.lifecycle.DefaultLifecycleObserver +import androidx.lifecycle.LifecycleOwner +import androidx.viewbinding.ViewBinding +import eu.darken.cap.common.debug.logging.Logging.Priority.* +import eu.darken.cap.common.debug.logging.log +import kotlin.properties.ReadOnlyProperty +import kotlin.reflect.KProperty + +inline fun FragmentT.viewBinding() = + this.viewBinding( + bindingProvider = { + val bindingMethod = BindingT::class.java.getMethod("bind", View::class.java) + bindingMethod(null, requireView()) as BindingT + }, + lifecycleOwnerProvider = { viewLifecycleOwner } + ) + +@Suppress("unused") +fun FragmentT.viewBinding( + bindingProvider: FragmentT.() -> BindingT, + lifecycleOwnerProvider: FragmentT.() -> LifecycleOwner +) = ViewBindingProperty(bindingProvider, lifecycleOwnerProvider) + +class ViewBindingProperty( + private val bindingProvider: (ComponentT) -> BindingT, + private val lifecycleOwnerProvider: ComponentT.() -> LifecycleOwner +) : ReadOnlyProperty { + + private val uiHandler = Handler(Looper.getMainLooper()) + private var localRef: ComponentT? = null + private var viewBinding: BindingT? = null + + private val onDestroyObserver = object : DefaultLifecycleObserver { + // Called right before Fragment.onDestroyView + override fun onDestroy(owner: LifecycleOwner) { + localRef?.lifecycle?.removeObserver(this) ?: return + + localRef = null + + uiHandler.post { + log(VERBOSE) { "Resetting viewBinding" } + viewBinding = null + } + } + } + + @MainThread + override fun getValue(thisRef: ComponentT, property: KProperty<*>): BindingT { + if (localRef == null && viewBinding != null) { + log(WARN) { "Fragment.onDestroyView() was called, but the handler didn't execute our delayed reset." } + /** + * There is a fragment racecondition if you navigate to another fragment and quickly popBackStack(). + * Our uiHandler.post { } will not have executed for some reason. + * In that case we manually null the old viewBinding, to allow for clean recreation. + */ + viewBinding = null + } + + /** + * When quickly navigating, a fragment may be created that was never visible to the user. + * It's possible that [Fragment.onDestroyView] is called, but [DefaultLifecycleObserver.onDestroy] is not. + * This means the ViewBinding will is not be set to `null` and it still holds the previous layout, + * instead of the new layout that the Fragment inflated when navigating back to it. + */ + (localRef as? Fragment)?.view?.let { + if (it != viewBinding?.root && localRef === thisRef) { + log(WARN) { "Different view for the same fragment, resetting old viewBinding." } + viewBinding = null + } + } + + viewBinding?.let { + // Only accessible from within the same component + require(localRef === thisRef) + return@getValue it + } + + val lifecycle = lifecycleOwnerProvider(thisRef).lifecycle + + return bindingProvider(thisRef).also { + viewBinding = it + localRef = thisRef + lifecycle.addObserver(onDestroyObserver) + } + } +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/viewmodel/SmartVM.kt b/app/src/main/java/eu/darken/cap/common/viewmodel/SmartVM.kt new file mode 100644 index 00000000..2fc1154a --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/viewmodel/SmartVM.kt @@ -0,0 +1,15 @@ +package eu.darken.cap.common.viewmodel + +import androidx.lifecycle.asLiveData +import eu.darken.cap.common.coroutine.DefaultDispatcherProvider +import eu.darken.cap.common.coroutine.DispatcherProvider +import kotlinx.coroutines.flow.Flow + + +abstract class SmartVM( + private val dispatcherProvider: DispatcherProvider = DefaultDispatcherProvider(), +) : VM() { + + fun Flow.asLiveData2() = this.asLiveData(context = dispatcherProvider.Default) + +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/viewmodel/VM.kt b/app/src/main/java/eu/darken/cap/common/viewmodel/VM.kt new file mode 100644 index 00000000..542a73f0 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/viewmodel/VM.kt @@ -0,0 +1,20 @@ +package eu.darken.cap.common.viewmodel + +import androidx.annotation.CallSuper +import androidx.lifecycle.ViewModel +import eu.darken.cap.common.debug.logging.log +import eu.darken.cap.common.debug.logging.logTag + +abstract class VM : ViewModel() { + val TAG: String = logTag("VM", javaClass.simpleName) + + init { + log(TAG) { "Initialized" } + } + + @CallSuper + override fun onCleared() { + log(TAG) { "onCleared()" } + super.onCleared() + } +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/common/viewmodel/ViewModelLazyKeyed.kt b/app/src/main/java/eu/darken/cap/common/viewmodel/ViewModelLazyKeyed.kt new file mode 100644 index 00000000..bf9cd15e --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/viewmodel/ViewModelLazyKeyed.kt @@ -0,0 +1,174 @@ +package eu.darken.cap.common.viewmodel + +/* + * Copyright 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +import androidx.activity.ComponentActivity +import androidx.annotation.MainThread +import androidx.fragment.app.Fragment +import androidx.lifecycle.* +import kotlin.reflect.KClass + +/** + * Returns an existing ViewModel or creates a new one in the scope (usually, a fragment or + * an activity), associated with this `ViewModelProvider`. + * + * @see ViewModelProvider.get(Class) + */ +//@MainThread +//inline fun ViewModelProvider.get() = get(VM::class.java) + +/** + * An implementation of [Lazy] used by [androidx.fragment.app.Fragment.viewModels] and + * [androidx.activity.ComponentActivity.viewmodels]. + * + * [storeProducer] is a lambda that will be called during initialization, [VM] will be created + * in the scope of returned [ViewModelStore]. + * + * [factoryProducer] is a lambda that will be called during initialization, + * returned [ViewModelProvider.Factory] will be used for creation of [VM] + */ +class ViewModelLazyKeyed( + private val viewModelClass: KClass, + private val keyProducer: (() -> String)? = null, + private val storeProducer: () -> ViewModelStore, + private val factoryProducer: () -> ViewModelProvider.Factory +) : Lazy { + private var cached: VM? = null + + override val value: VM + get() { + val viewModel = cached + return if (viewModel == null) { + val factory = factoryProducer() + val store = storeProducer() + val key = keyProducer?.invoke() ?: "androidx.lifecycle.ViewModelProvider.DefaultKey" + ViewModelProvider(store, factory).get( + key + ":" + viewModelClass.java.canonicalName, + viewModelClass.java + ).also { + cached = it + } + } else { + viewModel + } + } + + override fun isInitialized() = cached != null +} + +/** + * Returns a property delegate to access [ViewModel] by **default** scoped to this [Fragment]: + * ``` + * class MyFragment : Fragment() { + * val viewmodel: NYViewModel by viewmodels() + * } + * ``` + * + * Custom [ViewModelProvider.Factory] can be defined via [factoryProducer] parameter, + * factory returned by it will be used to create [ViewModel]: + * ``` + * class MyFragment : Fragment() { + * val viewmodel: MYViewModel by viewmodels { myFactory } + * } + * ``` + * + * Default scope may be overridden with parameter [ownerProducer]: + * ``` + * class MyFragment : Fragment() { + * val viewmodel: MYViewModel by viewmodels ({requireParentFragment()}) + * } + * ``` + * + * This property can be accessed only after this Fragment is attached i.e., after + * [Fragment.onAttach()], and access prior to that will result in IllegalArgumentException. + */ +@MainThread +inline fun Fragment.viewModelsKeyed( + noinline keyProducer: (() -> String)? = null, + noinline ownerProducer: () -> ViewModelStoreOwner = { this }, + noinline factoryProducer: (() -> ViewModelProvider.Factory)? = null +) = createViewModelLazyKeyed(VM::class, keyProducer, { ownerProducer().viewModelStore }, factoryProducer) + +/** + * Returns a property delegate to access parent activity's [ViewModel], + * if [factoryProducer] is specified then [ViewModelProvider.Factory] + * returned by it will be used to create [ViewModel] first time. + * + * ``` + * class MyFragment : Fragment() { + * val viewmodel: MyViewModel by activityViewModels() + * } + * ``` + * + * This property can be accessed only after this Fragment is attached i.e., after + * [Fragment.onAttach()], and access prior to that will result in IllegalArgumentException. + */ +@MainThread +inline fun Fragment.activityViewModelsKeyed( + noinline keyProducer: (() -> String)? = null, + noinline factoryProducer: (() -> ViewModelProvider.Factory)? = null +) = createViewModelLazyKeyed(VM::class, keyProducer, { requireActivity().viewModelStore }, factoryProducer) + +/** + * Helper method for creation of [ViewModelLazy], that resolves `null` passed as [factoryProducer] + * to default factory. + */ +@MainThread +fun Fragment.createViewModelLazyKeyed( + viewModelClass: KClass, + keyProducer: (() -> String)? = null, + storeProducer: () -> ViewModelStore, + factoryProducer: (() -> ViewModelProvider.Factory)? = null +): Lazy { + val factoryPromise = factoryProducer ?: { + val application = activity?.application ?: throw IllegalStateException( + "ViewModel can be accessed only when Fragment is attached" + ) + ViewModelProvider.AndroidViewModelFactory.getInstance(application) + } + return ViewModelLazyKeyed(viewModelClass, keyProducer, storeProducer, factoryPromise) +} + +/** + * Returns a [Lazy] delegate to access the ComponentActivity's ViewModel, if [factoryProducer] + * is specified then [ViewModelProvider.Factory] returned by it will be used + * to create [ViewModel] first time. + * + * ``` + * class MyComponentActivity : ComponentActivity() { + * val viewmodel: MyViewModel by viewmodels() + * } + * ``` + * + * This property can be accessed only after the Activity is attached to the Application, + * and access prior to that will result in IllegalArgumentException. + */ +@MainThread +inline fun ComponentActivity.viewModelsKeyed( + noinline keyProducer: (() -> String)? = null, + noinline factoryProducer: (() -> ViewModelProvider.Factory)? = null +): Lazy { + val factoryPromise = factoryProducer ?: { + val application = application ?: throw IllegalArgumentException( + "ViewModel can be accessed only when Activity is attached" + ) + ViewModelProvider.AndroidViewModelFactory.getInstance(application) + } + + return ViewModelLazyKeyed(VM::class, keyProducer, { viewModelStore }, factoryPromise) +} diff --git a/app/src/main/java/eu/darken/cap/common/worker/WorkerExtensions.kt b/app/src/main/java/eu/darken/cap/common/worker/WorkerExtensions.kt new file mode 100644 index 00000000..b9c3d7bb --- /dev/null +++ b/app/src/main/java/eu/darken/cap/common/worker/WorkerExtensions.kt @@ -0,0 +1,31 @@ +package eu.darken.cap.common.worker + +import android.os.Parcel +import android.os.Parcelable +import androidx.work.Data + +@Suppress("UNCHECKED_CAST") +inline fun Data.getParcelable(key: String): T? { + val parcel = Parcel.obtain() + try { + val bytes = getByteArray(key) ?: return null + parcel.unmarshall(bytes, 0, bytes.size) + parcel.setDataPosition(0) + val creator = T::class.java.getField("CREATOR").get(null) as Parcelable.Creator + return creator.createFromParcel(parcel) + } finally { + parcel.recycle() + } +} + + +fun Data.Builder.putParcelable(key: String, parcelable: Parcelable): Data.Builder { + val parcel = Parcel.obtain() + try { + parcelable.writeToParcel(parcel, 0) + putByteArray(key, parcel.marshall()) + } finally { + parcel.recycle() + } + return this +} diff --git a/app/src/main/java/eu/darken/cap/main/ui/MainActivity.kt b/app/src/main/java/eu/darken/cap/main/ui/MainActivity.kt new file mode 100644 index 00000000..343f3c9e --- /dev/null +++ b/app/src/main/java/eu/darken/cap/main/ui/MainActivity.kt @@ -0,0 +1,24 @@ +package eu.darken.cap.main.ui + +import android.os.Bundle +import androidx.activity.viewModels +import dagger.hilt.android.AndroidEntryPoint +import eu.darken.cap.R +import eu.darken.cap.common.navigation.findNavController +import eu.darken.cap.common.smart.SmartActivity +import eu.darken.cap.databinding.MainActivityBinding + +@AndroidEntryPoint +class MainActivity : SmartActivity() { + + private val vm: MainActivityVM by viewModels() + private lateinit var ui: MainActivityBinding + private val navController by lazy { supportFragmentManager.findNavController(R.id.nav_host) } + + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + + ui = MainActivityBinding.inflate(layoutInflater) + setContentView(ui.root) + } +} diff --git a/app/src/main/java/eu/darken/cap/main/ui/MainActivityVM.kt b/app/src/main/java/eu/darken/cap/main/ui/MainActivityVM.kt new file mode 100644 index 00000000..c0e53dab --- /dev/null +++ b/app/src/main/java/eu/darken/cap/main/ui/MainActivityVM.kt @@ -0,0 +1,16 @@ +package eu.darken.cap.main.ui + +import androidx.lifecycle.SavedStateHandle +import dagger.hilt.android.lifecycle.HiltViewModel +import eu.darken.cap.common.coroutine.DispatcherProvider +import eu.darken.cap.common.viewmodel.SmartVM +import javax.inject.Inject + + +@HiltViewModel +class MainActivityVM @Inject constructor( + handle: SavedStateHandle, + dispatcherProvider: DispatcherProvider, +) : SmartVM(dispatcherProvider = dispatcherProvider) { + +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/main/ui/MainAdapter.kt b/app/src/main/java/eu/darken/cap/main/ui/MainAdapter.kt new file mode 100644 index 00000000..4dba51bb --- /dev/null +++ b/app/src/main/java/eu/darken/cap/main/ui/MainAdapter.kt @@ -0,0 +1,39 @@ +package eu.darken.cap.main.ui + +import android.view.ViewGroup +import androidx.annotation.LayoutRes +import androidx.viewbinding.ViewBinding +import eu.darken.cap.common.lists.BindableVH +import eu.darken.cap.common.lists.differ.AsyncDiffer +import eu.darken.cap.common.lists.differ.DifferItem +import eu.darken.cap.common.lists.differ.HasAsyncDiffer +import eu.darken.cap.common.lists.differ.setupDiffer +import eu.darken.cap.common.lists.modular.ModularAdapter +import eu.darken.cap.common.lists.modular.mods.DataBinderMod +import eu.darken.cap.common.lists.modular.mods.TypedVHCreatorMod +import eu.darken.cap.main.ui.cards.PermissionCardVH +import eu.darken.cap.main.ui.cards.ToggleCardVH +import javax.inject.Inject + +class MainAdapter @Inject constructor() : + ModularAdapter>(), + HasAsyncDiffer { + + override val asyncDiffer: AsyncDiffer<*, Item> = setupDiffer() + + init { + modules.add(DataBinderMod(data)) + modules.add(TypedVHCreatorMod({ data[it] is ToggleCardVH.Item }) { ToggleCardVH(it) }) + modules.add(TypedVHCreatorMod({ data[it] is PermissionCardVH.Item }) { PermissionCardVH(it) }) + } + + override fun getItemCount(): Int = data.size + + abstract class BaseVH( + @LayoutRes layoutId: Int, + parent: ViewGroup + ) : ModularAdapter.VH(layoutId, parent), BindableVH + + interface Item : DifferItem + +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/main/ui/MainFragment.kt b/app/src/main/java/eu/darken/cap/main/ui/MainFragment.kt new file mode 100644 index 00000000..fbdc461d --- /dev/null +++ b/app/src/main/java/eu/darken/cap/main/ui/MainFragment.kt @@ -0,0 +1,56 @@ +package eu.darken.cap.main.ui + +import android.os.Bundle +import android.view.View +import androidx.activity.result.ActivityResultLauncher +import androidx.activity.result.contract.ActivityResultContracts +import androidx.fragment.app.viewModels +import dagger.hilt.android.AndroidEntryPoint +import eu.darken.cap.R +import eu.darken.cap.common.BuildConfigWrap +import eu.darken.cap.common.debug.logging.log +import eu.darken.cap.common.lists.differ.update +import eu.darken.cap.common.lists.setupDefaults +import eu.darken.cap.common.smart.Smart2Fragment +import eu.darken.cap.common.viewbinding.viewBinding +import eu.darken.cap.databinding.MainFragmentBinding +import javax.inject.Inject + +@AndroidEntryPoint +class MainFragment : Smart2Fragment(R.layout.main_fragment) { + + override val vm: MainFragmentVM by viewModels() + override val ui: MainFragmentBinding by viewBinding() + + @Inject + lateinit var adapter: MainAdapter + + lateinit var permissionLauncher: ActivityResultLauncher + + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + + permissionLauncher = registerForActivityResult(ActivityResultContracts.RequestPermission()) { granted -> + log { "Request for $id was granted=$granted" } + vm.onPermissionResult(granted) + } + } + + override fun onViewCreated(view: View, savedInstanceState: Bundle?) { + + ui.apply { + list.setupDefaults(adapter) + toolbar.subtitle = + "v${BuildConfigWrap.VERSION_NAME} (${BuildConfigWrap.VERSION_CODE}) [${BuildConfigWrap.GIT_SHA}]" + } + + vm.listItems.observe2(ui) { + adapter.update(it) + } + + vm.requestPermissionevent.observe2(ui) { + permissionLauncher.launch(it.permissionId) + } + super.onViewCreated(view, savedInstanceState) + } +} diff --git a/app/src/main/java/eu/darken/cap/main/ui/MainFragmentVM.kt b/app/src/main/java/eu/darken/cap/main/ui/MainFragmentVM.kt new file mode 100644 index 00000000..f3d7fcd6 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/main/ui/MainFragmentVM.kt @@ -0,0 +1,68 @@ +package eu.darken.cap.main.ui + +import android.content.Context +import androidx.lifecycle.LiveData +import androidx.lifecycle.SavedStateHandle +import dagger.hilt.android.lifecycle.HiltViewModel +import dagger.hilt.android.qualifiers.ApplicationContext +import eu.darken.cap.common.coroutine.DispatcherProvider +import eu.darken.cap.common.hasApiLevel +import eu.darken.cap.common.livedata.SingleLiveEvent +import eu.darken.cap.common.permissions.Permission +import eu.darken.cap.common.permissions.isGranted +import eu.darken.cap.common.smart.Smart2VM +import eu.darken.cap.main.ui.cards.PermissionCardVH +import eu.darken.cap.main.ui.cards.ToggleCardVH +import kotlinx.coroutines.flow.* +import java.util.* +import javax.inject.Inject + +@HiltViewModel +class MainFragmentVM @Inject constructor( + handle: SavedStateHandle, + @ApplicationContext private val context: Context, + dispatcherProvider: DispatcherProvider, +) : Smart2VM(dispatcherProvider = dispatcherProvider) { + + + private val enabledState: Flow = flow { + emit(false) + } + + private val permissionCheckTrigger = MutableStateFlow(UUID.randomUUID()) + private val requiredPermissions: Flow> = permissionCheckTrigger.map { + Permission.values() + .filter { hasApiLevel(it.minApiLevel) && !it.isGranted(context) } + } + + val requestPermissionevent = SingleLiveEvent() + + val listItems: LiveData> = combine( + enabledState, + requiredPermissions + ) { state, permissions -> + val items = mutableListOf() + ToggleCardVH.Item( + isEnabled = state, + onToggle = { + + } + ).run { items.add(this) } + + permissions + .map { + PermissionCardVH.Item( + permission = it, + onRequest = { requestPermissionevent.postValue(it) } + ) + } + .forEach { items.add(it) } + + items + }.asLiveData2() + + fun onPermissionResult(granted: Boolean) { + if (granted) permissionCheckTrigger.value = UUID.randomUUID() + } + +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/main/ui/cards/PermissionCardVH.kt b/app/src/main/java/eu/darken/cap/main/ui/cards/PermissionCardVH.kt new file mode 100644 index 00000000..3c6bc9d2 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/main/ui/cards/PermissionCardVH.kt @@ -0,0 +1,34 @@ +package eu.darken.cap.main.ui.cards + +import android.view.ViewGroup +import eu.darken.cap.R +import eu.darken.cap.common.permissions.Permission +import eu.darken.cap.databinding.MainPermissionItemBinding +import eu.darken.cap.main.ui.MainAdapter + +class PermissionCardVH(parent: ViewGroup) : + MainAdapter.BaseVH( + R.layout.main_permission_item, + parent + ) { + + override val viewBinding = lazy { + MainPermissionItemBinding.bind(itemView) + } + + override val onBindData: MainPermissionItemBinding.( + item: Item, + payloads: List + ) -> Unit = { item, _ -> + permissionLabel.setText(item.permission.labelRes) + permissionDescription.setText(item.permission.descriptionRes) + grantAction.setOnClickListener { item.onRequest(item.permission) } + } + + data class Item( + val permission: Permission, + val onRequest: (Permission) -> Unit + ) : MainAdapter.Item { + override val stableId: Long = this.javaClass.hashCode().toLong() + } +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/main/ui/cards/ToggleCardVH.kt b/app/src/main/java/eu/darken/cap/main/ui/cards/ToggleCardVH.kt new file mode 100644 index 00000000..66113277 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/main/ui/cards/ToggleCardVH.kt @@ -0,0 +1,35 @@ +package eu.darken.cap.main.ui.cards + +import android.view.ViewGroup +import eu.darken.cap.R +import eu.darken.cap.databinding.MainToggleItemBinding +import eu.darken.cap.main.ui.MainAdapter + +class ToggleCardVH(parent: ViewGroup) : + MainAdapter.BaseVH( + R.layout.main_toggle_item, + parent + ) { + + override val viewBinding = lazy { + MainToggleItemBinding.bind(itemView) + } + + override val onBindData: MainToggleItemBinding.( + item: Item, + payloads: List + ) -> Unit = { item, _ -> + toggleAction.text = when (item.isEnabled) { + true -> "Disable" + false -> "Enable" + } + itemView.setOnClickListener { item.onToggle() } + } + + data class Item( + val isEnabled: Boolean, + val onToggle: () -> Unit + ) : MainAdapter.Item { + override val stableId: Long = this.javaClass.hashCode().toLong() + } +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/monitor/core/MonitorComponent.kt b/app/src/main/java/eu/darken/cap/monitor/core/MonitorComponent.kt new file mode 100644 index 00000000..506e9716 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/monitor/core/MonitorComponent.kt @@ -0,0 +1,18 @@ +package eu.darken.cap.monitor.core + +import dagger.BindsInstance +import dagger.hilt.DefineComponent +import dagger.hilt.components.SingletonComponent + +@MonitorScope +@DefineComponent(parent = SingletonComponent::class) +interface MonitorComponent { + + @DefineComponent.Builder + interface Builder { + + fun coroutineScope(@BindsInstance coroutineScope: MonitorCoroutineScope): Builder + + fun build(): MonitorComponent + } +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/monitor/core/MonitorCoroutineScope.kt b/app/src/main/java/eu/darken/cap/monitor/core/MonitorCoroutineScope.kt new file mode 100644 index 00000000..f69445b5 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/monitor/core/MonitorCoroutineScope.kt @@ -0,0 +1,11 @@ +package eu.darken.cap.monitor.core + +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.SupervisorJob +import kotlin.coroutines.CoroutineContext + +class MonitorCoroutineScope : CoroutineScope { + override val coroutineContext: CoroutineContext = SupervisorJob() + Dispatchers.Default +} + diff --git a/app/src/main/java/eu/darken/cap/monitor/core/MonitorModule.kt b/app/src/main/java/eu/darken/cap/monitor/core/MonitorModule.kt new file mode 100644 index 00000000..282904f2 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/monitor/core/MonitorModule.kt @@ -0,0 +1,16 @@ +package eu.darken.cap.monitor.core + +import dagger.Binds +import dagger.Module +import dagger.hilt.InstallIn +import kotlinx.coroutines.CoroutineScope + +@InstallIn(MonitorComponent::class) +@Module() +abstract class ProcessorModule { + + @Binds + @MonitorScope + abstract fun processorScope(scope: MonitorCoroutineScope): CoroutineScope + +} diff --git a/app/src/main/java/eu/darken/cap/monitor/core/MonitorScope.kt b/app/src/main/java/eu/darken/cap/monitor/core/MonitorScope.kt new file mode 100644 index 00000000..f7043450 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/monitor/core/MonitorScope.kt @@ -0,0 +1,8 @@ +package eu.darken.cap.monitor.core + +import javax.inject.Qualifier + +@Qualifier +@MustBeDocumented +@Retention(AnnotationRetention.RUNTIME) +annotation class MonitorScope \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/monitor/core/PodMonitor.kt b/app/src/main/java/eu/darken/cap/monitor/core/PodMonitor.kt new file mode 100644 index 00000000..286c38e6 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/monitor/core/PodMonitor.kt @@ -0,0 +1,30 @@ +package eu.darken.cap.monitor.core + +import eu.darken.cap.common.bluetooth.BleScanner +import eu.darken.cap.common.debug.logging.logTag +import eu.darken.cap.pods.core.PodDevice +import eu.darken.cap.pods.core.PodFactory +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.map +import kotlinx.coroutines.flow.onStart +import javax.inject.Inject +import javax.inject.Singleton + +@Singleton +class PodMonitor @Inject constructor( + private val bleScanner: BleScanner, + private val podFactory: PodFactory, +) { + + val pods: Flow> = bleScanner.scan() + .onStart { emptyList() } + .map { scanResults -> + scanResults.mapNotNull { scanResult -> + podFactory.createPod(scanResult) + } + } + + companion object { + private val TAG = logTag("Monitor", "PodMonitor") + } +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/monitor/core/receiver/BluetoothEventReceiver.kt b/app/src/main/java/eu/darken/cap/monitor/core/receiver/BluetoothEventReceiver.kt new file mode 100644 index 00000000..8762eb34 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/monitor/core/receiver/BluetoothEventReceiver.kt @@ -0,0 +1,67 @@ +package eu.darken.cap.monitor.core.receiver + +import android.bluetooth.BluetoothA2dp +import android.bluetooth.BluetoothDevice +import android.bluetooth.BluetoothHeadset +import android.content.BroadcastReceiver +import android.content.Context +import android.content.Intent +import dagger.hilt.android.AndroidEntryPoint +import eu.darken.cap.common.bluetooth.hasFeature +import eu.darken.cap.common.coroutine.AppScope +import eu.darken.cap.common.debug.logging.Logging.Priority.WARN +import eu.darken.cap.common.debug.logging.log +import eu.darken.cap.common.debug.logging.logTag +import eu.darken.cap.monitor.core.worker.MonitorControl +import eu.darken.cap.pods.core.airpods.ContinuityProtocol +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.launch +import javax.inject.Inject + +@AndroidEntryPoint +class BluetoothEventReceiver : BroadcastReceiver() { + + @Inject lateinit var monitorControl: MonitorControl + @Inject @AppScope lateinit var appScope: CoroutineScope + + override fun onReceive(context: Context, intent: Intent) { + log { "onReceive($context, $intent)" } + if (!EXPECTED_ACTIONS.contains(intent.action)) { + log(WARN) { "Unknown action: $intent.action" } + return + } + + val bluetoothDevice = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE) + if (bluetoothDevice == null) { + log(TAG, WARN) { "Event without Bluetooth device association." } + return + } else { + log { "Event related to $bluetoothDevice" } + } + val supportedFeatures = ContinuityProtocol.BLE_FEATURE_UUIDS.filter { bluetoothDevice.hasFeature(it) } + + if (supportedFeatures.isEmpty()) { + log { "Device has no features we support." } + return + } else { + log { "Device has the following we features we support $supportedFeatures" } + } + + val pending = goAsync() + appScope.launch { + log { "Starting monitor" } + monitorControl.startMonitor(bluetoothDevice, forceStart = false) + pending.finish() + } + } + + companion object { + private val TAG = logTag("Monitor", "EventReceiver") + private val EXPECTED_ACTIONS = setOf( + BluetoothDevice.ACTION_ACL_CONNECTED, + BluetoothDevice.ACTION_ACL_DISCONNECTED, + BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED, + BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED + ) + } +} diff --git a/app/src/main/java/eu/darken/cap/monitor/core/worker/MonitorControl.kt b/app/src/main/java/eu/darken/cap/monitor/core/worker/MonitorControl.kt new file mode 100644 index 00000000..12fc13a4 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/monitor/core/worker/MonitorControl.kt @@ -0,0 +1,51 @@ +package eu.darken.cap.monitor.core.worker + +import android.bluetooth.BluetoothDevice +import androidx.work.Data +import androidx.work.ExistingWorkPolicy +import androidx.work.OneTimeWorkRequestBuilder +import androidx.work.WorkManager +import eu.darken.cap.common.BuildConfigWrap +import eu.darken.cap.common.coroutine.DispatcherProvider +import eu.darken.cap.common.debug.logging.Logging.Priority.VERBOSE +import eu.darken.cap.common.debug.logging.log +import eu.darken.cap.common.debug.logging.logTag +import kotlinx.coroutines.withContext +import javax.inject.Inject +import javax.inject.Singleton + +@Singleton +class MonitorControl @Inject constructor( + private val workerManager: WorkManager, + private val dispatcherProvider: DispatcherProvider, +) { + + suspend fun startMonitor( + bluetoothDevice: BluetoothDevice? = null, + forceStart: Boolean + ): Unit = withContext(dispatcherProvider.IO) { + val workerData = Data.Builder().apply { + + }.build() + log(TAG, VERBOSE) { "Worker data: $workerData" } + + val workRequest = OneTimeWorkRequestBuilder().apply { + setInputData(workerData) + }.build() + + log(TAG, VERBOSE) { "Worker request: $workRequest" } + + val operation = workerManager.enqueueUniqueWork( + "${BuildConfigWrap.APPLICATION_ID}.monitor.worker", + if (forceStart) ExistingWorkPolicy.REPLACE else ExistingWorkPolicy.KEEP, + workRequest, + ) + + operation.result.get() + log(TAG) { "Monitor start request send." } + } + + companion object { + private val TAG = logTag("Monitor", "Control") + } +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/monitor/core/worker/MonitorWorker.kt b/app/src/main/java/eu/darken/cap/monitor/core/worker/MonitorWorker.kt new file mode 100644 index 00000000..52fb0cd2 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/monitor/core/worker/MonitorWorker.kt @@ -0,0 +1,121 @@ +package eu.darken.cap.monitor.core.worker + +import android.app.NotificationManager +import android.content.Context +import androidx.hilt.work.HiltWorker +import androidx.work.CoroutineWorker +import androidx.work.WorkerParameters +import dagger.assisted.Assisted +import dagger.assisted.AssistedInject +import dagger.hilt.EntryPoints +import eu.darken.cap.common.debug.logging.Logging.Priority.ERROR +import eu.darken.cap.common.debug.logging.Logging.Priority.VERBOSE +import eu.darken.cap.common.debug.logging.asLog +import eu.darken.cap.common.debug.logging.log +import eu.darken.cap.common.debug.logging.logTag +import eu.darken.cap.common.flow.setupCommonEventHandlers +import eu.darken.cap.monitor.core.MonitorComponent +import eu.darken.cap.monitor.core.MonitorCoroutineScope +import eu.darken.cap.monitor.ui.MonitorNotifications +import eu.darken.cap.pods.core.airpods.ContinuityProtocol +import kotlinx.coroutines.cancel +import kotlinx.coroutines.delay +import kotlinx.coroutines.flow.* + + +@HiltWorker +class MonitorWorker @AssistedInject constructor( + @Assisted private val context: Context, + @Assisted private val params: WorkerParameters, + monitorComponentBuilder: MonitorComponent.Builder, + private val monitorNotifications: MonitorNotifications, + private val notificationManager: NotificationManager, +) : CoroutineWorker(context, params) { + + private val workerScope = MonitorCoroutineScope() + private val monitorComponent = monitorComponentBuilder + .coroutineScope(workerScope) + .build() + + private val entryPoint by lazy { + EntryPoints.get(monitorComponent, MonitorWorkerEntryPoint::class.java) + } + + private val podMonitor by lazy { + entryPoint.podMonitor() + } + private val bluetoothManager2 by lazy { + entryPoint.bluetoothManager2() + } + private var finishedWithError = false + + init { + log(TAG, VERBOSE) { "init(): workerId=$id" } + } + + override suspend fun doWork(): Result = try { + val start = System.currentTimeMillis() + log(TAG, VERBOSE) { "Executing $inputData now (runAttemptCount=$runAttemptCount)" } + + bluetoothManager2 + .isBluetoothEnabled + .flatMapLatest { bluetoothManager2.connectedDevices() } + .map { devices -> + devices.any { device -> + ContinuityProtocol.BLE_FEATURE_UUIDS.any { feature -> + device.hasFeature(feature) + } + } + } + .setupCommonEventHandlers(TAG) { "ConnectedDevices" } + .flatMapLatest { arePodsConnected -> + flow { + if (arePodsConnected) { + log(TAG) { "Pods are connected, aborting any timeout." } + } else { + log(TAG) { "No Pods are connected, canceling worker soon." } + delay(60 * 1000) + log(TAG) { "Canceling worker now, still no Pods connected." } + // FIXME +// workerScope.coroutineContext.cancelChildren() + } + } + } + .launchIn(workerScope) + + + val monitorJob = podMonitor.pods + .setupCommonEventHandlers(TAG) { "PodMonitor" } + .onStart { + setForeground(monitorNotifications.getForegroundInfo(null)) + } + .onEach { + notificationManager.notify( + MonitorNotifications.NOTIFICATION_ID, + monitorNotifications.getNotification(it.firstOrNull()) + ) + } + .launchIn(workerScope) + + log(TAG, VERBOSE) { "monitor job is active" } + monitorJob.join() + log(TAG, VERBOSE) { "monitor job quit" } + + val duration = System.currentTimeMillis() - start + + log(TAG, VERBOSE) { "Execution finished after ${duration}ms, $inputData" } + + Result.success(inputData) + } catch (e: Throwable) { + log(TAG, ERROR) { "Execution failed:\n${e.asLog()}" } + finishedWithError = true + // TODO update result? + Result.failure(inputData) + } finally { + this.workerScope.cancel("Worker finished (withError?=$finishedWithError).") + } + + companion object { + val TAG = logTag("Monitor", "Worker") + } +} diff --git a/app/src/main/java/eu/darken/cap/monitor/core/worker/MonitorWorkerEntryPoint.kt b/app/src/main/java/eu/darken/cap/monitor/core/worker/MonitorWorkerEntryPoint.kt new file mode 100644 index 00000000..1343e89c --- /dev/null +++ b/app/src/main/java/eu/darken/cap/monitor/core/worker/MonitorWorkerEntryPoint.kt @@ -0,0 +1,14 @@ +package eu.darken.cap.monitor.core.worker + +import dagger.hilt.EntryPoint +import dagger.hilt.InstallIn +import eu.darken.cap.common.bluetooth.BluetoothManager2 +import eu.darken.cap.monitor.core.MonitorComponent +import eu.darken.cap.monitor.core.PodMonitor + +@InstallIn(MonitorComponent::class) +@EntryPoint +interface MonitorWorkerEntryPoint { + fun podMonitor(): PodMonitor + fun bluetoothManager2(): BluetoothManager2 +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/monitor/ui/MonitorNotifications.kt b/app/src/main/java/eu/darken/cap/monitor/ui/MonitorNotifications.kt new file mode 100644 index 00000000..957b6365 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/monitor/ui/MonitorNotifications.kt @@ -0,0 +1,92 @@ +package eu.darken.cap.monitor.ui + +import android.annotation.SuppressLint +import android.app.Notification +import android.app.NotificationChannel +import android.app.NotificationManager +import android.app.PendingIntent +import android.content.Context +import android.content.Intent +import android.content.pm.ServiceInfo +import android.os.Build +import androidx.core.app.NotificationCompat +import androidx.work.ForegroundInfo +import dagger.hilt.android.qualifiers.ApplicationContext +import eu.darken.cap.R +import eu.darken.cap.common.debug.logging.Logging.Priority.VERBOSE +import eu.darken.cap.common.debug.logging.log +import eu.darken.cap.common.debug.logging.logTag +import eu.darken.cap.common.hasApiLevel +import eu.darken.cap.main.ui.MainActivity +import eu.darken.cap.pods.core.PodDevice +import javax.inject.Inject + + +class MonitorNotifications @Inject constructor( + @ApplicationContext private val context: Context, + notificationManager: NotificationManager, +) { + + private val builder: NotificationCompat.Builder + + init { + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { + val channel = NotificationChannel( + NOTIFICATION_CHANNEL_ID, + context.getString(R.string.notification_channel_device_status_label), + NotificationManager.IMPORTANCE_LOW + ) + notificationManager.createNotificationChannel(channel) + } + + val openIntent = Intent(context, MainActivity::class.java) + val openPi = if (hasApiLevel(31)) { + PendingIntent.getActivity(context, 0, openIntent, PendingIntent.FLAG_IMMUTABLE) + } else { + PendingIntent.getActivity(context, 0, openIntent, 0) + } + + builder = NotificationCompat.Builder(context, NOTIFICATION_CHANNEL_ID) + .setChannelId(NOTIFICATION_CHANNEL_ID) + .setContentIntent(openPi) + .setPriority(NotificationCompat.PRIORITY_HIGH) + .setSmallIcon(R.drawable.ic_notification_device_status_icon) + .setContentTitle(context.getString(R.string.app_name)) + .setStyle( + NotificationCompat.BigTextStyle().bigText(context.getString(R.string.device_status_loading_message)) + ) + } + + fun getBuilder(podDevice: PodDevice?): NotificationCompat.Builder { + if (podDevice == null) return builder + +// builder.setContentTitle(gear.primary.get(context)) +// builder.setStyle(NotificationCompat.BigTextStyle().bigText(it.secondary.get(context))) + log(TAG, VERBOSE) { "updatingNotification(): $podDevice" } + return builder + } + + fun getNotification(podDevice: PodDevice?): Notification = getBuilder(podDevice).build() + + fun getForegroundInfo(podDevice: PodDevice?): ForegroundInfo = getBuilder(podDevice).toForegroundInfo() + + @SuppressLint("InlinedApi") + private fun NotificationCompat.Builder.toForegroundInfo(): ForegroundInfo = if (hasApiLevel(29)) { + ForegroundInfo( + NOTIFICATION_ID, + this.build(), + ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE + ) + } else { + ForegroundInfo( + NOTIFICATION_ID, + this.build() + ) + } + + companion object { + val TAG = logTag("Monitor", "Notifications") + private const val NOTIFICATION_CHANNEL_ID = "eu.darken.cap.notification.channel.device.status" + internal const val NOTIFICATION_ID = 1 + } +} diff --git a/app/src/main/java/eu/darken/cap/pods/core/PodDevice.kt b/app/src/main/java/eu/darken/cap/pods/core/PodDevice.kt new file mode 100644 index 00000000..930b16ff --- /dev/null +++ b/app/src/main/java/eu/darken/cap/pods/core/PodDevice.kt @@ -0,0 +1,12 @@ +package eu.darken.cap.pods.core + +import android.bluetooth.le.ScanResult + +interface PodDevice { + + val scanResult: ScanResult + + interface Status { + + } +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/pods/core/PodFactory.kt b/app/src/main/java/eu/darken/cap/pods/core/PodFactory.kt new file mode 100644 index 00000000..3f4914a4 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/pods/core/PodFactory.kt @@ -0,0 +1,36 @@ +package eu.darken.cap.pods.core + +import android.bluetooth.le.ScanResult +import dagger.Reusable +import eu.darken.cap.common.debug.logging.Logging.Priority.VERBOSE +import eu.darken.cap.common.debug.logging.Logging.Priority.WARN +import eu.darken.cap.common.debug.logging.log +import eu.darken.cap.common.debug.logging.logTag +import eu.darken.cap.pods.core.airpods.AirPodsFactory +import javax.inject.Inject + +@Reusable +class PodFactory @Inject constructor( + private val airPodsFactory: AirPodsFactory +) { + + suspend fun createPod(scanResult: ScanResult): PodDevice? { + log(TAG, VERBOSE) { "Trying to create Pod for $scanResult" } + + val pod = airPodsFactory.create(scanResult) + if (pod != null) { + log(TAG) { "Pod created: $pod" } + return pod + } else { + log(TAG, WARN) { "Not an AirPod : $scanResult" } + } + + + log(TAG, WARN) { "Failed to find matching PodFactory for $scanResult" } + return null + } + + companion object { + private val TAG = logTag("Pod", "Factory") + } +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/pods/core/airpods/AirPodsDevice.kt b/app/src/main/java/eu/darken/cap/pods/core/airpods/AirPodsDevice.kt new file mode 100644 index 00000000..4dde577b --- /dev/null +++ b/app/src/main/java/eu/darken/cap/pods/core/airpods/AirPodsDevice.kt @@ -0,0 +1,191 @@ +package eu.darken.cap.pods.core.airpods + +import eu.darken.cap.common.debug.logging.log +import eu.darken.cap.common.isBitSet +import eu.darken.cap.common.lowerNibble +import eu.darken.cap.common.upperNibble + +interface AirPodsDevice : ApplePods { + + val tag: String + + // We start counting at the airpods prefix byte + val rawPrefix: UByte + get() = proximityMessage.data[0] + + val rawDeviceModel: UShort + get() = (((proximityMessage.data[1].toInt() and 255) shl 8) or (proximityMessage.data[2].toInt() and 255)).toUShort() + + val rawStatus: UByte + get() = proximityMessage.data[3] + + val rawPodsBattery: UByte + get() = proximityMessage.data[4] + + val rawCaseBattery: UByte + get() = proximityMessage.data[5] + + val rawCaseLidState: UByte + get() = proximityMessage.data[6] + + val rawDeviceColor: UByte + get() = proximityMessage.data[7] + + val rawSuffix: UByte + get() = proximityMessage.data[8] + + val microPhonePod: Pod + get() = when (rawStatus.isBitSet(5)) { + true -> Pod.LEFT + false -> Pod.RIGHT + } + + enum class Pod { + LEFT, + RIGHT + } + + val batteryLeftPodPercent: Float? + get() { + val value = when (microPhonePod) { + Pod.LEFT -> rawPodsBattery.lowerNibble.toInt() + Pod.RIGHT -> rawPodsBattery.upperNibble.toInt() + } + return when (value) { + 15 -> null + else -> if (value >= 10) { + log(tag) { "Left pod: Above 100% battery: $value" } + 1.0f + } else { + (value / 10f) + } + } + } + + val batteryRightPodPercent: Float? + get() { + val value = when (microPhonePod) { + Pod.LEFT -> rawPodsBattery.upperNibble.toInt() + Pod.RIGHT -> rawPodsBattery.lowerNibble.toInt() + } + return when (value) { + 15 -> null + else -> if (value > 10) { + log(tag) { "Right pod: Above 100% battery: $value" } + 1.0f + } else { + value / 10f + } + } + } + + val batteryCasePercent: Float? + get() = when (val value = rawCaseBattery.lowerNibble.toInt()) { + 15 -> null + else -> if (value > 10) { + log(tag) { "Case: Above 100% battery: $value" } + 1.0f + } else { + value / 10f + } + } + + val isLeftPodInEar: Boolean + get() = when (microPhonePod) { + Pod.LEFT -> rawStatus.isBitSet(1) + Pod.RIGHT -> rawStatus.isBitSet(3) + } + + val isRightPodInEar: Boolean + get() = when (microPhonePod) { + Pod.LEFT -> rawStatus.isBitSet(3) + Pod.RIGHT -> rawStatus.isBitSet(1) + } + + val status: Status + get() = Status.values().firstOrNull { it.raw == rawStatus } ?: Status.UNKNOWN + + enum class Status(val raw: UByte?) { + BOTH_AIRPODS_IN_CASE(0x55), + LEFT_IN_EAR(0x33), + AIRPLANE(0x02), + UNKNOWN(null); + + constructor(raw: Int) : this(raw.toUByte()) + } + + // 1010101 0x55 85 Both In Case + // 0101011 0x2b 43 Both In Ear + // 0101001 0x29 41 Right in Ear + // 0100011 0x23 35 Left In Ear + // 0100001 0x21 33 Neither in Ear or In Case + // 1110001 0x71 113 Left in Case, Right on Desk + // 0010001 0x11 17 Left in Case, Right on Desk + // 0010011 0x13 19 Left in Case, Right in Ear + // 1110011 0x73 115 Left in Case, Right in Ear + + + val isCaseCharging: Boolean + get() = rawCaseBattery.upperNibble.isBitSet(2) + + val isLeftPodCharging: Boolean + get() = when (microPhonePod) { + Pod.LEFT -> rawCaseBattery.upperNibble.isBitSet(0) + Pod.RIGHT -> rawCaseBattery.upperNibble.isBitSet(1) + } + + val isRightPodCharging: Boolean + get() = when (microPhonePod) { + Pod.LEFT -> rawCaseBattery.upperNibble.isBitSet(1) + Pod.RIGHT -> rawCaseBattery.upperNibble.isBitSet(0) + } + + val caseLidState: LidState + get() = LidState.values().firstOrNull { it.raw == rawCaseLidState } ?: LidState.UNKNOWN + + enum class LidState(val raw: UByte?) { + OPEN(0x31), + CLOSED(0x38), + NOT_IN_CASE(0x01), + UNKNOWN(null); + + constructor(raw: Int) : this(raw.toUByte()) + } + + val deviceColor: DeviceColor + get() = DeviceColor.values().firstOrNull { it.raw == rawDeviceColor } ?: DeviceColor.UNKNOWN + + enum class DeviceColor(val raw: UByte?) { + WHITE(0x00), + BLACK(0x01), + RED(0x02), + BLUE(0x03), + PINK(0x04), + GRAY(0x05), + SILVER(0x06), + GOLD(0x07), + ROSE_GOLD(0x08), + SPACE_GRAY(0x09), + DARK_BLUE(0x0a), + LIGHT_BLUE(0x0b), + YELLOW(0x0c), + UNKNOWN(null); + + constructor(raw: Int) : this(raw.toUByte()) + } + + val connectionState: ConnectionState + get() = ConnectionState.values().firstOrNull { rawSuffix == it.raw } ?: ConnectionState.UNKNOWN + + enum class ConnectionState(val raw: UByte?) { + DISCONNECTED(0x00), + IDLE(0x04), + MUSIC(0x05), + CALL(0x06), + RINGING(0x07), + HANGING_UP(0x09), + UNKNOWN(null); + + constructor(raw: Int) : this(raw.toUByte()) + } +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/pods/core/airpods/AirPodsFactory.kt b/app/src/main/java/eu/darken/cap/pods/core/airpods/AirPodsFactory.kt new file mode 100644 index 00000000..1120f962 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/pods/core/airpods/AirPodsFactory.kt @@ -0,0 +1,110 @@ +package eu.darken.cap.pods.core.airpods + +import android.bluetooth.le.ScanResult +import dagger.Reusable +import eu.darken.cap.bugreporting.Bugs +import eu.darken.cap.common.debug.logging.Logging.Priority.INFO +import eu.darken.cap.common.debug.logging.Logging.Priority.WARN +import eu.darken.cap.common.debug.logging.asLog +import eu.darken.cap.common.debug.logging.log +import eu.darken.cap.common.debug.logging.logTag +import eu.darken.cap.pods.core.PodDevice +import eu.darken.cap.pods.core.airpods.models.AirPodsGen1 +import eu.darken.cap.pods.core.airpods.models.AirPodsGen2 +import eu.darken.cap.pods.core.airpods.models.AirPodsPro +import eu.darken.cap.pods.core.airpods.models.UnknownAppleDevice +import javax.inject.Inject + +@Reusable +class AirPodsFactory @Inject constructor( + private val continuityProtocolDecoder: ContinuityProtocol.Decoder, + private val proximityPairingDecoder: ProximityPairing.Decoder +) { + + data class Message( + // 0x07 ; AirPods message1 byte + // 25; Length 1byte + // 0x01 + val type: UByte, + val deviceModel: UShort, + val status: UByte, + val batteryIndicator: UShort, + val lidCount: UByte, + val deviceColor: UByte, + val encryptedData: UShort, + ) + + suspend fun create(scanResult: ScanResult): PodDevice? { + val messages = try { + continuityProtocolDecoder.decode(scanResult) + } catch (e: Exception) { + log(TAG, WARN) { "Data wasn't continuity protocol conform:\n${e.asLog()}" } + return null + } + if (messages.isEmpty()) { + log(TAG, WARN) { "Data contained no continuity messages: $scanResult" } + return null + } + + if (messages.size > 1) { + log(TAG, WARN) { "Decoded multiple continuity messages, picking first: $messages" } + } + + val proximityMessage = proximityPairingDecoder.decode(messages.first()) + if (proximityMessage == null) { + log(TAG) { "Not a proximity pairing message: $messages" } + return null + } + + log(TAG, INFO) { + val data = scanResult.scanRecord!!.getManufacturerSpecificData( + ContinuityProtocol.APPLE_COMPANY_IDENTIFIER + )!! + val dataHex = data.joinToString(separator = " ") { + String.format("%02X", it) + } + "Decoding (MAC=${scanResult.device.address}, nanos=${scanResult.timestampNanos}, rssi=${scanResult.rssi}): $dataHex" + } + + val dm = ( + ((proximityMessage.data[1].toInt() and 255) shl 8) or (proximityMessage.data[2].toInt() and 255) + ).toUShort() + val dmDirty = proximityMessage.data[1] + + return when { + dm == 0x0220.toUShort() || dmDirty == 2.toUByte() -> AirPodsGen1(scanResult, proximityMessage) + dm == 0x0F20.toUShort() || dmDirty == 15.toUByte() -> AirPodsGen2(scanResult, proximityMessage) + dm == 0x0e20.toUShort() || dmDirty == 14.toUByte() -> AirPodsPro(scanResult, proximityMessage) +// dmDirty == 10.toUByte() -> { +// TODO("Airpods Max") +// } +// dmDirty == 11.toUByte() -> { +// TODO("PowerBeatsPro") +// } +// dm == 0x0520.toUShort() || dmDirty == 5.toUByte() -> { +// TODO("BeatsX") +// } +// dmDirty == 0.toUByte() -> { +// TODO("BeatsFlex") +// } +// dm == 0x0620.toUShort() || dmDirty == 6.toUByte() -> { +// TODO("Beats Solo 3") +// } +// dmDirty == 9.toUByte() -> { +// TODO("Beats Studio 3") +// } +// dm == 0x0320.toUShort() || dmDirty == 3.toUByte() -> { +// TODO("Power Beats 3") +// } + else -> { + log(TAG, WARN) { "Unknown proximity message type" } + Bugs.report(IllegalArgumentException("Unknown ProximityMessage: $proximityMessage")) + UnknownAppleDevice(scanResult, proximityMessage) + } + } + } + + companion object { + private val TAG = logTag("Pod", "AirPods", "Factory") + } +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/pods/core/airpods/ApplePods.kt b/app/src/main/java/eu/darken/cap/pods/core/airpods/ApplePods.kt new file mode 100644 index 00000000..735eb69d --- /dev/null +++ b/app/src/main/java/eu/darken/cap/pods/core/airpods/ApplePods.kt @@ -0,0 +1,14 @@ +package eu.darken.cap.pods.core.airpods + +import eu.darken.cap.common.debug.logging.logTag +import eu.darken.cap.pods.core.PodDevice + +interface ApplePods : PodDevice { + + val proximityMessage: ProximityPairing.Message + + companion object { + + val TAG = logTag("Pod", "BaseAirPods") + } +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/pods/core/airpods/ContinuityProtocol.kt b/app/src/main/java/eu/darken/cap/pods/core/airpods/ContinuityProtocol.kt new file mode 100644 index 00000000..d20c42f9 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/pods/core/airpods/ContinuityProtocol.kt @@ -0,0 +1,66 @@ +package eu.darken.cap.pods.core.airpods + +import android.bluetooth.le.ScanResult +import android.os.ParcelUuid +import dagger.Reusable +import eu.darken.cap.common.debug.logging.Logging.Priority.WARN +import eu.darken.cap.common.debug.logging.log +import eu.darken.cap.common.debug.logging.logTag +import javax.inject.Inject + +object ContinuityProtocol { + + data class Message( + val type: UByte, + val length: Int, + val data: UByteArray + ) { + override fun equals(other: Any?): Boolean { + if (this === other) return true + if (other !is Message) return false + + if (!data.contentEquals(other.data)) return false + + return true + } + + override fun hashCode(): Int = data.contentHashCode() + } + + @Reusable + class Decoder @Inject constructor() { + fun decode(scanResult: ScanResult): List = scanResult.scanRecord + ?.getManufacturerSpecificData(APPLE_COMPANY_IDENTIFIER) + ?.let { data -> + val messages = mutableListOf() + + var remainingData = data.asUByteArray() + while (remainingData.size >= 2) { + val dataLength = remainingData[1].toInt() + val dataStart = 2 + val dataEnd = dataStart + dataLength + Message( + type = remainingData[0], + length = dataLength, + data = remainingData.copyOfRange(dataStart, dataEnd) + ).run { messages.add(this) } + + remainingData = remainingData.copyOfRange(dataEnd, remainingData.size) + } + if (remainingData.isNotEmpty()) { + log(TAG, WARN) { "Data contained malformed protocol message $remainingData" } + } + messages.toList() + } ?: emptyList() + } + + const val APPLE_COMPANY_IDENTIFIER = 0x004C + + // Continuity protocol data is in these vendor specific data sets + val BLE_FEATURE_UUIDS = setOf( + ParcelUuid.fromString("74ec2172-0bad-4d01-8f77-997b2be0722a"), + ParcelUuid.fromString("2a72e02b-7b99-778f-014d-ad0b7221ec74") + ) + + val TAG = logTag("ContinuityProtocol", "Decoder") +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/pods/core/airpods/ProximityPairing.kt b/app/src/main/java/eu/darken/cap/pods/core/airpods/ProximityPairing.kt new file mode 100644 index 00000000..68645427 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/pods/core/airpods/ProximityPairing.kt @@ -0,0 +1,60 @@ +package eu.darken.cap.pods.core.airpods + +import android.bluetooth.le.ScanFilter +import dagger.Reusable +import eu.darken.cap.common.debug.logging.log +import javax.inject.Inject + + +object ProximityPairing { + + data class Message( + val type: UByte, + val length: Int, + val data: UByteArray + ) + + @Reusable + class Decoder @Inject constructor() { + fun decode(message: ContinuityProtocol.Message): Message? { + if (message.type != CONTINUITY_PROTOCOL_MESSAGE_TYPE_PROXIMITY_PAIRING) { + log(ApplePods.TAG) { "Not a proximity pairing message: $this" } + return null + } + if (message.length != PROXIMITY_PAIRING_MESSAGE_LENGTH) { + log(ApplePods.TAG) { "Proximity pairing message has invalid length." } + return null + } + + return Message( + type = message.type, + length = message.length, + data = message.data + ) + } + } + + fun getBleScanFilter(): Set { + val manufacturerData = ByteArray(CONTINUITY_PROTOCOL_MESSAGE_LENGTH).apply { + this[0] = CONTINUITY_PROTOCOL_MESSAGE_TYPE_PROXIMITY_PAIRING.toByte() + this[1] = PROXIMITY_PAIRING_MESSAGE_LENGTH.toByte() + } + + val manufacturerDataMask = ByteArray(CONTINUITY_PROTOCOL_MESSAGE_LENGTH).apply { + this[0] = 1 + this[1] = 1 + } + val builder = ScanFilter.Builder().apply { + setManufacturerData( + ContinuityProtocol.APPLE_COMPANY_IDENTIFIER, + manufacturerData, + manufacturerDataMask + ) + } + return setOf(builder.build()) + } + + private const val CONTINUITY_PROTOCOL_MESSAGE_LENGTH = 27 + private val CONTINUITY_PROTOCOL_MESSAGE_TYPE_PROXIMITY_PAIRING = 0x07.toUByte() + private const val PROXIMITY_PAIRING_MESSAGE_LENGTH = 25 +} diff --git a/app/src/main/java/eu/darken/cap/pods/core/airpods/models/AirPodsGen1.kt b/app/src/main/java/eu/darken/cap/pods/core/airpods/models/AirPodsGen1.kt new file mode 100644 index 00000000..559c641a --- /dev/null +++ b/app/src/main/java/eu/darken/cap/pods/core/airpods/models/AirPodsGen1.kt @@ -0,0 +1,13 @@ +package eu.darken.cap.pods.core.airpods.models + +import android.bluetooth.le.ScanResult +import eu.darken.cap.common.debug.logging.logTag +import eu.darken.cap.pods.core.airpods.AirPodsDevice +import eu.darken.cap.pods.core.airpods.ProximityPairing + +data class AirPodsGen1 constructor( + override val scanResult: ScanResult, + override val proximityMessage: ProximityPairing.Message +) : AirPodsDevice { + override val tag: String = logTag("Pod", "AirPodsGen1") +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/pods/core/airpods/models/AirPodsGen2.kt b/app/src/main/java/eu/darken/cap/pods/core/airpods/models/AirPodsGen2.kt new file mode 100644 index 00000000..1437b770 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/pods/core/airpods/models/AirPodsGen2.kt @@ -0,0 +1,13 @@ +package eu.darken.cap.pods.core.airpods.models + +import android.bluetooth.le.ScanResult +import eu.darken.cap.common.debug.logging.logTag +import eu.darken.cap.pods.core.airpods.AirPodsDevice +import eu.darken.cap.pods.core.airpods.ProximityPairing + +data class AirPodsGen2 constructor( + override val scanResult: ScanResult, + override val proximityMessage: ProximityPairing.Message +) : AirPodsDevice { + override val tag: String = logTag("Pod", "AirPodsGen2") +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/pods/core/airpods/models/AirPodsMax.kt b/app/src/main/java/eu/darken/cap/pods/core/airpods/models/AirPodsMax.kt new file mode 100644 index 00000000..d5acd2eb --- /dev/null +++ b/app/src/main/java/eu/darken/cap/pods/core/airpods/models/AirPodsMax.kt @@ -0,0 +1,10 @@ +package eu.darken.cap.pods.core.airpods.models + +import android.bluetooth.le.ScanResult +import eu.darken.cap.pods.core.airpods.ApplePods +import eu.darken.cap.pods.core.airpods.ProximityPairing + +data class AirPodsMax constructor( + override val scanResult: ScanResult, + override val proximityMessage: ProximityPairing.Message +) : ApplePods \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/pods/core/airpods/models/AirPodsPro.kt b/app/src/main/java/eu/darken/cap/pods/core/airpods/models/AirPodsPro.kt new file mode 100644 index 00000000..040555f6 --- /dev/null +++ b/app/src/main/java/eu/darken/cap/pods/core/airpods/models/AirPodsPro.kt @@ -0,0 +1,14 @@ +package eu.darken.cap.pods.core.airpods.models + +import android.bluetooth.le.ScanResult +import eu.darken.cap.common.debug.logging.logTag +import eu.darken.cap.pods.core.airpods.AirPodsDevice +import eu.darken.cap.pods.core.airpods.ProximityPairing + +data class AirPodsPro constructor( + override val scanResult: ScanResult, + override val proximityMessage: ProximityPairing.Message +) : AirPodsDevice { + + override val tag: String = logTag("Pod", "AirPodsPro") +} \ No newline at end of file diff --git a/app/src/main/java/eu/darken/cap/pods/core/airpods/models/UnknownAppleDevice.kt b/app/src/main/java/eu/darken/cap/pods/core/airpods/models/UnknownAppleDevice.kt new file mode 100644 index 00000000..84c0ccbc --- /dev/null +++ b/app/src/main/java/eu/darken/cap/pods/core/airpods/models/UnknownAppleDevice.kt @@ -0,0 +1,10 @@ +package eu.darken.cap.pods.core.airpods.models + +import android.bluetooth.le.ScanResult +import eu.darken.cap.pods.core.airpods.ApplePods +import eu.darken.cap.pods.core.airpods.ProximityPairing + +data class UnknownAppleDevice constructor( + override val scanResult: ScanResult, + override val proximityMessage: ProximityPairing.Message +) : ApplePods \ No newline at end of file diff --git a/app/src/main/res/drawable-v24/ic_launcher_foreground.xml b/app/src/main/res/drawable-v24/ic_launcher_foreground.xml new file mode 100644 index 00000000..2b068d11 --- /dev/null +++ b/app/src/main/res/drawable-v24/ic_launcher_foreground.xml @@ -0,0 +1,30 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable/ic_baseline_add_24.xml b/app/src/main/res/drawable/ic_baseline_add_24.xml new file mode 100644 index 00000000..54da215b --- /dev/null +++ b/app/src/main/res/drawable/ic_baseline_add_24.xml @@ -0,0 +1,10 @@ + + + diff --git a/app/src/main/res/drawable/ic_launcher_background.xml b/app/src/main/res/drawable/ic_launcher_background.xml new file mode 100644 index 00000000..07d5da9c --- /dev/null +++ b/app/src/main/res/drawable/ic_launcher_background.xml @@ -0,0 +1,170 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/app/src/main/res/drawable/ic_notification_device_status_icon.xml b/app/src/main/res/drawable/ic_notification_device_status_icon.xml new file mode 100644 index 00000000..adc33c38 --- /dev/null +++ b/app/src/main/res/drawable/ic_notification_device_status_icon.xml @@ -0,0 +1,10 @@ + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable/launch_screen.xml b/app/src/main/res/drawable/launch_screen.xml new file mode 100644 index 00000000..4f525576 --- /dev/null +++ b/app/src/main/res/drawable/launch_screen.xml @@ -0,0 +1,10 @@ + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/main_activity.xml b/app/src/main/res/layout/main_activity.xml new file mode 100644 index 00000000..24b3ac4c --- /dev/null +++ b/app/src/main/res/layout/main_activity.xml @@ -0,0 +1,20 @@ + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/main_fragment.xml b/app/src/main/res/layout/main_fragment.xml new file mode 100644 index 00000000..ad74c387 --- /dev/null +++ b/app/src/main/res/layout/main_fragment.xml @@ -0,0 +1,37 @@ + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/main_permission_item.xml b/app/src/main/res/layout/main_permission_item.xml new file mode 100644 index 00000000..7e22f5d8 --- /dev/null +++ b/app/src/main/res/layout/main_permission_item.xml @@ -0,0 +1,66 @@ + + + + + + + + + + + + + + + diff --git a/app/src/main/res/layout/main_toggle_item.xml b/app/src/main/res/layout/main_toggle_item.xml new file mode 100644 index 00000000..16f55e98 --- /dev/null +++ b/app/src/main/res/layout/main_toggle_item.xml @@ -0,0 +1,41 @@ + + + + + + + + + + + diff --git a/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml b/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml new file mode 100644 index 00000000..eca70cfe --- /dev/null +++ b/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml b/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml new file mode 100644 index 00000000..eca70cfe --- /dev/null +++ b/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/app/src/main/res/mipmap-hdpi/ic_launcher.png b/app/src/main/res/mipmap-hdpi/ic_launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..a571e60098c92c2baca8a5df62f2929cbff01b52 GIT binary patch literal 3593 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 P00000NkvXXu0mjfP=x?Y literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-hdpi/ic_launcher_round.png b/app/src/main/res/mipmap-hdpi/ic_launcher_round.png new file mode 100644 index 0000000000000000000000000000000000000000..61da551c5594a1f9d26193983d2cd69189014603 GIT binary patch literal 5339 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png b/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png new file mode 100644 index 0000000000000000000000000000000000000000..b216f2d313cc673d8b8c4da591c174ebed52795c GIT binary patch literal 11873 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/navigation/nav_graph.xml b/app/src/main/res/navigation/nav_graph.xml new file mode 100644 index 00000000..e29677d9 --- /dev/null +++ b/app/src/main/res/navigation/nav_graph.xml @@ -0,0 +1,15 @@ + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/values-night/themes.xml b/app/src/main/res/values-night/themes.xml new file mode 100644 index 00000000..d69a4b5b --- /dev/null +++ b/app/src/main/res/values-night/themes.xml @@ -0,0 +1,32 @@ + + + + + \ No newline at end of file diff --git a/app/src/main/res/values/colors.xml b/app/src/main/res/values/colors.xml new file mode 100644 index 00000000..7733ee46 --- /dev/null +++ b/app/src/main/res/values/colors.xml @@ -0,0 +1,57 @@ + + + #6750A4 + #FFFFFF + #EADDFF + #21005D + #625B71 + #FFFFFF + #E8DEF8 + #1D192B + #7D5260 + #FFFFFF + #FFD8E4 + #31111D + #B3261E + #F9DEDC + #FFFFFF + #410E0B + #FFFBFE + #1C1B1F + #FFFBFE + #1C1B1F + #E7E0EC + #49454F + #79747E + #F4EFF4 + #313033 + #D0BCFF + #D0BCFF + #381E72 + #4F378B + #EADDFF + #CCC2DC + #332D41 + #4A4458 + #E8DEF8 + #EFB8C8 + #492532 + #633B48 + #FFD8E4 + #F2B8B5 + #8C1D18 + #601410 + #F9DEDC + #1C1B1F + #E6E1E5 + #1C1B1F + #E6E1E5 + #49454F + #CAC4D0 + #938F99 + #1C1B1F + #E6E1E5 + #6750A4 + #6750A4 + #B3261E + \ No newline at end of file diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml new file mode 100644 index 00000000..d793dd89 --- /dev/null +++ b/app/src/main/res/values/strings.xml @@ -0,0 +1,10 @@ + + Companion App for AirPods + Error + BLUETOOTH CONNECT + Required to be able to connect to paired Bluetooth devices. + Loading device status + Device status + BLUETOOTH SCAN + Required to be able to discover and pair nearby Bluetooth devices. + \ No newline at end of file diff --git a/app/src/main/res/values/styles.xml b/app/src/main/res/values/styles.xml new file mode 100644 index 00000000..216d8781 --- /dev/null +++ b/app/src/main/res/values/styles.xml @@ -0,0 +1,9 @@ + + + + + \ No newline at end of file diff --git a/app/src/main/res/values/themes.xml b/app/src/main/res/values/themes.xml new file mode 100644 index 00000000..53bffe0b --- /dev/null +++ b/app/src/main/res/values/themes.xml @@ -0,0 +1,32 @@ + + + + + \ No newline at end of file diff --git a/app/src/test/java/eu/darken/cap/common/flow/DynamicStateFlowTest.kt b/app/src/test/java/eu/darken/cap/common/flow/DynamicStateFlowTest.kt new file mode 100644 index 00000000..1a54e5d2 --- /dev/null +++ b/app/src/test/java/eu/darken/cap/common/flow/DynamicStateFlowTest.kt @@ -0,0 +1,351 @@ +package eu.darken.cap.common.flow + +import eu.darken.cap.common.collections.mutate +import io.kotest.assertions.throwables.shouldThrow +import io.kotest.matchers.shouldBe +import io.kotest.matchers.types.instanceOf +import io.kotest.matchers.types.shouldBeInstanceOf +import io.mockk.coEvery +import io.mockk.coVerify +import io.mockk.mockk +import kotlinx.coroutines.* +import kotlinx.coroutines.flow.first +import kotlinx.coroutines.flow.firstOrNull +import kotlinx.coroutines.test.TestCoroutineScope +import org.junit.jupiter.api.Test +import testhelper.BaseTest +import testhelper.coroutine.runBlockingTest2 +import testhelper.flow.test +import java.io.IOException +import java.lang.Thread.sleep +import kotlin.concurrent.thread + +class DynamicStateFlowTest : BaseTest() { + + // Without an init value, there isn't a way to keep using the flow + @Test + fun `exceptions on initialization are rethrown`() { + val testScope = TestCoroutineScope() + val hotData = DynamicStateFlow( + loggingTag = "tag", + parentScope = testScope, + coroutineContext = Dispatchers.Unconfined, + startValueProvider = { throw IOException() } + ) + runBlocking { + withTimeoutOrNull(500) { + // This blocking scope gets the init exception as the first caller + hotData.flow.firstOrNull() + } shouldBe null + } + + testScope.advanceUntilIdle() + + testScope.uncaughtExceptions.single() shouldBe instanceOf(IOException::class) + } + + @Test + fun `subscription doesn't end when no subscriber is collecting, mode Lazily`() { + val testScope = TestCoroutineScope() + val valueProvider = mockk String>() + coEvery { valueProvider.invoke(any()) } returns "Test" + + val hotData = DynamicStateFlow( + loggingTag = "tag", + parentScope = testScope, + coroutineContext = Dispatchers.Unconfined, + startValueProvider = valueProvider, + ) + + testScope.apply { + runBlockingTest2(allowUncompleted = true) { + hotData.flow.first() shouldBe "Test" + hotData.flow.first() shouldBe "Test" + } + coVerify(exactly = 1) { valueProvider.invoke(any()) } + } + } + + @Test + fun `value updates`() { + val testScope = TestCoroutineScope() + val valueProvider = mockk Long>() + coEvery { valueProvider.invoke(any()) } returns 1 + + val hotData = DynamicStateFlow( + loggingTag = "tag", + parentScope = testScope, + startValueProvider = valueProvider, + ) + + val testCollector = hotData.flow.test(startOnScope = testScope) + testCollector.silent = true + + (1..16).forEach { _ -> + thread { + (1..200).forEach { _ -> + sleep(10) + hotData.updateAsync( + onUpdate = { this + 1L }, + onError = { throw it } + ) + } + } + } + + runBlocking { + testCollector.await { list, _ -> list.size == 3201 } + testCollector.latestValues shouldBe (1..3201).toList() + } + + coVerify(exactly = 1) { valueProvider.invoke(any()) } + } + + data class TestData( + val number: Long = 1 + ) + + @Test + fun `check multi threading value updates with more complex data`() { + val testScope = TestCoroutineScope() + val valueProvider = mockk Map>() + coEvery { valueProvider.invoke(any()) } returns mapOf("data" to TestData()) + + val hotData = DynamicStateFlow( + loggingTag = "tag", + parentScope = testScope, + startValueProvider = valueProvider, + ) + + val testCollector = hotData.flow.test(startOnScope = testScope) + testCollector.silent = true + + (1..10).forEach { _ -> + thread { + (1..400).forEach { _ -> + hotData.updateAsync { + mutate { + this["data"] = getValue("data").copy( + number = getValue("data").number + 1 + ) + } + } + } + } + } + + runBlocking { + testCollector.await { list, _ -> list.size == 4001 } + testCollector.latestValues.map { it.values.single().number } shouldBe (1L..4001L).toList() + } + + coVerify(exactly = 1) { valueProvider.invoke(any()) } + } + + @Test + fun `only emit new values if they actually changed updates`() { + val testScope = TestCoroutineScope() + + val hotData = DynamicStateFlow( + loggingTag = "tag", + parentScope = testScope, + startValueProvider = { "1" }, + ) + + val testCollector = hotData.flow.test(startOnScope = testScope) + testCollector.silent = true + + hotData.updateAsync { "1" } + hotData.updateAsync { "2" } + hotData.updateAsync { "2" } + hotData.updateAsync { "1" } + + runBlocking { + testCollector.await { list, _ -> list.size == 3 } + testCollector.latestValues shouldBe listOf("1", "2", "1") + } + } + + @Test + fun `multiple subscribers share the flow`() { + val testScope = TestCoroutineScope() + val valueProvider = mockk String>() + coEvery { valueProvider.invoke(any()) } returns "Test" + + val hotData = DynamicStateFlow( + loggingTag = "tag", + parentScope = testScope, + startValueProvider = valueProvider, + ) + + testScope.runBlockingTest2(allowUncompleted = true) { + val sub1 = hotData.flow.test(tag = "sub1", startOnScope = this) + val sub2 = hotData.flow.test(tag = "sub2", startOnScope = this) + val sub3 = hotData.flow.test(tag = "sub3", startOnScope = this) + + hotData.updateAsync { "A" } + hotData.updateAsync { "B" } + hotData.updateAsync { "C" } + + listOf(sub1, sub2, sub3).forEach { + it.await { list, _ -> list.size == 4 } + it.latestValues shouldBe listOf("Test", "A", "B", "C") + it.cancel() + } + + hotData.flow.first() shouldBe "C" + } + coVerify(exactly = 1) { valueProvider.invoke(any()) } + } + + @Test + fun `value is persisted between unsubscribes`() = runBlockingTest2(allowUncompleted = true) { + val valueProvider = mockk Long>() + coEvery { valueProvider.invoke(any()) } returns 1 + + val hotData = DynamicStateFlow( + loggingTag = "tag", + parentScope = this, + coroutineContext = this.coroutineContext, + startValueProvider = valueProvider, + ) + + val testCollector1 = hotData.flow.test(tag = "collector1", startOnScope = this) + testCollector1.silent = false + + (1..10).forEach { _ -> + hotData.updateAsync { + this + 1L + } + } + + advanceUntilIdle() + + testCollector1.await { list, _ -> list.size == 11 } + testCollector1.latestValues shouldBe (1L..11L).toList() + + testCollector1.cancel() + testCollector1.awaitFinal() + + val testCollector2 = hotData.flow.test(tag = "collector2", startOnScope = this) + testCollector2.silent = false + + advanceUntilIdle() + + testCollector2.cancel() + testCollector2.awaitFinal() + + testCollector2.latestValues shouldBe listOf(11L) + + coVerify(exactly = 1) { valueProvider.invoke(any()) } + } + + @Test + fun `blocking update is actually blocking`() = runBlocking { + val testScope = TestCoroutineScope() + val hotData = DynamicStateFlow( + loggingTag = "tag", + parentScope = testScope, + coroutineContext = testScope.coroutineContext, + startValueProvider = { + delay(2000) + 2 + }, + ) + + hotData.updateAsync { + delay(2000) + this + 1 + } + + val testCollector = hotData.flow.test(startOnScope = testScope) + + testScope.advanceUntilIdle() + + hotData.updateBlocking { this - 3 } shouldBe 0 + + testCollector.await { _, i -> i == 3 } + testCollector.latestValues shouldBe listOf(2, 3, 0) + + testCollector.cancel() + } + + @Test + fun `blocking update rethrows error`() = runBlocking { + val testScope = TestCoroutineScope() + val hotData = DynamicStateFlow( + loggingTag = "tag", + parentScope = testScope, + coroutineContext = testScope.coroutineContext, + startValueProvider = { + delay(2000) + 2 + }, + ) + + val testCollector = hotData.flow.test(startOnScope = testScope) + + testScope.advanceUntilIdle() + + shouldThrow { + hotData.updateBlocking { throw IOException("Surprise") } shouldBe 0 + } + hotData.flow.first() shouldBe 2 + + hotData.updateBlocking { 3 } shouldBe 3 + hotData.flow.first() shouldBe 3 + + testScope.uncaughtExceptions.singleOrNull() shouldBe null + + testCollector.cancel() + } + + @Test + fun `async updates error handler`() { + val testScope = TestCoroutineScope() + + val hotData = DynamicStateFlow( + loggingTag = "tag", + parentScope = testScope, + startValueProvider = { 1 }, + ) + + val testCollector = hotData.flow.test(startOnScope = testScope) + testScope.advanceUntilIdle() + + hotData.updateAsync { throw IOException("Surprise") } + + testScope.advanceUntilIdle() + + testScope.uncaughtExceptions.single() shouldBe instanceOf(IOException::class) + + testCollector.cancel() + } + + @Test + fun `async updates rethrow errors on HotDataFlow scope if no error handler is set`() = runBlocking { + val testScope = TestCoroutineScope() + + val hotData = DynamicStateFlow( + loggingTag = "tag", + parentScope = testScope, + startValueProvider = { 1 }, + ) + + val testCollector = hotData.flow.test(startOnScope = testScope) + testScope.advanceUntilIdle() + + var thrownError: Exception? = null + + hotData.updateAsync( + onUpdate = { throw IOException("Surprise") }, + onError = { thrownError = it } + ) + + testScope.advanceUntilIdle() + thrownError!!.shouldBeInstanceOf() + testScope.uncaughtExceptions.singleOrNull() shouldBe null + + testCollector.cancel() + } +} diff --git a/app/src/test/java/eu/darken/cap/pods/core/airpods/AirPodsFactoryTest.kt b/app/src/test/java/eu/darken/cap/pods/core/airpods/AirPodsFactoryTest.kt new file mode 100644 index 00000000..9141452e --- /dev/null +++ b/app/src/test/java/eu/darken/cap/pods/core/airpods/AirPodsFactoryTest.kt @@ -0,0 +1,290 @@ +package eu.darken.cap.pods.core.airpods + +import android.bluetooth.BluetoothDevice +import android.bluetooth.le.ScanRecord +import android.bluetooth.le.ScanResult +import eu.darken.cap.pods.core.PodDevice +import eu.darken.cap.pods.core.airpods.models.AirPodsGen1 +import eu.darken.cap.pods.core.airpods.models.AirPodsPro +import eu.darken.cap.pods.core.airpods.models.UnknownAppleDevice +import io.kotest.matchers.shouldBe +import io.kotest.matchers.types.instanceOf +import io.mockk.MockKAnnotations +import io.mockk.every +import io.mockk.impl.annotations.MockK +import kotlinx.coroutines.test.runBlockingTest +import org.junit.jupiter.api.BeforeEach +import org.junit.jupiter.api.Test +import testhelper.BaseTest + +class AirPodsFactoryTest : BaseTest() { + + @MockK lateinit var scanResult: ScanResult + @MockK lateinit var scanRecord: ScanRecord + @MockK lateinit var device: BluetoothDevice + + val factory = AirPodsFactory( + proximityPairingDecoder = ProximityPairing.Decoder(), + continuityProtocolDecoder = ContinuityProtocol.Decoder(), + ) + + @BeforeEach + fun setup() { + MockKAnnotations.init(this) + every { scanResult.scanRecord } returns scanRecord + every { scanResult.rssi } returns -66 + every { scanResult.timestampNanos } returns 136136027721826 + every { scanResult.device } returns device + every { device.address } returns "77:49:4C:D8:25:0C" + } + + private suspend inline fun create(hex: String, block: T.() -> Unit) { + val trimmed = hex + .replace(" ", "") + .replace(">", "") + .replace("<", "") + require(trimmed.length % 2 == 0) { "Not a HEX string" } + val bytes = trimmed.chunked(2).map { it.toInt(16).toByte() }.toByteArray() + mockData(bytes) + block.invoke(factory.create(scanResult) as T) + } + + private fun mockData(hex: String) { + val trimmed = hex + .replace(" ", "") + .replace(">", "") + .replace("<", "") + require(trimmed.length % 2 == 0) { "Not a HEX string" } + val bytes = trimmed.chunked(2).map { it.toInt(16).toByte() }.toByteArray() + return mockData(bytes) + } + + private fun mockData(data: ByteArray) { + every { scanRecord.getManufacturerSpecificData(ContinuityProtocol.APPLE_COMPANY_IDENTIFIER) } returns data + } + + @Test + fun `test AirPodDevice - active microphone`() = runBlockingTest { + create("07 19 01 0E 20 >2B< AA B5 31 00 00 E0 0C A7 8A 60 4B D3 7D F4 60 4F 2C 73 E9 A7 F4") { + // 00101011 + // --^----- + microPhonePod shouldBe AirPodsDevice.Pod.LEFT + } + create("07 19 01 0E 20 >0B< AA B5 31 00 00 E0 0C A7 8A 60 4B D3 7D F4 60 4F 2C 73 E9 A7 F4") { + // 00001011 + // --^----- + microPhonePod shouldBe AirPodsDevice.Pod.RIGHT + } + } + + @Test + fun `test AirPodDevice - left pod ear status`() = runBlockingTest { + // Left Pod primary + create("07 19 01 0E 20 >22< AA B5 31 00 00 E0 0C A7 8A 60 4B D3 7D F4 60 4F 2C 73 E9 A7 F4") { + // 00100010 + // 765432¹0 + isLeftPodInEar shouldBe true + } + create("07 19 01 0E 20 >20< AA B5 31 00 00 E0 0C A7 8A 60 4B D3 7D F4 60 4F 2C 73 E9 A7 F4") { + // 00100000 + // 765432¹0 + isLeftPodInEar shouldBe false + } + + // Right Pod is primary + create("07 19 01 0E 20 >09< AA B5 31 00 00 E0 0C A7 8A 60 4B D3 7D F4 60 4F 2C 73 E9 A7 F4") { + // 00001001 + // 7654³210 + isLeftPodInEar shouldBe true + } + create("07 19 01 0E 20 >20< AA B5 31 00 00 E0 0C A7 8A 60 4B D3 7D F4 60 4F 2C 73 E9 A7 F4") { + // 00000001 + // 7654³210 + isLeftPodInEar shouldBe false + } + } + + @Test + fun `test AirPodDevice - right pod ear status`() = runBlockingTest { + // Left Pod primary + create("07 19 01 0E 20 >29< AA B5 31 00 00 E0 0C A7 8A 60 4B D3 7D F4 60 4F 2C 73 E9 A7 F4") { + // 00101001 + // 7654³210 + isRightPodInEar shouldBe true + } + create("07 19 01 0E 20 >21< AA B5 31 00 00 E0 0C A7 8A 60 4B D3 7D F4 60 4F 2C 73 E9 A7 F4") { + // 00100001 + // 7654³210 + isRightPodInEar shouldBe false + } + + // Right Pod is primary + create("07 19 01 0E 20 >03< AA B5 31 00 00 E0 0C A7 8A 60 4B D3 7D F4 60 4F 2C 73 E9 A7 F4") { + // 00000011 + // 765432¹0 + isRightPodInEar shouldBe true + } + create("07 19 01 0E 20 >01< AA B5 31 00 00 E0 0C A7 8A 60 4B D3 7D F4 60 4F 2C 73 E9 A7 F4") { + // 00000001 + // 765432¹0 + isRightPodInEar shouldBe false + } + } + + @Test + fun `test AirPodDevice - battery status`() = runBlockingTest { + // Right Pod is primary + create("07 19 01 0E 20 0B >98< 94 52 00 05 09 73 3C 3D F9 2C 3E B3 DD 76 02 DD 4E 16 FD FB") { + // 88 10001000 + batteryLeftPodPercent shouldBe 0.9f + batteryRightPodPercent shouldBe 0.8f + } + // Left Pod primary + create("07 19 01 0E 20 2B >89< 94 52 00 05 09 73 3C 3D F9 2C 3E B3 DD 76 02 DD 4E 16 FD FB") { + // F8 11111000 + batteryLeftPodPercent shouldBe 0.9f + batteryRightPodPercent shouldBe 0.8f + } + } + + @Test + fun `test AirPodDevice - pod charging`() = runBlockingTest { + /** + * Right pod is charging + */ + // This is the left + create("07 19 01 0E 20 51 89 >94< 52 00 00 F4 89 82 6D 3E 27 7F 26 62 57 D0 E2 A6 49 E9 35") { + // 1001 0100 + isLeftPodCharging shouldBe false + isRightPodCharging shouldBe true + } + // This is the right + create("07 19 01 0E 20 31 98 >A4< 01 00 00 31 B9 A0 C4 80 CD D1 CF B9 3A 9A 6D 48 31 08 EB") { + // 1010 0100 + isLeftPodCharging shouldBe false + isRightPodCharging shouldBe true + } + + /** + * Left pod is charging + */ + // This is the left + create("07 19 01 0E 20 71 98 >94< 52 00 05 A5 37 31 B2 BD 42 68 0C 64 FD 00 99 4A E5 3E F4") { + // 1001 0100 + isLeftPodCharging shouldBe true + isRightPodCharging shouldBe false + } + // This is the right + create("07 19 01 0E 20 11 89 >A4< 04 00 04 BA 79 1B C0 65 69 C6 9F 19 6E 37 7D 6D 86 8D D9") { + // 1010 0100 + isLeftPodCharging shouldBe true + isRightPodCharging shouldBe false + } + + // Both charging + create("07 19 01 0E 20 55 88 >B4< 59 00 05 4B FC DF 68 28 A5 45 52 65 9C FE 51 86 3A B5 DB") { + // 1011 0100 + isLeftPodCharging shouldBe true + isRightPodCharging shouldBe true + } + // Both not charging + create("07 19 01 0E 20 00 F8 >8F< 03 00 05 4C 0F A0 C4 05 24 DD EB AF 92 99 FD 54 B1 06 48") { + // 1000 1111 + isLeftPodCharging shouldBe false + isRightPodCharging shouldBe false + } + } + + @Test + fun `test AirPodDevice - case charging`() = runBlockingTest { + create("07 19 01 0E 20 75 99 >B4< 31 00 05 77 C8 BA 0C 4E 1F BE AD 70 C5 40 71 D2 E9 17 A2") { + // 0011 0011 + isCaseCharging shouldBe false + } + create("07 19 01 0E 20 75 A9 >F4< 51 00 05 A0 37 92 35 49 79 CC DC 27 94 8E FB 72 12 94 52") { + // 0101 0011 + isCaseCharging shouldBe true + } + } + + @Test + fun `test AirPodDevice - case lid test`() = runBlockingTest { + // Lid open + create("07 19 01 0E 20 55 AA B4 >31< 00 00 A1 D0 BD 82 D3 52 86 CA FC 11 62 DC 42 C6 92 8E") { + // 31 0011 0001 + caseLidState shouldBe AirPodsDevice.LidState.OPEN + } + // Lid just closed + create("07 19 01 0E 20 55 AA B4 >39< 00 00 08 A6 DB 99 E0 5E 14 85 E5 C2 0B 68 D7 FF C3 A1") { + // 39 0011 1001 + caseLidState shouldBe AirPodsDevice.LidState.UNKNOWN + } + // Lid closed + create("07 19 01 0E 20 55 AA B4 38 00 00 F3 F7 08 3B 98 09 C0 DD E4 BD BD 84 55 56 8B 81") { + // 38 0011 1000 + caseLidState shouldBe AirPodsDevice.LidState.CLOSED + } + } + + @Test + fun `test AirPodDevice - connection state`() = runBlockingTest { + // Disconnected + create("07 19 01 0E 20 2B AA 8F 01 00 >00< 62 D4 BB F1 A7 F8 64 98 D2 C8 BD 7B 3A EF 2E 15") { + // 31 0011 0001 + connectionState shouldBe AirPodsDevice.ConnectionState.DISCONNECTED + } + // Connected idle + create("07 19 01 0E 20 2B AA 8F 01 00 >04< 1D 69 69 9C C2 51 F3 1F BF 6E 45 DA 90 4A A3 E3") { + // 39 0011 1001 + connectionState shouldBe AirPodsDevice.ConnectionState.IDLE + } + // Connected and playing music + create("07 19 01 0E 20 2B A9 8F 01 00 >05< 14 F7 CB 49 9F D3 B3 22 77 D2 22 F1 74 8C AC A6") { + // 38 0011 1000 + connectionState shouldBe AirPodsDevice.ConnectionState.MUSIC + } + // Connected and call active + create("07 19 01 0E 20 2B 99 8F 01 00 >06< 0F 4B 43 25 E0 4A 73 63 14 22 C2 3C 89 13 BD 97") { + // 38 0011 1000 + connectionState shouldBe AirPodsDevice.ConnectionState.CALL + } + // Connected and call active + create("07 19 01 0E 20 2B 99 8F 01 00 >07< E7 DF 76 44 85 B5 30 F4 95 14 02 DC A1 A4 8A 09") { + // 38 0011 1000 + connectionState shouldBe AirPodsDevice.ConnectionState.RINGING + } + // Switching? + create("07 19 01 0E 20 2B 99 8F 01 00 >09< 10 30 EE F3 41 B5 D8 9F A3 B0 B4 17 9F 85 97 5F") { + // 38 0011 1000 + connectionState shouldBe AirPodsDevice.ConnectionState.HANGING_UP + } + } + + @Test + fun `create AirPodsGen1`() = runBlockingTest { + create("07 19 01 02 20 55 AA 56 31 00 00 6F E4 DF 10 AF 10 60 81 03 3B 76 D9 C7 11 22 88") { + this shouldBe instanceOf() + } + } + + @Test + fun `create AirPodsPro`() = runBlockingTest { + create("07 19 01 0E 20 2B 99 8F 01 00 >09< 10 30 EE F3 41 B5 D8 9F A3 B0 B4 17 9F 85 97 5F") { + this shouldBe instanceOf() + } + } + + @Test + fun `unknown AppleDevice`() = runBlockingTest { + create("07 19 01 FF FF 2B 99 8F 01 00 >09< 10 30 EE F3 41 B5 D8 9F A3 B0 B4 17 9F 85 97 5F") { + this shouldBe instanceOf() + } + } + + @Test + fun `invalid data`() = runBlockingTest { + create("abcd") { + this shouldBe null + } + } +} \ No newline at end of file diff --git a/app/src/test/java/eu/darken/cap/pods/core/airpods/BaseAirPodsTest.kt b/app/src/test/java/eu/darken/cap/pods/core/airpods/BaseAirPodsTest.kt new file mode 100644 index 00000000..4358e547 --- /dev/null +++ b/app/src/test/java/eu/darken/cap/pods/core/airpods/BaseAirPodsTest.kt @@ -0,0 +1,58 @@ +package eu.darken.cap.pods.core.airpods + +import android.bluetooth.BluetoothDevice +import android.bluetooth.le.ScanRecord +import android.bluetooth.le.ScanResult +import eu.darken.cap.pods.core.PodDevice +import io.mockk.MockKAnnotations +import io.mockk.every +import io.mockk.impl.annotations.MockK +import org.junit.jupiter.api.BeforeEach +import testhelper.BaseTest + +abstract class BaseAirPodsTest : BaseTest() { + + @MockK lateinit var scanResult: ScanResult + @MockK lateinit var scanRecord: ScanRecord + @MockK lateinit var device: BluetoothDevice + + val factory = AirPodsFactory( + proximityPairingDecoder = ProximityPairing.Decoder(), + continuityProtocolDecoder = ContinuityProtocol.Decoder(), + ) + + @BeforeEach + fun setup() { + MockKAnnotations.init(this) + every { scanResult.scanRecord } returns scanRecord + every { scanResult.rssi } returns -66 + every { scanResult.timestampNanos } returns 136136027721826 + every { scanResult.device } returns device + every { device.address } returns "77:49:4C:D8:25:0C" + } + + suspend inline fun create(hex: String, block: T.() -> Unit) { + val trimmed = hex + .replace(" ", "") + .replace(">", "") + .replace("<", "") + require(trimmed.length % 2 == 0) { "Not a HEX string" } + val bytes = trimmed.chunked(2).map { it.toInt(16).toByte() }.toByteArray() + mockData(bytes) + block.invoke(factory.create(scanResult) as T) + } + + fun mockData(hex: String) { + val trimmed = hex + .replace(" ", "") + .replace(">", "") + .replace("<", "") + require(trimmed.length % 2 == 0) { "Not a HEX string" } + val bytes = trimmed.chunked(2).map { it.toInt(16).toByte() }.toByteArray() + return mockData(bytes) + } + + fun mockData(data: ByteArray) { + every { scanRecord.getManufacturerSpecificData(ContinuityProtocol.APPLE_COMPANY_IDENTIFIER) } returns data + } +} \ No newline at end of file diff --git a/app/src/test/java/eu/darken/cap/pods/core/airpods/models/AirPodsGen1Test.kt b/app/src/test/java/eu/darken/cap/pods/core/airpods/models/AirPodsGen1Test.kt new file mode 100644 index 00000000..512ad1fb --- /dev/null +++ b/app/src/test/java/eu/darken/cap/pods/core/airpods/models/AirPodsGen1Test.kt @@ -0,0 +1,42 @@ +package eu.darken.cap.pods.core.airpods.models + +import eu.darken.cap.pods.core.airpods.AirPodsDevice +import eu.darken.cap.pods.core.airpods.BaseAirPodsTest +import io.kotest.matchers.shouldBe +import kotlinx.coroutines.test.runBlockingTest +import org.junit.jupiter.api.Test + +class AirPodsGen1Test : BaseAirPodsTest() { + + // Test data from https://github.com/adolfintel/OpenPods/issues/39#issuecomment-557664269 + @Test + fun `fake airpods`() = runBlockingTest { + create("07 19 01 02 20 55 AF 56 31 00 00 6F E4 DF 10 AF 10 60 81 03 3B 76 D9 C7 11 22 88") { + rawPrefix shouldBe 0x01.toUByte() + rawDeviceModel shouldBe 0x0220.toUShort() + rawStatus shouldBe 0x55.toUByte() + rawPodsBattery shouldBe 0xAF.toUByte() + rawCaseBattery shouldBe 0x56.toUByte() + rawCaseLidState shouldBe 0x31.toUByte() + rawDeviceColor shouldBe 0x00.toUByte() + rawSuffix shouldBe 0x00.toUByte() + + batteryLeftPodPercent shouldBe 1.0f + batteryRightPodPercent shouldBe null + + isCaseCharging shouldBe true + isLeftPodCharging shouldBe false + isRightPodCharging shouldBe true + + isLeftPodInEar shouldBe false + isRightPodInEar shouldBe false + batteryCasePercent shouldBe 0.6f + + caseLidState shouldBe AirPodsDevice.LidState.OPEN + + connectionState shouldBe AirPodsDevice.ConnectionState.DISCONNECTED + + deviceColor shouldBe AirPodsDevice.DeviceColor.WHITE + } + } +} \ No newline at end of file diff --git a/app/src/test/java/eu/darken/cap/pods/core/airpods/models/AirPodsGen2Test.kt b/app/src/test/java/eu/darken/cap/pods/core/airpods/models/AirPodsGen2Test.kt new file mode 100644 index 00000000..8f732edc --- /dev/null +++ b/app/src/test/java/eu/darken/cap/pods/core/airpods/models/AirPodsGen2Test.kt @@ -0,0 +1,41 @@ +package eu.darken.cap.pods.core.airpods.models + +import eu.darken.cap.pods.core.airpods.AirPodsDevice +import eu.darken.cap.pods.core.airpods.BaseAirPodsTest +import io.kotest.matchers.shouldBe +import kotlinx.coroutines.test.runBlockingTest +import org.junit.jupiter.api.Test + +class AirPodsGen2Test : BaseAirPodsTest() { + + @Test + fun `random Neighbor AirPodsGen2`() = runBlockingTest { + create("07 19 01 0F 20 02 F9 8F 01 00 05 F2 7E 14 E0 54 0A 53 69 5B 7D F2 15 1F D7 B1 12") { + rawPrefix shouldBe 0x01.toUByte() + rawDeviceModel shouldBe 0x0F20.toUShort() + rawStatus shouldBe 0x02.toUByte() + rawPodsBattery shouldBe 0xF9.toUByte() + rawCaseBattery shouldBe 0x8F.toUByte() + rawCaseLidState shouldBe 0x01.toUByte() + rawDeviceColor shouldBe 0x00.toUByte() + rawSuffix shouldBe 0x05.toUByte() + + batteryLeftPodPercent shouldBe null + batteryRightPodPercent shouldBe 0.9f + + isCaseCharging shouldBe false + isLeftPodCharging shouldBe false + isRightPodCharging shouldBe false + + isLeftPodInEar shouldBe false + isRightPodInEar shouldBe true + batteryCasePercent shouldBe null + + caseLidState shouldBe AirPodsDevice.LidState.NOT_IN_CASE + + connectionState shouldBe AirPodsDevice.ConnectionState.MUSIC + + deviceColor shouldBe AirPodsDevice.DeviceColor.WHITE + } + } +} \ No newline at end of file diff --git a/app/src/test/java/eu/darken/cap/pods/core/airpods/models/AirPodsProTest.kt b/app/src/test/java/eu/darken/cap/pods/core/airpods/models/AirPodsProTest.kt new file mode 100644 index 00000000..10da59ca --- /dev/null +++ b/app/src/test/java/eu/darken/cap/pods/core/airpods/models/AirPodsProTest.kt @@ -0,0 +1,194 @@ +package eu.darken.cap.pods.core.airpods.models + +import eu.darken.cap.pods.core.airpods.AirPodsDevice +import eu.darken.cap.pods.core.airpods.BaseAirPodsTest +import io.kotest.matchers.shouldBe +import kotlinx.coroutines.test.runBlockingTest +import org.junit.jupiter.api.Test + +class AirPodsProTest : BaseAirPodsTest() { + + @Test + fun `test AirPods Pro - default changed and in case`() = runBlockingTest { + create("07 19 01 0E 20 54 AA B5 31 00 00 E0 0C A7 8A 60 4B D3 7D F4 60 4F 2C 73 E9 A7 F4") { + + rawPrefix shouldBe 0x01.toUByte() + rawDeviceModel shouldBe 0x0e20.toUShort() + rawStatus shouldBe 0x54.toUByte() + rawPodsBattery shouldBe 0xAA.toUByte() + rawCaseBattery shouldBe 0xB5.toUByte() + rawCaseLidState shouldBe 0x31.toUByte() + rawDeviceColor shouldBe 0x00.toUByte() + rawSuffix shouldBe 0x00.toUByte() + + microPhonePod shouldBe AirPodsDevice.Pod.RIGHT + + batteryLeftPodPercent shouldBe 1.0f + batteryRightPodPercent shouldBe 1.0f + + isCaseCharging shouldBe false + isRightPodCharging shouldBe true + isLeftPodCharging shouldBe true + batteryCasePercent shouldBe 0.5f + + deviceColor shouldBe AirPodsDevice.DeviceColor.WHITE + } + } + + @Test + fun `test AirPods from my downstairs neighbour`() = runBlockingTest { + create("07 19 01 0E 20 00 F3 8F 02 00 04 79 C6 3F F9 C3 15 D9 11 A1 3C B1 58 66 B9 8B 67") { + microPhonePod shouldBe AirPodsDevice.Pod.RIGHT + + batteryLeftPodPercent shouldBe null + batteryRightPodPercent shouldBe 0.3f + + isCaseCharging shouldBe false + isRightPodCharging shouldBe false + isLeftPodCharging shouldBe false + batteryCasePercent shouldBe null + + deviceColor shouldBe AirPodsDevice.DeviceColor.WHITE + } + } + + // Test data from https://github.com/adolfintel/OpenPods/issues/34#issuecomment-565894487 + @Test + fun `various AirPods Pro messages`() = runBlockingTest { + create("0719010e202b668f01000500000000000000000000000000000000") { + batteryLeftPodPercent shouldBe 0.6f + batteryRightPodPercent shouldBe 0.6f + + isCaseCharging shouldBe false + isRightPodCharging shouldBe false + isLeftPodCharging shouldBe false + batteryCasePercent shouldBe null + + deviceColor shouldBe AirPodsDevice.DeviceColor.WHITE + } + + create("0719010e202b668f01000500000000000000000000000000000000") { + batteryLeftPodPercent shouldBe 0.6f + batteryRightPodPercent shouldBe 0.6f + + isCaseCharging shouldBe false + isRightPodCharging shouldBe false + isLeftPodCharging shouldBe false + batteryCasePercent shouldBe null + + deviceColor shouldBe AirPodsDevice.DeviceColor.WHITE + } + + create("0719010e202b668f01000400000000000000000000000000000000") { + batteryLeftPodPercent shouldBe 0.6f + batteryRightPodPercent shouldBe 0.6f + + isCaseCharging shouldBe false + isRightPodCharging shouldBe false + isLeftPodCharging shouldBe false + batteryCasePercent shouldBe null + + deviceColor shouldBe AirPodsDevice.DeviceColor.WHITE + } + + create("0719010e200b668f01000500000000000000000000000000000000") { + batteryLeftPodPercent shouldBe 0.6f + batteryRightPodPercent shouldBe 0.6f + + isCaseCharging shouldBe false + isRightPodCharging shouldBe false + isLeftPodCharging shouldBe false + batteryCasePercent shouldBe null + + deviceColor shouldBe AirPodsDevice.DeviceColor.WHITE + } + + create("0719010e2003668f01000500000000000000000000000000000000") { + batteryLeftPodPercent shouldBe 0.6f + batteryRightPodPercent shouldBe 0.6f + + isCaseCharging shouldBe false + isRightPodCharging shouldBe false + isLeftPodCharging shouldBe false + batteryCasePercent shouldBe null + + deviceColor shouldBe AirPodsDevice.DeviceColor.WHITE + } + + create("0719010e2001668f01000500000000000000000000000000000000") { + batteryLeftPodPercent shouldBe 0.6f + batteryRightPodPercent shouldBe 0.6f + + isCaseCharging shouldBe false + isRightPodCharging shouldBe false + isLeftPodCharging shouldBe false + batteryCasePercent shouldBe null + + deviceColor shouldBe AirPodsDevice.DeviceColor.WHITE + } + + create("0719010e2009668f01000500000000000000000000000000000000") { + batteryLeftPodPercent shouldBe 0.6f + batteryRightPodPercent shouldBe 0.6f + + isCaseCharging shouldBe false + isRightPodCharging shouldBe false + isLeftPodCharging shouldBe false + batteryCasePercent shouldBe null + + deviceColor shouldBe AirPodsDevice.DeviceColor.WHITE + } + + create("0719010e2053669653000500000000000000000000000000000000") { + batteryLeftPodPercent shouldBe 0.6f + batteryRightPodPercent shouldBe 0.6f + + isCaseCharging shouldBe false + isRightPodCharging shouldBe true + isLeftPodCharging shouldBe false + batteryCasePercent shouldBe 0.6f + + deviceColor shouldBe AirPodsDevice.DeviceColor.WHITE + } + + create("0719010e203366a602000500000000000000000000000000000000") { + batteryLeftPodPercent shouldBe 0.6f + batteryRightPodPercent shouldBe 0.6f + + isCaseCharging shouldBe false + isRightPodCharging shouldBe true + isLeftPodCharging shouldBe false + batteryCasePercent shouldBe 0.6f + + deviceColor shouldBe AirPodsDevice.DeviceColor.WHITE + } + + create("0719010e202b768f02000500000000000000000000000000000000") { + batteryLeftPodPercent shouldBe 0.6f + batteryRightPodPercent shouldBe 0.7f + + isCaseCharging shouldBe false + isRightPodCharging shouldBe false + isLeftPodCharging shouldBe false + batteryCasePercent shouldBe null + + deviceColor shouldBe AirPodsDevice.DeviceColor.WHITE + } + } + + // Test data from https://github.com/adolfintel/OpenPods/issues/39#issuecomment-557664269 + @Test + fun `fake airpods`() = runBlockingTest { + create("071901022055AA563100006FE4DF10AF106081033B76D9C7112288") { + batteryLeftPodPercent shouldBe 1.0f + batteryRightPodPercent shouldBe 1.0f + + isCaseCharging shouldBe true + isRightPodCharging shouldBe true + isLeftPodCharging shouldBe false + batteryCasePercent shouldBe 0.6f + + deviceColor shouldBe AirPodsDevice.DeviceColor.WHITE + } + } +} \ No newline at end of file diff --git a/app/src/test/java/testhelper/BaseTest.kt b/app/src/test/java/testhelper/BaseTest.kt new file mode 100644 index 00000000..46b3b362 --- /dev/null +++ b/app/src/test/java/testhelper/BaseTest.kt @@ -0,0 +1,29 @@ +package testhelper + +import eu.darken.cap.common.debug.logging.Logging +import eu.darken.cap.common.debug.logging.Logging.Priority.VERBOSE +import eu.darken.cap.common.debug.logging.log +import io.mockk.unmockkAll +import org.junit.jupiter.api.AfterAll +import testhelpers.logging.JUnitLogger + + +open class BaseTest { + init { + Logging.clearAll() + Logging.install(JUnitLogger()) + testClassName = this.javaClass.simpleName + } + + companion object { + private var testClassName: String? = null + + @JvmStatic + @AfterAll + fun onTestClassFinished() { + unmockkAll() + log(testClassName!!, VERBOSE) { "onTestClassFinished()" } + Logging.clearAll() + } + } +} diff --git a/app/src/test/java/testhelper/coroutine/CoroutinesTestExtension.kt b/app/src/test/java/testhelper/coroutine/CoroutinesTestExtension.kt new file mode 100644 index 00000000..900333f2 --- /dev/null +++ b/app/src/test/java/testhelper/coroutine/CoroutinesTestExtension.kt @@ -0,0 +1,26 @@ +package testhelper.coroutine + +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.test.TestCoroutineDispatcher +import kotlinx.coroutines.test.TestCoroutineScope +import kotlinx.coroutines.test.resetMain +import kotlinx.coroutines.test.setMain +import org.junit.jupiter.api.extension.AfterEachCallback +import org.junit.jupiter.api.extension.BeforeEachCallback +import org.junit.jupiter.api.extension.ExtensionContext + +@ExperimentalCoroutinesApi +class CoroutinesTestExtension( + private val dispatcher: TestCoroutineDispatcher = TestCoroutineDispatcher() +) : BeforeEachCallback, AfterEachCallback, TestCoroutineScope by TestCoroutineScope(dispatcher) { + + override fun beforeEach(context: ExtensionContext?) { + Dispatchers.setMain(dispatcher) + } + + override fun afterEach(context: ExtensionContext?) { + cleanupTestCoroutines() + Dispatchers.resetMain() + } +} diff --git a/app/src/test/java/testhelper/coroutine/TestDispatcherProvider.kt b/app/src/test/java/testhelper/coroutine/TestDispatcherProvider.kt new file mode 100644 index 00000000..de0e17cd --- /dev/null +++ b/app/src/test/java/testhelper/coroutine/TestDispatcherProvider.kt @@ -0,0 +1,23 @@ +package testhelper.coroutine + +import eu.darken.cap.common.coroutine.DispatcherProvider +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlin.coroutines.CoroutineContext + +class TestDispatcherProvider(private val context: CoroutineContext? = null) : DispatcherProvider { + override val Default: CoroutineContext + get() = context ?: Dispatchers.Unconfined + override val Main: CoroutineContext + get() = context ?: Dispatchers.Unconfined + override val MainImmediate: CoroutineContext + get() = context ?: Dispatchers.Unconfined + override val Unconfined: CoroutineContext + get() = context ?: Dispatchers.Unconfined + override val IO: CoroutineContext + get() = context ?: Dispatchers.Unconfined +} + +fun CoroutineScope.asDispatcherProvider() = this.coroutineContext.asDispatcherProvider() + +fun CoroutineContext.asDispatcherProvider() = TestDispatcherProvider(context = this) diff --git a/app/src/test/java/testhelper/coroutine/TestExtensions.kt b/app/src/test/java/testhelper/coroutine/TestExtensions.kt new file mode 100644 index 00000000..624ff6f7 --- /dev/null +++ b/app/src/test/java/testhelper/coroutine/TestExtensions.kt @@ -0,0 +1,49 @@ +package testhelper.coroutine + +import eu.darken.cap.common.debug.logging.log +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.runBlocking +import kotlinx.coroutines.test.TestCoroutineScope +import kotlinx.coroutines.test.UncompletedCoroutinesError +import kotlinx.coroutines.test.runBlockingTest +import kotlin.coroutines.CoroutineContext +import kotlin.coroutines.EmptyCoroutineContext + +/** + * If you have a test that uses a coroutine that never stops, you may use this. + */ + +@ExperimentalCoroutinesApi // Since 1.2.1, tentatively till 1.3.0 +fun TestCoroutineScope.runBlockingTest2( + allowUncompleted: Boolean = false, + block: suspend TestCoroutineScope.() -> Unit +): Unit = runBlockingTest2( + allowUncompleted = allowUncompleted, + context = coroutineContext, + testBody = block +) + +fun runBlockingTest2( + allowUncompleted: Boolean = false, + context: CoroutineContext = EmptyCoroutineContext, + testBody: suspend TestCoroutineScope.() -> Unit +) { + try { + runBlocking { + try { + runBlockingTest( + context = context, + testBody = testBody + ) + } catch (e: UncompletedCoroutinesError) { + if (!allowUncompleted) throw e + else log { "Ignoring active job." } + } + } + } catch (e: Exception) { + if (!allowUncompleted || (e.message != "This job has not completed yet")) { + throw e + } + } +} + diff --git a/app/src/test/java/testhelper/flow/FlowTest.kt b/app/src/test/java/testhelper/flow/FlowTest.kt new file mode 100644 index 00000000..cdd9c494 --- /dev/null +++ b/app/src/test/java/testhelper/flow/FlowTest.kt @@ -0,0 +1,101 @@ +package testhelper.flow + +import eu.darken.cap.common.debug.logging.Logging.Priority.WARN +import eu.darken.cap.common.debug.logging.asLog +import eu.darken.cap.common.debug.logging.log +import kotlinx.coroutines.* +import kotlinx.coroutines.channels.BufferOverflow +import kotlinx.coroutines.flow.* +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock +import kotlinx.coroutines.test.TestCoroutineScope + +fun Flow.test( + tag: String? = null, + startOnScope: CoroutineScope = TestCoroutineScope() +): TestCollector = createTest(tag ?: "FlowTest").start(scope = startOnScope) + +fun Flow.createTest( + tag: String? = null +): TestCollector = TestCollector(this, tag ?: "FlowTest") + +class TestCollector( + private val flow: Flow, + private val tag: String + +) { + private var error: Throwable? = null + private lateinit var job: Job + private val cache = MutableSharedFlow( + replay = Int.MAX_VALUE, + extraBufferCapacity = Int.MAX_VALUE, + onBufferOverflow = BufferOverflow.SUSPEND + ) + private var latestInternal: T? = null + private val collectedValuesMutex = Mutex() + private val collectedValues = mutableListOf() + + var silent = false + + fun start(scope: CoroutineScope) = apply { + flow + .buffer(capacity = Int.MAX_VALUE) + .onStart { log(tag) { "Setting up." } } + .onCompletion { log(tag) { "Final." } } + .onEach { + collectedValuesMutex.withLock { + if (!silent) log(tag) { "Collecting: $it" } + latestInternal = it + collectedValues.add(it) + cache.emit(it) + } + } + .catch { e -> + log(tag, WARN) { "Caught error: ${e.asLog()}" } + error = e + } + .launchIn(scope) + .also { job = it } + } + + fun emissions(): Flow = cache + + val latestValue: T? + get() = collectedValues.last() + + val latestValues: List + get() = collectedValues + + fun await( + timeout: Long = 10_000, + condition: (List, T) -> Boolean + ): T = runBlocking { + withTimeout(timeMillis = timeout) { + emissions().first { + condition(collectedValues, it) + } + } + } + + suspend fun awaitFinal(cancel: Boolean = false) = apply { + if (cancel) cancel() + try { + job.join() + } catch (e: Exception) { + error = e + } + } + + suspend fun assertNoErrors() = apply { + awaitFinal() + require(error == null) { "Error was not null: $error" } + } + + fun cancel() { + if (job.isCompleted) throw IllegalStateException("Flow is already canceled.") + + runBlocking { + job.cancelAndJoin() + } + } +} diff --git a/app/src/test/java/testhelper/livedata/InstantExecutorExtension.kt b/app/src/test/java/testhelper/livedata/InstantExecutorExtension.kt new file mode 100644 index 00000000..debd59d9 --- /dev/null +++ b/app/src/test/java/testhelper/livedata/InstantExecutorExtension.kt @@ -0,0 +1,26 @@ +package testhelper.livedata + +import androidx.arch.core.executor.ArchTaskExecutor +import androidx.arch.core.executor.TaskExecutor +import org.junit.jupiter.api.extension.AfterEachCallback +import org.junit.jupiter.api.extension.BeforeEachCallback +import org.junit.jupiter.api.extension.ExtensionContext + +class InstantExecutorExtension : BeforeEachCallback, AfterEachCallback { + + override fun beforeEach(context: ExtensionContext?) { + ArchTaskExecutor.getInstance().setDelegate( + object : TaskExecutor() { + override fun executeOnDiskIO(runnable: Runnable) = runnable.run() + + override fun postToMainThread(runnable: Runnable) = runnable.run() + + override fun isMainThread(): Boolean = true + } + ) + } + + override fun afterEach(context: ExtensionContext?) { + ArchTaskExecutor.getInstance().setDelegate(null) + } +} diff --git a/app/src/test/java/testhelper/preferences/MockSharedPreferencesTest.kt b/app/src/test/java/testhelper/preferences/MockSharedPreferencesTest.kt new file mode 100644 index 00000000..f69e990e --- /dev/null +++ b/app/src/test/java/testhelper/preferences/MockSharedPreferencesTest.kt @@ -0,0 +1,22 @@ +package testhelper.preferences + +import androidx.core.content.edit +import io.kotest.matchers.shouldBe +import org.junit.jupiter.api.Test +import testhelper.BaseTest +import testhelpers.preferences.MockSharedPreferences + +class MockSharedPreferencesTest : BaseTest() { + + private fun createInstance() = MockSharedPreferences() + + @Test + fun `test boolean insertion`() { + val prefs = createInstance() + prefs.dataMapPeek shouldBe emptyMap() + prefs.getBoolean("key", true) shouldBe true + prefs.edit { putBoolean("key", false) } + prefs.getBoolean("key", true) shouldBe false + prefs.dataMapPeek["key"] shouldBe false + } +} diff --git a/app/src/testShared/java/testhelpers/BaseTestInstrumentation.kt b/app/src/testShared/java/testhelpers/BaseTestInstrumentation.kt new file mode 100644 index 00000000..8f9a7776 --- /dev/null +++ b/app/src/testShared/java/testhelpers/BaseTestInstrumentation.kt @@ -0,0 +1,29 @@ +package testhelpers + +import eu.darken.cap.common.debug.logging.Logging +import eu.darken.cap.common.debug.logging.Logging.Priority.VERBOSE +import eu.darken.cap.common.debug.logging.log +import io.mockk.unmockkAll +import org.junit.AfterClass +import testhelpers.logging.JUnitLogger + +abstract class BaseTestInstrumentation { + + init { + Logging.clearAll() + Logging.install(JUnitLogger()) + testClassName = this.javaClass.simpleName + } + + companion object { + private var testClassName: String? = null + + @JvmStatic + @AfterClass + fun onTestClassFinished() { + unmockkAll() + log(testClassName!!, VERBOSE) { "onTestClassFinished()" } + Logging.clearAll() + } + } +} diff --git a/app/src/testShared/java/testhelpers/IsAUnitTest.kt b/app/src/testShared/java/testhelpers/IsAUnitTest.kt new file mode 100644 index 00000000..2af3e4cb --- /dev/null +++ b/app/src/testShared/java/testhelpers/IsAUnitTest.kt @@ -0,0 +1,3 @@ +package testhelpers + +class IsAUnitTest diff --git a/app/src/testShared/java/testhelpers/logging/JUnitLogger.kt b/app/src/testShared/java/testhelpers/logging/JUnitLogger.kt new file mode 100644 index 00000000..d3983964 --- /dev/null +++ b/app/src/testShared/java/testhelpers/logging/JUnitLogger.kt @@ -0,0 +1,13 @@ +package testhelpers.logging + +import eu.darken.cap.common.debug.logging.Logging + +class JUnitLogger(private val minLogLevel: Logging.Priority = Logging.Priority.VERBOSE) : Logging.Logger { + + override fun isLoggable(priority: Logging.Priority): Boolean = priority.intValue >= minLogLevel.intValue + + override fun log(priority: Logging.Priority, tag: String, message: String, metaData: Map?) { + println("${System.currentTimeMillis()} ${priority.shortLabel}/$tag: $message") + } + +} diff --git a/app/src/testShared/java/testhelpers/preferences/MockFlowPreference.kt b/app/src/testShared/java/testhelpers/preferences/MockFlowPreference.kt new file mode 100644 index 00000000..1e908c1b --- /dev/null +++ b/app/src/testShared/java/testhelpers/preferences/MockFlowPreference.kt @@ -0,0 +1,21 @@ +package testhelpers.preferences + +import eu.darken.cap.common.preferences.FlowPreference +import io.mockk.every +import io.mockk.mockk +import kotlinx.coroutines.flow.MutableStateFlow + +fun mockFlowPreference( + defaultValue: T +): FlowPreference { + val instance = mockk>() + val flow = MutableStateFlow(defaultValue) + every { instance.flow } answers { flow } + every { instance.value } answers { flow.value } + every { instance.update(any()) } answers { + val updateCall = arg<(T) -> T>(0) + flow.value = updateCall(flow.value) + } + + return instance +} diff --git a/app/src/testShared/java/testhelpers/preferences/MockSharedPreferences.kt b/app/src/testShared/java/testhelpers/preferences/MockSharedPreferences.kt new file mode 100644 index 00000000..c094e560 --- /dev/null +++ b/app/src/testShared/java/testhelpers/preferences/MockSharedPreferences.kt @@ -0,0 +1,99 @@ +package testhelpers.preferences + +import android.content.SharedPreferences + +class MockSharedPreferences : SharedPreferences { + private val listeners = mutableListOf() + private val dataMap = mutableMapOf() + val dataMapPeek: Map + get() = dataMap.toMap() + + override fun getAll(): MutableMap = dataMap + + override fun getString(key: String, defValue: String?): String? = + dataMap[key] as? String ?: defValue + + override fun getStringSet(key: String, defValues: MutableSet?): MutableSet { + throw NotImplementedError() + } + + override fun getInt(key: String, defValue: Int): Int = + dataMap[key] as? Int ?: defValue + + override fun getLong(key: String, defValue: Long): Long = + dataMap[key] as? Long ?: defValue + + override fun getFloat(key: String, defValue: Float): Float { + throw NotImplementedError() + } + + override fun getBoolean(key: String, defValue: Boolean): Boolean = + dataMap[key] as? Boolean ?: defValue + + override fun contains(key: String): Boolean = dataMap.contains(key) + + override fun edit(): SharedPreferences.Editor = createEditor(dataMap.toMap()) { newData -> + dataMap.clear() + dataMap.putAll(newData) + } + + override fun registerOnSharedPreferenceChangeListener(listener: SharedPreferences.OnSharedPreferenceChangeListener) { + listeners.add(listener) + } + + override fun unregisterOnSharedPreferenceChangeListener(listener: SharedPreferences.OnSharedPreferenceChangeListener) { + listeners.remove(listener) + } + + private fun createEditor( + toEdit: Map, + onSave: (Map) -> Unit + ): SharedPreferences.Editor { + return object : SharedPreferences.Editor { + private val editorData = toEdit.toMutableMap() + override fun putString(key: String, value: String?): SharedPreferences.Editor = apply { + value?.let { editorData[key] = it } ?: editorData.remove(key) + } + + override fun putStringSet( + key: String?, + values: MutableSet? + ): SharedPreferences.Editor { + throw NotImplementedError() + } + + override fun putInt(key: String, value: Int): SharedPreferences.Editor = apply { + editorData[key] = value + } + + override fun putLong(key: String, value: Long): SharedPreferences.Editor = apply { + editorData[key] = value + } + + override fun putFloat(key: String, value: Float): SharedPreferences.Editor = apply { + editorData[key] = value + } + + override fun putBoolean(key: String, value: Boolean): SharedPreferences.Editor = apply { + editorData[key] = value + } + + override fun remove(key: String): SharedPreferences.Editor = apply { + editorData.remove(key) + } + + override fun clear(): SharedPreferences.Editor = apply { + editorData.clear() + } + + override fun commit(): Boolean { + onSave(editorData) + return true + } + + override fun apply() { + onSave(editorData) + } + } + } +} diff --git a/build.gradle b/build.gradle new file mode 100644 index 00000000..29712258 --- /dev/null +++ b/build.gradle @@ -0,0 +1,55 @@ +// Top-level build file where you can add configuration options common to all sub-projects/modules. +buildscript { + ext.buildConfig = [ + 'compileSdk': 31, + 'minSdk' : 21, + 'targetSdk' : 31, + + 'version' : [ + 'major': 0, + 'minor': 0, + 'patch': 1, + 'build': 0, + ], + ] + + ext.buildConfig.version['name'] = "${buildConfig.version.major}.${buildConfig.version.minor}.${buildConfig.version.patch}" + ext.buildConfig.version['fullName'] = "${buildConfig.version.name}.${buildConfig.version.build}" + ext.buildConfig.version['code'] = buildConfig.version.major * 1000000 + buildConfig.version.minor * 10000 + buildConfig.version.patch * 100 + buildConfig.version.build + + ext.versions = [ + 'kotlin' : [ + 'core' : '1.6.10', + 'coroutines': '1.5.1' + ], + 'dagger' : [ + 'core': '2.40.5' + ], + 'androidx' : [ + 'navigation': '2.3.5' + ], + ] + + repositories { + google() + mavenCentral() + } + dependencies { + classpath 'com.android.tools.build:gradle:7.0.4' + classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${versions.kotlin.core}" + classpath "com.google.dagger:hilt-android-gradle-plugin:${versions.dagger.core}" + classpath "androidx.navigation:navigation-safe-args-gradle-plugin:${versions.androidx.navigation}" + classpath 'com.bugsnag:bugsnag-android-gradle-plugin:7.0.0' + } +} + +allprojects { + repositories { + google() + mavenCentral() + } +} + +task clean(type: Delete) { + delete rootProject.buildDir +} \ No newline at end of file diff --git a/gradle.properties b/gradle.properties new file mode 100644 index 00000000..25217527 --- /dev/null +++ b/gradle.properties @@ -0,0 +1,19 @@ +# Project-wide Gradle settings. +# IDE (e.g. Android Studio) users: +# Gradle settings configured through the IDE *will override* +# any settings specified in this file. +# For more details on how to configure your build environment visit +# http://www.gradle.org/docs/current/userguide/build_environment.html +# Specifies the JVM arguments used for the daemon process. +# The setting is particularly useful for tweaking memory settings. +org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8 +# When configured, Gradle will run in incubating parallel mode. +# This option should only be used with decoupled projects. More details, visit +# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects +# org.gradle.parallel=true +# AndroidX package structure to make it clearer which packages are bundled with the +# Android operating system, and which are packaged with your app"s APK +# https://developer.android.com/topic/libraries/support-library/androidx-rn +android.useAndroidX=true +# Kotlin code style for this project: "official" or "obsolete": +kotlin.code.style=official \ No newline at end of file diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 0000000000000000000000000000000000000000..f6b961fd5a86aa5fbfe90f707c3138408be7c718 GIT binary patch literal 54329 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

<5G2M1WZP5 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 F{|7XC?P&l2 literal 0 HcmV?d00001 diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 00000000..516b361d --- /dev/null +++ b/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,6 @@ +#Thu May 13 21:51:43 CEST 2021 +distributionBase=GRADLE_USER_HOME +distributionUrl=https\://services.gradle.org/distributions/gradle-7.0.2-bin.zip +distributionPath=wrapper/dists +zipStorePath=wrapper/dists +zipStoreBase=GRADLE_USER_HOME diff --git a/gradlew b/gradlew new file mode 100755 index 00000000..cccdd3d5 --- /dev/null +++ b/gradlew @@ -0,0 +1,172 @@ +#!/usr/bin/env sh + +############################################################################## +## +## Gradle start up script for UN*X +## +############################################################################## + +# Attempt to set APP_HOME +# Resolve links: $0 may be a link +PRG="$0" +# Need this for relative symlinks. +while [ -h "$PRG" ] ; do + ls=`ls -ld "$PRG"` + link=`expr "$ls" : '.*-> \(.*\)$'` + if expr "$link" : '/.*' > /dev/null; then + PRG="$link" + else + PRG=`dirname "$PRG"`"/$link" + fi +done +SAVED="`pwd`" +cd "`dirname \"$PRG\"`/" >/dev/null +APP_HOME="`pwd -P`" +cd "$SAVED" >/dev/null + +APP_NAME="Gradle" +APP_BASE_NAME=`basename "$0"` + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS="" + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD="maximum" + +warn () { + echo "$*" +} + +die () { + echo + echo "$*" + echo + exit 1 +} + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "`uname`" in + CYGWIN* ) + cygwin=true + ;; + Darwin* ) + darwin=true + ;; + MINGW* ) + msys=true + ;; + NONSTOP* ) + nonstop=true + ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + else + JAVACMD="$JAVA_HOME/bin/java" + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD="java" + which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi + +# Increase the maximum file descriptors if we can. +if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then + MAX_FD_LIMIT=`ulimit -H -n` + if [ $? -eq 0 ] ; then + if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then + MAX_FD="$MAX_FD_LIMIT" + fi + ulimit -n $MAX_FD + if [ $? -ne 0 ] ; then + warn "Could not set maximum file descriptor limit: $MAX_FD" + fi + else + warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" + fi +fi + +# For Darwin, add options to specify how the application appears in the dock +if $darwin; then + GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" +fi + +# For Cygwin, switch paths to Windows format before running java +if $cygwin ; then + APP_HOME=`cygpath --path --mixed "$APP_HOME"` + CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` + JAVACMD=`cygpath --unix "$JAVACMD"` + + # We build the pattern for arguments to be converted via cygpath + ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` + SEP="" + for dir in $ROOTDIRSRAW ; do + ROOTDIRS="$ROOTDIRS$SEP$dir" + SEP="|" + done + OURCYGPATTERN="(^($ROOTDIRS))" + # Add a user-defined pattern to the cygpath arguments + if [ "$GRADLE_CYGPATTERN" != "" ] ; then + OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" + fi + # Now convert the arguments - kludge to limit ourselves to /bin/sh + i=0 + for arg in "$@" ; do + CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` + CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option + + if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition + eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` + else + eval `echo args$i`="\"$arg\"" + fi + i=$((i+1)) + done + case $i in + (0) set -- ;; + (1) set -- "$args0" ;; + (2) set -- "$args0" "$args1" ;; + (3) set -- "$args0" "$args1" "$args2" ;; + (4) set -- "$args0" "$args1" "$args2" "$args3" ;; + (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; + (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; + (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; + (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; + (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; + esac +fi + +# Escape application args +save () { + for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done + echo " " +} +APP_ARGS=$(save "$@") + +# Collect all arguments for the java command, following the shell quoting and substitution rules +eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" + +# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong +if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then + cd "$(dirname "$0")" +fi + +exec "$JAVACMD" "$@" diff --git a/gradlew.bat b/gradlew.bat new file mode 100644 index 00000000..f9553162 --- /dev/null +++ b/gradlew.bat @@ -0,0 +1,84 @@ +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS= + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto init + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto init + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:init +@rem Get command-line arguments, handling Windows variants + +if not "%OS%" == "Windows_NT" goto win9xME_args + +:win9xME_args +@rem Slurp the command line arguments. +set CMD_LINE_ARGS= +set _SKIP=2 + +:win9xME_args_slurp +if "x%~1" == "x" goto execute + +set CMD_LINE_ARGS=%* + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% + +:end +@rem End local scope for the variables with windows NT shell +if "%ERRORLEVEL%"=="0" goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 +exit /b 1 + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/local.properties b/local.properties new file mode 100644 index 00000000..a943e23f --- /dev/null +++ b/local.properties @@ -0,0 +1,10 @@ +## This file is automatically generated by Android Studio. +# Do not modify this file -- YOUR CHANGES WILL BE ERASED! +# +# This file should *NOT* be checked into Version Control Systems, +# as it contains information specific to your local configuration. +# +# Location of the SDK. This is only used by Gradle. +# For customization when using a Version Control System, please read the +# header note. +sdk.dir=/home/darken/Android/sdk \ No newline at end of file diff --git a/settings.gradle b/settings.gradle new file mode 100644 index 00000000..4fc256ae --- /dev/null +++ b/settings.gradle @@ -0,0 +1,2 @@ +rootProject.name = "Companion App for AirPods" +include ':app'