v2.1.1 bugfixes: AM demodulation. Crash in Zoom Slider. Adding FOSS build flavor.

Author: Dennis Mantz

.gitignore

@@ -15,6 +15,8 @@ local.properties
 .kotlin
 build/
 app/release/
+app/play/release/
+app/foss/release/
 
 # mkdocs generated files
 build_site/

Readme.md

@@ -88,6 +88,10 @@ You can also donate to support my work:
 
 [![liberapay](https://liberapay.com/assets/widgets/donate.svg)](https://liberapay.com/DM4NTZ/donate)
 
+Paypal: https://paypal.me/dennismantz
+
+Bitcoin: bc1qnzuvkpxd08grw505aurw45y7rty60554kd2ja2
+
 ---
 
 ## About the Author

app/build.gradle.kts

@@ -14,12 +14,31 @@ android {
         applicationId = "com.mantz_it.rfanalyzer"
         minSdk = 28
         targetSdk = 36
-        versionCode = 20106
-        versionName = "2.1.0"
+        versionCode = 20107
+        versionName = "2.1.1"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
 
+    flavorDimensions += "distribution"
+
+    productFlavors {
+        create("play") {
+            dimension = "distribution"
+            buildConfigField("boolean", "IS_FOSS", "false")
+            resValue("string", "flavor_name", "Google Play")
+            resValue("string", "app_name", "RF Analyzer")
+        }
+        create("foss") {
+            dimension = "distribution"
+            applicationIdSuffix = ".foss"
+            versionNameSuffix = "-foss"
+            buildConfigField("boolean", "IS_FOSS", "true")
+            resValue("string", "flavor_name", "FOSS")
+            resValue("string", "app_name", "RF Analyzer (FOSS)")
+        }
+    }
+
     buildTypes {
         release {
             isMinifyEnabled = true
@@ -98,7 +117,9 @@ dependencies {
     androidTestImplementation(libs.androidx.espresso.core)
     debugImplementation(libs.androidx.ui.tooling)
     implementation(libs.androidx.security.crypto)
-    implementation(libs.billing)
     implementation(libs.dagger.hilt)
     ksp(libs.dagger.hilt.compiler)
+
+    // Flavor-specific dependencies:
+    add("playImplementation", libs.billing)  // "play" is the flavor
 }

app/src/foss/kotlin/com/mantz_it/rfanalyzer/database/BillingRepository.kt

@@ -0,0 +1,45 @@
+package com.mantz_it.rfanalyzer.database
+
+import android.app.Activity
+import android.content.Context
+
+/**
+ * <h1>RF Analyzer - Billing Repository (FOSS)</h1>
+ *
+ * Module:      BillingRepository.kt
+ * Description: Mock Interface (without Google Play Billing API) for FOSS version
+ *
+ * @author Dennis Mantz
+ *
+ * Copyright (C) 2025 Dennis Mantz
+ * License: http://www.gnu.org/licenses/gpl.html GPL version 2 or higher
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+
+interface BillingRepositoryInterface {
+    fun queryPurchases()
+    fun purchaseFullVersion(activity: Activity)
+}
+
+class BillingRepository(val context: Context, val appStateRepository: AppStateRepository) : BillingRepositoryInterface {
+    override fun queryPurchases() {
+        // do nothing in foss
+    }
+    override fun purchaseFullVersion(activity: Activity) {
+        // do nothing in foss
+    }
+}

app/src/main/java/com/mantz_it/rfanalyzer/database/MockedBillingRepository.kt renamed to app/src/foss/kotlin/com/mantz_it/rfanalyzer/database/MockedBillingRepository.kt

@@ -43,18 +43,6 @@ import kotlinx.coroutines.launch
 
 class MockedBillingRepository(val context: Context, val appStateRepository: AppStateRepository) : BillingRepositoryInterface {
 
-    private val _remainingTrialPeriodDays = MutableStateFlow(calculateRemainingDays())
-    override val remainingTrialPeriodDays: StateFlow<Int> = _remainingTrialPeriodDays.asStateFlow()
-
-    init {
-        CoroutineScope(Dispatchers.Default).launch {
-            while (isActive) {
-                _remainingTrialPeriodDays.value = calculateRemainingDays()
-                delay(TimeUnit.HOURS.toMillis(1)) // update every hour
-            }
-        }
-    }
-
     override fun queryPurchases() {
         // do nothing in mock
     }
@@ -63,26 +51,4 @@ class MockedBillingRepository(val context: Context, val appStateRepository: AppS
         //Log.d("MockedBillingRepository", "purchaseFullVersion: DISABLED")
         appStateRepository.isFullVersion.set(true)
     }
-
-    private fun calculateRemainingDays(): Int {
-        val installTimestamp = getInstallTimestamp(context) // todo: this should be 'purchase time'
-        val currentTime = System.currentTimeMillis()
-        val installedDays = TimeUnit.MILLISECONDS.toDays(currentTime - installTimestamp).toInt()
-        val trialPeriod= 7 // 7-day trial period
-        Log.d("MockedBillingRepository", "Install: $installTimestamp ; Now: $currentTime  ;  Diff: ${currentTime-installTimestamp}  ; InstalledDays: $installedDays")
-        return (trialPeriod - installedDays).coerceAtLeast(0)
-    }
-
-    override fun isTrialPeriodExpired(): Boolean {
-        return remainingTrialPeriodDays.value <= 0
-    }
-
-    private fun getInstallTimestamp(context: Context): Long {
-        return try {
-            val packageInfo = context.packageManager.getPackageInfo(context.packageName, 0)
-            packageInfo.firstInstallTime // Returns install time in milliseconds
-        } catch (e: PackageManager.NameNotFoundException) {
-            0L
-        }
-    }
 }

app/src/main/AndroidManifest.xml

@@ -1,6 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="com.mantz_it.rfanalyzer" >
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" >
 
     <!-- Internet is used to connect to local and remote rtl_tcp instances -->
     <uses-permission android:name="android.permission.INTERNET" />

app/src/main/java/com/mantz_it/rfanalyzer/AppModule.kt

@@ -82,7 +82,8 @@ object AppModule {
     @Singleton
     fun provideBillingRepository(@ApplicationContext context: Context, appStateRepository: AppStateRepository): BillingRepositoryInterface {
         val buildType = BuildConfig.BUILD_TYPE
-        return if (buildType == "debug")
+        val isFoss = BuildConfig.IS_FOSS
+        return if (isFoss || buildType == "debug")
             MockedBillingRepository(context, appStateRepository)
         else
             BillingRepository(context, appStateRepository)

app/src/main/java/com/mantz_it/rfanalyzer/analyzer/Demodulator.kt

@@ -299,7 +299,7 @@ class Demodulator(
 
         // normalize values:
         val gain = 0.75f / lastMax
-        for (i in 0..<output.size()) reOut[i] = (reOut[i] - avg) * gain
+        for (i in 0..<input.size()) reOut[i] = (reOut[i] - avg) * gain
 
         output.setSize(input.size())
         output.sampleRate = demodulationMode.quadratureRate

app/src/main/java/com/mantz_it/rfanalyzer/database/AppStateRepository.kt

@@ -258,7 +258,10 @@ class AppStateRepository @Inject constructor(
     val viewportVerticalScaleMax = Setting("viewportVerticalScaleMax", 0f, scope, dataStore)
     val viewportStartFrequency = DerivedState(viewportFrequency, viewportSampleRate) { viewportFrequency.value - viewportSampleRate.value/2 }
     val viewportEndFrequency = DerivedState(viewportFrequency, viewportSampleRate) { viewportFrequency.value + viewportSampleRate.value/2 }
-    val viewportZoom = DerivedState(sourceSampleRate, viewportSampleRate) { (1f - (viewportSampleRate.value.toFloat()/sourceSampleRate.value)).coerceIn(0f, 1f) }
+    val viewportZoom = DerivedState(sourceSampleRate, viewportSampleRate) {
+        val tmp = (1f - (viewportSampleRate.value.toFloat()/sourceSampleRate.value)).coerceIn(0f, 1f)
+        if (tmp.isNaN()) 0f else tmp
+    }
 
     // Analyzer State
     val analyzerRunning = MutableState(false)
@@ -277,6 +280,10 @@ class AppStateRepository @Inject constructor(
     val isPurchasePending = Setting("isPurchasePending", false, scope, dataStore)
     val isAppUsageTimeUsedUp = DerivedState(appUsageTimeInSeconds) { appUsageTimeInSeconds.value > TRIAL_VERSTION_USAGE_TIME }
 
+    // Donation Dialog:
+    val timestampOfLastDonationDialog = Setting("timestampOfLastDonationDialog", 0, scope, dataStore)
+    val donationDialogCounter = Setting("donationDialogCounter", 0, scope, dataStore)
+
 
     // FFT Data
     val fftProcessorData = FftProcessorData()
@@ -325,32 +332,57 @@ class AppStateRepository @Inject constructor(
     ) : MutableState<T>(default) {
         init {
             settingsTotalCount++
-            val key: Preferences.Key<T> = when (default) {
+            val key: Preferences.Key<T>? = when (default) {
                 is Boolean -> booleanPreferencesKey(keyName)
                 is Int -> intPreferencesKey(keyName)
                 is Long -> longPreferencesKey(keyName)
                 is Float -> floatPreferencesKey(keyName)
                 is String -> stringPreferencesKey(keyName)
-                is Enum<*> -> intPreferencesKey(keyName) // Enum stored as ordinal
-                is List<*> -> stringPreferencesKey(keyName) // Store lists as comma separated list (string)
+                is Enum<*> -> null
+                is List<*> -> null
                 else -> throw IllegalArgumentException("Unsupported setting type (setting: ${keyName}")
-            } as Preferences.Key<T>
+            } as Preferences.Key<T>?
 
             scope.launch {
                 // Load initial value
                 val saved = dataStore.data
                     .map { prefs -> when(default) {
-                        is Enum<*> -> {
+                        is Enum<*> -> {  // up until 2.1 this was stored as int (ordinal) but now we store the enum name (using a different key)
                             val enumClass = default!!::class.java
-                            val enumIndex = prefs[key as Preferences.Key<Int>] ?: default.ordinal
-                            enumClass.enumConstants[enumIndex.coerceAtMost(enumClass.enumConstants.size - 1)]
+                            // If we find the string type key take it, otherwise try using the legacy int key:
+                            val stringKey = stringPreferencesKey(keyName + "Enum")  // name new key with 'Enum' suffix
+                            val legacyIntKey = intPreferencesKey(keyName)
+                            val prefsString = prefs[stringKey]
+                            val prefsInt = prefs[legacyIntKey]
+                            val enumValue = when {
+                                prefsString != null -> enumClass.enumConstants.firstOrNull { it.name == prefsString }
+                                prefsInt != null -> enumClass.enumConstants.getOrNull(prefsInt)
+                                else -> default
+                            } ?: default
+
+                            // If we loaded from legacy int, immediately migrate to new key
+                            if (prefsString == null && prefsInt != null) {
+                                scope.launch {
+                                    dataStore.edit { editPrefs ->
+                                        editPrefs[stringKey] = enumValue.name
+                                        editPrefs.remove(legacyIntKey)  // cleanup
+                                    }
+                                }
+                            }
+
+                            enumValue
                         }
                         is List<*> -> {
-                            val stringValue = prefs[key as Preferences.Key<String>]
+                            // Store lists as comma separated list (string)
+                            val stringKey = stringPreferencesKey(keyName)
+                            val stringValue = prefs[stringKey]
                             val list = stringValue?.split(",")?.mapNotNull { it.toIntOrNull() } ?: default
                             list as T
                         }
-                        else -> prefs[key] ?: default
+                        else -> {
+                            if (key == null) throw IllegalArgumentException("Unsupported setting type (setting: ${keyName}")
+                            else prefs[key] ?: default
+                        }
                     }}
                     .firstOrNull()
 
@@ -367,9 +399,9 @@ class AppStateRepository @Inject constructor(
                     .collectLatest { newValue ->
                         dataStore.edit { prefs ->
                             when (newValue) {
-                                is Enum<*> -> prefs[key as Preferences.Key<Int>] = newValue.ordinal
-                                is List<*> -> prefs[key as Preferences.Key<String>] = newValue.joinToString(",")
-                                else -> prefs[key] = newValue
+                                is Enum<*> -> prefs[stringPreferencesKey(keyName + "Enum")] = newValue.name
+                                is List<*> -> prefs[stringPreferencesKey(keyName)] = newValue.joinToString(",")
+                                else -> key?.let { prefs[it] = newValue }
                             }
                         }
                     }

app/src/main/java/com/mantz_it/rfanalyzer/ui/AnalyzerSurface.kt

@@ -21,6 +21,7 @@ import android.view.ScaleGestureDetector
 import android.view.SurfaceHolder
 import android.view.SurfaceView
 import androidx.core.content.ContextCompat
+import com.mantz_it.rfanalyzer.BuildConfig
 import com.mantz_it.rfanalyzer.database.AppStateRepository
 import com.mantz_it.rfanalyzer.database.AppStateRepository.Companion.VERTICAL_SCALE_LOWER_BOUNDARY
 import com.mantz_it.rfanalyzer.database.AppStateRepository.Companion.VERTICAL_SCALE_UPPER_BOUNDARY
@@ -696,7 +697,7 @@ class AnalyzerSurface(context: Context,
                         peakAvg = 0f
                         counter = 0
                         var j = (i * samplesPerPx).toInt()
-                        while (j < (i + 1) * samplesPerPx) {
+                        while (j < (i + 1) * samplesPerPx && (j+start)<fftSize) {
                             avg += fftRow[j + start]
                             if (rowNumber == 0 && calcPeaks) peakAvg += peaks[j + start]
                             counter++
@@ -1206,7 +1207,11 @@ class AnalyzerSurface(context: Context,
         fun drawWatermark() {
             var c: Canvas? = null
             val bitmap: Bitmap = BitmapFactory.decodeResource(resources, R.drawable.rfanalyzer2)
-            var text = if(isFullVersion.value) "FULL VERSION" else "TRIAL VERSION"
+            var text = if(BuildConfig.IS_FOSS) {
+                "FOSS VERSION"
+            } else {
+                if(isFullVersion.value) "FULL VERSION" else "TRIAL VERSION"
+            }
             val paint = Paint()
             val textPaint = Paint()
             textPaint.color = Color.DKGRAY