Merge pull request #2 from FeernandoOFF/feature/shake-to-open

Feature/shake to open

Author: FeernandoOFF

.idea/deviceManager.xml

@@ -10,7 +10,7 @@ inspect DataStore preferences, monitor logs, and create custom debugging modules
 Currently, there are a couple of other debug menu libraries,
 like [Lens-Logger](https://github.com/farhazulMullick/Lens-Logger/tree/feat/log-datastore)
 and [Beagle](https://github.com/pandulapeter/beagle), however, they were either focused on a limited set of features or
-interfered with the LayoutInpector in Android Studio.
+interfered with the LayoutInspector in Android Studio.
 
 This library offers a lightweight, easy-to-use, and modular debug menu that you can easily integrate into your app and
 customise to your needs.
@@ -33,7 +33,7 @@ customise to your needs.
 
 ### Basic Usage
 
-In order to use the library, you first need to add the FAB to your Activity/Composable; this changes depending on the
+To use the library, you first need to add the FAB to your Activity/Composable; this changes depending on the
 project.
 
 <details>
@@ -111,6 +111,38 @@ class MainActivity : ComponentActivity() {
 
 </details>
 
+### Showing the Debug Menu
+
+<details>
+<summary>FAB Button</summary>
+With all the usage methods above, you can also pass a `showFab` parameter to show or hide the FAB button.
+
+```kotlin
+DebugMenuOverlay(
+    showFab = true, // <-- Only open through the FAB button
+    enableShake = false, // <-- Disable shake to open
+    modules = listOf(
+        // your modules...
+    )
+)
+```
+</details>
+
+<details>
+<summary> Shake to Open </summary>
+If you only want the menu to be opened through shake, you can pass `enableShake` to `true` and disable the FAB button.
+
+```kotlin
+DebugMenuOverlay(
+    showFab = false, // <-- Disable FAB button
+    enableShake = true, // <-- Enable shake to open
+    modules = listOf(
+        // your modules...
+    )
+)
+```
+</details>
+
 ## Integrating Modules
 
 > Note: Modules determine the order in which they are displayed in the debug menu.
@@ -121,7 +153,8 @@ class MainActivity : ComponentActivity() {
 
 **Adding Analytics Module**
 
-Just add the `DebugAnalytics` singleton to your list of Modules, and you're good to go.
+First, to show the module, you need to add the `AnalyticsModule` to your list of Modules. Then, you can use the
+`DebugAnalytics` singleton to log events.
 
 ```kotlin
 DebugMenuOverlay(
@@ -140,7 +173,7 @@ just add the event to the `DebugAnalytics` singleton, and it will be logged in t
 
 > **Note:** The signature of the `logEvent` method is the same as Firebase Analytics, so if you're using Firebase
 > Analytics,
-> you can just call it with the same signature.
+> you can just call it in the same way.
 
 ```kotlin
 class AnalyticsManager {
@@ -161,7 +194,7 @@ class AnalyticsManager {
 
 **Adding DataStore Module**
 
-Just add the `DataStoreModule` class to your list of Modules, and pass the list of DataStores and you're good to go. The
+Just add the `DataStoreModule` class to your list of Modules, and pass the list of DataStores and, you're good to go. The
 UI Will automatically generate the UI for every entry.
 
 ```kotlin
@@ -261,7 +294,7 @@ class DemoApp : Application() {
 <br/>
 The dynamic module allows you to add custom actions to the debug menu. They can either be:
 
-- Global actions: These actions are displayed in the debug menu, and can be triggered from anywhere in the app.
+- Global actions: These actions are displayed in the debug menu and can be triggered from anywhere in the app.
 - Dynamic Actions: These actions are only displayed when the user is in a specific screen and get automatically removed
   when the user navigates away from that screen.
 

.idea/dictionaries/project.xml

@@ -27,6 +27,7 @@ import androidx.compose.material3.dynamicLightColorScheme
 import androidx.compose.material3.lightColorScheme
 import androidx.compose.material3.rememberModalBottomSheetState
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -35,7 +36,9 @@ import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.hapticfeedback.HapticFeedbackType
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalHapticFeedback
 import androidx.compose.ui.unit.dp
 import com.tapadoo.debugmenu.analytics.AnalyticsModule
 import com.tapadoo.debugmenu.module.DebugMenuModule
@@ -48,10 +51,33 @@ fun DebugMenuOverlay(
     modules: List<DebugMenuModule> = listOf(AnalyticsModule()),
     modifier: Modifier = Modifier,
     showFab: Boolean = true,
+    enableShake: Boolean = false,
     sheetState: SheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true),
     colorScheme: ColorScheme = getTheme()
 ) {
+    val haptics = LocalHapticFeedback.current
+    val context = LocalContext.current
+
+
     var showContent by remember { mutableStateOf(false) }
+
+    // Shake detector
+    if (enableShake) {
+        val shakeDetector = remember {
+            ShakeDetector(context) {
+                showContent = true
+                haptics.performHapticFeedback(HapticFeedbackType.LongPress)
+            }
+        }
+
+        DisposableEffect(Unit) {
+            shakeDetector.start()
+            onDispose {
+                shakeDetector.stop()
+            }
+        }
+    }
+    
     MaterialTheme(
         colorScheme = colorScheme,
     ) {

.idea/inspectionProfiles/Project_Default.xml

@@ -20,10 +20,17 @@ object DebugMenuAttacher {
     fun attachToApplication(
         application: Application,
         modules: List<DebugMenuModule>,
+        showFab: Boolean = true,
+        enableShake: Boolean = false,
     ) {
         application.registerActivityLifecycleCallbacks(object : Application.ActivityLifecycleCallbacks {
             override fun onActivityCreated(activity: Activity, savedInstanceState: android.os.Bundle?) {
-                DebugMenuAttacher.attach(activity, modules)
+                try {
+                    // When attaching to an app that uses an Activity as a splash screen, it can crash
+                    DebugMenuAttacher.attach(activity, modules, showFab, enableShake)
+                } catch (e: Exception) {
+
+                }
             }
 
             override fun onActivityStarted(activity: Activity) {}
@@ -41,6 +48,8 @@ object DebugMenuAttacher {
     fun attach(
         activity: Activity,
         modules: List<DebugMenuModule>,
+        showFab: Boolean = true,
+        enableShake: Boolean = false,
     ) = runCatching {
         val decor = activity.window?.decorView as? ViewGroup ?: return@runCatching
         // Avoid duplicates
@@ -66,7 +75,8 @@ object DebugMenuAttacher {
             )
             setContent {
                 DebugMenuOverlay(
-                    showFab = true,
+                    showFab = showFab,
+                    enableShake = enableShake,
                     modules = modules,
                 )
             }

.idea/vcs.xml

@@ -0,0 +1,67 @@
+package com.tapadoo.debugmenu
+
+import android.content.Context
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorEventListener
+import android.hardware.SensorManager
+import kotlin.math.sqrt
+
+class ShakeDetector(
+    context: Context,
+    private val onShake: () -> Unit
+) : SensorEventListener {
+
+    private val sensorManager = context.getSystemService(Context.SENSOR_SERVICE) as SensorManager
+    private val accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
+
+    private var lastShakeTime: Long = 0
+    private var lastX = 0f
+    private var lastY = 0f
+    private var lastZ = 0f
+
+    companion object {
+        private const val SHAKE_THRESHOLD = 15f
+        private const val SHAKE_COOLDOWN_MS = 1000L
+    }
+
+    fun start() {
+        accelerometer?.let {
+            sensorManager.registerListener(this, it, SensorManager.SENSOR_DELAY_UI)
+        }
+    }
+
+    fun stop() {
+        sensorManager.unregisterListener(this)
+    }
+
+    override fun onSensorChanged(event: SensorEvent?) {
+        if (event?.sensor?.type != Sensor.TYPE_ACCELEROMETER) return
+
+        val currentTime = System.currentTimeMillis()
+        if (currentTime - lastShakeTime < SHAKE_COOLDOWN_MS) return
+
+        val x = event.values[0]
+        val y = event.values[1]
+        val z = event.values[2]
+
+        val deltaX = x - lastX
+        val deltaY = y - lastY
+        val deltaZ = z - lastZ
+
+        lastX = x
+        lastY = y
+        lastZ = z
+
+        val acceleration = sqrt((deltaX * deltaX + deltaY * deltaY + deltaZ * deltaZ).toDouble())
+
+        if (acceleration > SHAKE_THRESHOLD) {
+            lastShakeTime = currentTime
+            onShake()
+        }
+    }
+
+    override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {
+        // Not needed for shake detection
+    }
+}