pakstr 0.6.0 → 0.8.0

package/android-template/app/build.gradle.kts

@@ -1,5 +1,4 @@
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-import java.util.Properties
 import java.io.File
 
 plugins {
@@ -7,49 +6,32 @@ plugins {
     alias(libs.plugins.kotlin.compose)
 }
 
-val keystoreProperties =
-
-    Properties()
-
-val keystorePath =
-    providers.gradleProperty(
-        "releaseKeystoreConfig"
-    ).orNull
-
-val keystorePropertiesFile =
-    keystorePath?.let { rootProject.file(it) }
-if (keystorePropertiesFile?.exists() == true) {
-
-    keystorePropertiesFile.inputStream()
-        .use {
-            keystoreProperties.load(it)
-        }
+val releaseRequested = gradle.startParameter.taskNames.any {
+    it.contains("release", ignoreCase = true)
 }
 
+fun requireReleaseSigningValue(name: String): String =
+    System.getenv(name)
+        ?.takeIf { it.isNotEmpty() }
+        ?: throw GradleException("Missing required release signing environment variable: $name")
+
 android {
     namespace = "com.pakstr.app"
     compileSdk = 36
 
     signingConfigs {
-
         create("release") {
-
-            if (keystorePropertiesFile?.exists() == true) {
-
-                storeFile =
-                    File(
-                        keystorePropertiesFile.parentFile,
-                        keystoreProperties["storeFile"] as String
-                    )
-
-                storePassword =
-                    keystoreProperties["storePassword"] as String
-
-                keyAlias =
-                    keystoreProperties["keyAlias"] as String
-
-                keyPassword =
-                    keystoreProperties["keyPassword"] as String
+            if (releaseRequested) {
+                val keystorePath = requireReleaseSigningValue("PAKSTR_ANDROID_KEYSTORE_PATH")
+                val keystoreFile = File(keystorePath)
+                if (!keystoreFile.isFile) {
+                    throw GradleException("Release signing keystore path is not a file")
+                }
+
+                storeFile = keystoreFile
+                storePassword = requireReleaseSigningValue("PAKSTR_ANDROID_KEYSTORE_PASSWORD")
+                keyAlias = requireReleaseSigningValue("PAKSTR_ANDROID_KEY_ALIAS")
+                keyPassword = requireReleaseSigningValue("PAKSTR_ANDROID_KEY_PASSWORD")
             }
         }
     }
@@ -65,25 +47,22 @@ android {
     }
 
     buildTypes {
-
         debug {
             applicationIdSuffix = ".debug"
             versionNameSuffix = "-debug"
         }
 
         release {
-            signingConfig =
-                signingConfigs.getByName("release")
+            signingConfig = signingConfigs.getByName("release")
             isMinifyEnabled = true
             isShrinkResources = true
             proguardFiles(
-                getDefaultProguardFile(
-                    "proguard-android-optimize.txt"
-                ),
+                getDefaultProguardFile("proguard-android-optimize.txt"),
                 "proguard-rules.pro"
             )
         }
     }
+
     compileOptions {
         sourceCompatibility = JavaVersion.VERSION_17
         targetCompatibility = JavaVersion.VERSION_17
@@ -94,6 +73,7 @@ android {
         buildConfig = true
     }
 }
+
 tasks.withType<KotlinCompile>()
     .configureEach {
         compilerOptions {
@@ -121,9 +101,7 @@ dependencies {
     debugImplementation(libs.androidx.compose.ui.test.manifest)
     implementation(libs.nanohttpd)
     implementation(libs.androidx.appcompat)
-
     implementation(libs.material)
     implementation(libs.androidx.core.splashscreen)
-
     implementation("org.bouncycastle:bcprov-jdk18on:1.78.1")
-}
+}

package/android-template/app/src/main/java/com/pakstr/app/MainActivity.kt

@@ -3,11 +3,14 @@ package com.pakstr.app
 import android.Manifest
 import android.content.Intent
 import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
 
 import android.view.View
 import android.webkit.PermissionRequest
 import android.webkit.WebView
 import android.widget.FrameLayout
+import android.widget.Toast
 import androidx.activity.OnBackPressedCallback
 import androidx.activity.enableEdgeToEdge
 import androidx.activity.result.ActivityResultLauncher
@@ -22,8 +25,11 @@ import com.pakstr.app.debug.AppDebugLogger
 import com.pakstr.app.debug.CrashHandler
 
 import com.pakstr.app.debug.DebugReportShare
+import com.pakstr.app.debug.DeveloperToolsAccessManager
 import com.pakstr.app.debug.DeveloperToolsActivity
 import com.pakstr.app.debug.DeveloperToolsManager
+import com.pakstr.app.debug.SupportUnlock
+import com.pakstr.app.debug.SupportUnlockGestureLayout
 import com.pakstr.app.debug.WebViewDebugManager
 
 import com.pakstr.app.permissions.PermissionManager
@@ -46,6 +52,12 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
             ActivityResultLauncher<Intent>
 
     private lateinit var fab: FloatingActionButton
+    private lateinit var supportUnlockGestureLayout: SupportUnlockGestureLayout
+
+    private val diagnosticsHandler = Handler(Looper.getMainLooper())
+    private val diagnosticsExpiryCheck = Runnable {
+        showDebugFab()
+    }
 
     override fun onCreate(
 
@@ -92,6 +104,7 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
         )
 
         initViews()
+        setupSupportUnlockGesture()
         showDebugFab()
 
         amberLauncher =
@@ -151,33 +164,61 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
     }
 
     private fun showDebugFab() {
-        if (BuildConfig.DEBUG || RuntimeConfig.debugEnabled(this)) {
+        diagnosticsHandler.removeCallbacks(diagnosticsExpiryCheck)
+
+        if (DeveloperToolsAccessManager.canOpenDeveloperTools(this)) {
 
             fab.visibility = View.VISIBLE
 
             fab.setOnClickListener {
+                if (DeveloperToolsAccessManager.canOpenDeveloperTools(this)) {
+                    startActivity(
 
-                startActivity(
+                        Intent(
 
-                    Intent(
+                            this,
 
-                        this,
+                            DeveloperToolsActivity::class.java
 
-                        DeveloperToolsActivity::class.java
+                        )
 
                     )
+                } else {
+                    showDebugFab()
+                }
+            }
 
+            val remainingDuration = SupportUnlock.remainingDuration(this)
+            if (!BuildConfig.DEBUG &&
+                !RuntimeConfig.debugEnabled(this) &&
+                remainingDuration > 0L
+            ) {
+                diagnosticsHandler.postDelayed(
+                    diagnosticsExpiryCheck,
+                    remainingDuration
                 )
-
             }
 
         } else {
 
             fab.visibility = View.GONE
+            fab.setOnClickListener(null)
 
         }
     }
 
+    private fun setupSupportUnlockGesture() {
+        supportUnlockGestureLayout.onUnlock = {
+            SupportUnlock.unlock(this)
+            Toast.makeText(
+                this,
+                R.string.diagnostics_mode_enabled,
+                Toast.LENGTH_LONG
+            ).show()
+            showDebugFab()
+        }
+    }
+
     private fun setupBackNavigation() {
         onBackPressedDispatcher.addCallback(
             this,
@@ -220,6 +261,9 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
         container =
             findViewById(R.id.mainContainer)
 
+        supportUnlockGestureLayout =
+            container as SupportUnlockGestureLayout
+
         webView =
             findViewById(R.id.webView)
 
@@ -243,7 +287,29 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
         )
     }
 
+    override fun onResume() {
+        super.onResume()
+
+        if (::fab.isInitialized) {
+            showDebugFab()
+        }
+    }
+
+    override fun onStop() {
+        if (::supportUnlockGestureLayout.isInitialized) {
+            supportUnlockGestureLayout.cancelHold()
+        }
+
+        super.onStop()
+    }
+
     override fun onDestroy() {
+        diagnosticsHandler.removeCallbacks(diagnosticsExpiryCheck)
+
+        if (::supportUnlockGestureLayout.isInitialized) {
+            supportUnlockGestureLayout.cancelHold()
+            supportUnlockGestureLayout.onUnlock = null
+        }
 
         if (::runtime.isInitialized) {
 

package/android-template/app/src/main/java/com/pakstr/app/debug/DeveloperToolsAccessManager.kt

@@ -0,0 +1,14 @@
+package com.pakstr.app.debug
+
+import android.content.Context
+import com.pakstr.app.BuildConfig
+import com.pakstr.app.RuntimeConfig
+
+object DeveloperToolsAccessManager {
+
+    fun canOpenDeveloperTools(context: Context): Boolean {
+        return BuildConfig.DEBUG ||
+                RuntimeConfig.debugEnabled(context) ||
+                SupportUnlock.isActive(context)
+    }
+}

package/android-template/app/src/main/java/com/pakstr/app/debug/SupportUnlock.kt

@@ -0,0 +1,44 @@
+package com.pakstr.app.debug
+
+import android.content.Context
+
+object SupportUnlock {
+
+    const val UNLOCK_DURATION_MS = 60 * 60 * 1000L
+
+    private const val PREFERENCES_NAME = "pakstr_support_unlock"
+    private const val EXPIRES_AT_KEY = "expires_at"
+
+    fun unlock(context: Context) {
+        preferences(context)
+            .edit()
+            .putLong(EXPIRES_AT_KEY, System.currentTimeMillis() + UNLOCK_DURATION_MS)
+            .apply()
+    }
+
+    fun isActive(context: Context): Boolean {
+        val remainingDuration = remainingDuration(context)
+
+        if (remainingDuration <= 0L) {
+            clear(context)
+            return false
+        }
+
+        return true
+    }
+
+    fun clear(context: Context) {
+        preferences(context)
+            .edit()
+            .remove(EXPIRES_AT_KEY)
+            .apply()
+    }
+
+    fun remainingDuration(context: Context): Long {
+        val expiresAt = preferences(context).getLong(EXPIRES_AT_KEY, 0L)
+        return (expiresAt - System.currentTimeMillis()).coerceAtLeast(0L)
+    }
+
+    private fun preferences(context: Context) =
+        context.getSharedPreferences(PREFERENCES_NAME, Context.MODE_PRIVATE)
+}

package/android-template/app/src/main/java/com/pakstr/app/debug/SupportUnlockGestureLayout.kt

@@ -0,0 +1,87 @@
+package com.pakstr.app.debug
+
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.util.AttributeSet
+import android.view.MotionEvent
+import android.view.ViewConfiguration
+import android.widget.FrameLayout
+import kotlin.math.abs
+
+class SupportUnlockGestureLayout @JvmOverloads constructor(
+    context: Context,
+    attrs: AttributeSet? = null,
+    defStyleAttr: Int = 0
+) : FrameLayout(context, attrs, defStyleAttr) {
+
+    var onUnlock: (() -> Unit)? = null
+
+    private val handler = Handler(Looper.getMainLooper())
+    private val touchSlop = ViewConfiguration.get(context).scaledTouchSlop
+    private val cornerSize = CORNER_SIZE_DP * resources.displayMetrics.density
+
+    private var tracking = false
+    private var downX = 0f
+    private var downY = 0f
+
+    private val unlockRunnable = Runnable {
+        if (tracking) {
+            tracking = false
+            onUnlock?.invoke()
+        }
+    }
+
+    override fun dispatchTouchEvent(event: MotionEvent): Boolean {
+        observeTouch(event)
+        return super.dispatchTouchEvent(event)
+    }
+
+    fun cancelHold() {
+        tracking = false
+        handler.removeCallbacks(unlockRunnable)
+    }
+
+    override fun onDetachedFromWindow() {
+        cancelHold()
+        super.onDetachedFromWindow()
+    }
+
+    private fun observeTouch(event: MotionEvent) {
+        when (event.actionMasked) {
+            MotionEvent.ACTION_DOWN -> {
+                if (isInTopRightCorner(event.x, event.y)) {
+                    tracking = true
+                    downX = event.x
+                    downY = event.y
+                    handler.postDelayed(unlockRunnable, HOLD_DURATION_MS)
+                } else {
+                    cancelHold()
+                }
+            }
+
+            MotionEvent.ACTION_MOVE -> {
+                if (tracking && hasMovedBeyondTouchSlop(event.x, event.y)) {
+                    cancelHold()
+                }
+            }
+
+            MotionEvent.ACTION_POINTER_DOWN,
+            MotionEvent.ACTION_UP,
+            MotionEvent.ACTION_CANCEL -> cancelHold()
+        }
+    }
+
+    private fun isInTopRightCorner(x: Float, y: Float): Boolean {
+        return x >= width - cornerSize && y <= paddingTop + cornerSize
+    }
+
+    private fun hasMovedBeyondTouchSlop(x: Float, y: Float): Boolean {
+        return abs(x - downX) > touchSlop || abs(y - downY) > touchSlop
+    }
+
+    private companion object {
+        const val HOLD_DURATION_MS = 10_000L
+        const val CORNER_SIZE_DP = 72
+    }
+}

package/android-template/app/src/main/res/layout/activity_layout.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+<com.pakstr.app.debug.SupportUnlockGestureLayout xmlns:android="http://schemas.android.com/apk/res/android"
     android:id="@+id/mainContainer"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
@@ -27,4 +27,4 @@
         android:contentDescription="@string/developer_tools"
         android:src="@android:drawable/ic_menu_info_details" />
 
-</FrameLayout>
+</com.pakstr.app.debug.SupportUnlockGestureLayout>

package/android-template/app/src/main/res/values/strings.xml

@@ -43,4 +43,5 @@
     <string name="developer_tools_browser_unavailable">No browser is available.</string>
 
     <string name="developer_tools">Open Developer Tools</string>
+    <string name="diagnostics_mode_enabled">Diagnostics mode enabled</string>
 </resources>

package/android-template/gradle.properties

@@ -12,5 +12,4 @@ org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
 # https://developer.android.com/r/tools/gradle-multi-project-decoupled-projects
 # org.gradle.parallel=true
 # Kotlin code style for this project: "official" or "obsolete":
-kotlin.code.style=official
-releaseKeystoreConfig=../../../keystore.properties
+kotlin.code.style=official

package/dist/android/releaseVerification.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyReleaseApk = verifyReleaseApk;
+exports.parseApkSignerFingerprints = parseApkSignerFingerprints;
+exports.parseKeystoreFingerprints = parseKeystoreFingerprints;
+const crypto_1 = require("crypto");
+const releaseSigning_1 = require("../core/releaseSigning");
+function verifyReleaseApk(input) {
+    const signerResult = input.executor.run("apksigner", [
+        "verify",
+        "--print-certs",
+        input.artifactPath,
+    ]);
+    const signerFingerprints = parseApkSignerFingerprints(signerResult.stdout);
+    if (signerFingerprints.length !== 1) {
+        throw new Error(`Release APK must have exactly one current signer; found ${signerFingerprints.length}`);
+    }
+    const keytoolEnv = {
+        [releaseSigning_1.PUBLIC_SIGNING_ENV.keystorePassword]: input.signing.storePassword,
+    };
+    const keytoolResult = input.executor.run("keytool", [
+        "-list",
+        "-rfc",
+        "-keystore",
+        input.toolKeystorePath ?? input.signing.keystorePath,
+        `-storepass:env`,
+        releaseSigning_1.PUBLIC_SIGNING_ENV.keystorePassword,
+    ], keytoolEnv);
+    const keystoreFingerprints = parseKeystoreFingerprints(keytoolResult.stdout);
+    const signerFingerprint = signerFingerprints[0];
+    const matchingEntries = keystoreFingerprints.filter(fingerprint => fingerprint === signerFingerprint);
+    if (matchingEntries.length !== 1) {
+        throw new Error(`Release APK signer must match exactly one certificate in the supplied keystore; found ${matchingEntries.length}`);
+    }
+    const identityResult = input.executor.run("apkanalyzer", [
+        "manifest",
+        "application-id",
+        input.artifactPath,
+    ]);
+    const applicationIds = identityResult.stdout
+        .split(/\r?\n/)
+        .map(value => value.trim())
+        .filter(Boolean);
+    if (applicationIds.length !== 1) {
+        throw new Error("Unable to derive one unambiguous Application ID from release APK");
+    }
+    const actualApplicationId = applicationIds[0];
+    if (actualApplicationId !== input.expectedApplicationId) {
+        throw new Error(`Release APK Application ID mismatch: expected ${input.expectedApplicationId}, received ${actualApplicationId}`);
+    }
+    return {
+        signatureVerified: true,
+        signerMatched: true,
+        expectedApplicationId: input.expectedApplicationId,
+        actualApplicationId,
+        tools: {
+            signature: "apksigner",
+            signer: "keytool",
+            identity: "apkanalyzer",
+        },
+    };
+}
+function parseApkSignerFingerprints(output) {
+    const fingerprints = output
+        .split(/\r?\n/)
+        .map(line => line.match(/Signer #\d+ certificate SHA-256 digest:\s*([0-9a-fA-F]+)/)?.[1])
+        .filter((value) => value !== undefined)
+        .map(normalizeFingerprint);
+    return [...new Set(fingerprints)];
+}
+function parseKeystoreFingerprints(output) {
+    const certificates = output.match(/-----BEGIN CERTIFICATE-----[\s\S]+?-----END CERTIFICATE-----/g);
+    if (!certificates?.length) {
+        throw new Error("No certificate-bearing entries found in supplied keystore");
+    }
+    return certificates.map(pem => {
+        const certificate = new crypto_1.X509Certificate(pem);
+        return (0, crypto_1.createHash)("sha256").update(certificate.raw).digest("hex");
+    });
+}
+function normalizeFingerprint(value) {
+    return value.replace(/[^0-9a-fA-F]/g, "").toLowerCase();
+}

package/dist/android/releaseWorkspace.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReleaseWorkspace = createReleaseWorkspace;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const template_1 = require("./template");
+function createReleaseWorkspace(templateRoot) {
+    const workspaceRoot = path_1.default.join((0, template_1.getCacheDir)(), "workspaces");
+    fs_1.default.mkdirSync(workspaceRoot, { recursive: true, mode: 0o700 });
+    const workspaceParent = fs_1.default.mkdtempSync(path_1.default.join(workspaceRoot, "pakstr-release-workspace-"));
+    const androidRoot = path_1.default.join(workspaceParent, "android");
+    let cleaned = false;
+    try {
+        fs_1.default.chmodSync(workspaceParent, 0o700);
+        fs_1.default.cpSync(templateRoot, androidRoot, { recursive: true });
+        const gradlewPath = path_1.default.join(androidRoot, "gradlew");
+        if (fs_1.default.existsSync(gradlewPath)) {
+            fs_1.default.chmodSync(gradlewPath, 0o755);
+        }
+    }
+    catch (error) {
+        fs_1.default.rmSync(workspaceParent, { recursive: true, force: true });
+        throw error;
+    }
+    return {
+        androidRoot,
+        cleanup() {
+            if (cleaned)
+                return;
+            fs_1.default.rmSync(workspaceParent, {
+                recursive: true,
+                force: true,
+                maxRetries: 2,
+            });
+            if (fs_1.default.existsSync(workspaceParent)) {
+                throw new Error(`Failed to remove temporary release workspace: ${workspaceParent}`);
+            }
+            cleaned = true;
+        },
+    };
+}

package/dist/android/template.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCacheDir = getCacheDir;
 exports.ensureTemplate = ensureTemplate;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -54,10 +55,14 @@ function fixGradlewPermissions(root) {
 // -----------------------------
 function createLocalProperties(root) {
     const sdkPath = process.env.ANDROID_HOME ??
+        process.env.ANDROID_SDK_ROOT ??
         path_1.default.join(os_1.default.homedir(), "Library", "Android", "sdk");
-    const content = `sdk.dir=${sdkPath}\n`;
     const file = path_1.default.join(root, "local.properties");
-    fs_1.default.writeFileSync(file, content);
+    if (!fs_1.default.existsSync(sdkPath)) {
+        fs_1.default.rmSync(file, { force: true });
+        return;
+    }
+    fs_1.default.writeFileSync(file, `sdk.dir=${sdkPath}\n`);
     console.log("📍 local.properties created:", sdkPath);
 }
 async function ensureTemplate() {