feat: Add release build script for APK generation

docs: Update design documents to reflect project name change from PeerChat Secure to PeerChat

docs: Modify implementation plan to align with project name change and update file paths

docs: Revise project state snapshot to reflect name change and recent updates

docs: Update requirements document to reflect project name change

docs: Revise system architecture document to reflect project name change

chore: Update pubspec.lock with new dependencies and versions

chore: Update pubspec.yaml to reflect version bump and new dependencies

test: Update widget test to reflect project name change

fix: Update ADB path error message in smoke test script

feat: Enhance website content to include file sharing features and project name change

Author: Mathi4Raja

.kiro/specs/mesh-routing/design.md

@@ -2,7 +2,7 @@
 
 ## Overview
 
-This design specifies a message store-and-forward system with mesh routing capabilities for PeerChat Secure. The system enables multi-hop message delivery through intermediate peers, allowing communication beyond direct connectivity range in disaster scenarios where traditional infrastructure is unavailable.
+This design specifies a message store-and-forward system with mesh routing capabilities for PeerChat. The system enables multi-hop message delivery through intermediate peers, allowing communication beyond direct connectivity range in disaster scenarios where traditional infrastructure is unavailable.
 
 The design integrates with the existing Flutter application architecture, leveraging:
 - **libsodium (sodium package)** for cryptographic operations (signing, encryption)
@@ -1076,3 +1076,4 @@ A property is a characteristic or behavior that should hold true across all vali
 
 **Validates: Requirements 16.3**
 
+

.kiro/specs/mesh-routing/requirements.md

@@ -2,7 +2,7 @@
 
 ## Introduction
 
-This document specifies requirements for a message store-and-forward system with mesh routing capabilities for PeerChat Secure, an offline-first disaster communication Flutter application. The system enables messages to travel through multiple devices to reach destinations beyond direct connectivity range, which is critical for disaster scenarios where people are spread out and traditional communication infrastructure is unavailable.
+This document specifies requirements for a message store-and-forward system with mesh routing capabilities for PeerChat, an offline-first disaster communication Flutter application. The system enables messages to travel through multiple devices to reach destinations beyond direct connectivity range, which is critical for disaster scenarios where people are spread out and traditional communication infrastructure is unavailable.
 
 ## Glossary
 
@@ -217,3 +217,4 @@ This document specifies requirements for a message store-and-forward system with
 3. WHEN a malformed message is received, THE Mesh_Router SHALL discard it and log the error
 4. WHEN storage operations fail, THE Mesh_Router SHALL notify the application layer
 5. WHEN cryptographic operations fail, THE Mesh_Router SHALL discard the message and log the error
+

android/app/build.gradle.kts

@@ -13,6 +13,7 @@ android {
     compileOptions {
         sourceCompatibility = JavaVersion.VERSION_17
         targetCompatibility = JavaVersion.VERSION_17
+        isCoreLibraryDesugaringEnabled = true
     }
 
     kotlinOptions {
@@ -42,3 +43,7 @@ android {
 flutter {
     source = "../.."
 }
+
+dependencies {
+    coreLibraryDesugaring("com.android.tools:desugar_jdk_libs:2.1.5")
+}

android/app/src/main/AndroidManifest.xml

@@ -19,6 +19,10 @@
         android:name="android.permission.WRITE_EXTERNAL_STORAGE"
         android:maxSdkVersion="28" />
 
+    <!-- Android 13+ specific media permissions -->
+    <uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />
+    <uses-permission android:name="android.permission.READ_MEDIA_VIDEO" />
+    
     <!-- WiFi Direct permissions -->
     <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
     <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
@@ -28,18 +32,26 @@
 
     <!-- Internet permission for mDNS -->
     <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
     <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" />
 
     <!-- Camera permission for QR code scanning -->
     <uses-permission android:name="android.permission.CAMERA" />
 
+    <!-- Permission to list installed apps (for App Sharing) -->
+    <uses-permission android:name="android.permission.QUERY_ALL_PACKAGES" />
+    
+    <!-- Permission to modify system settings (for Hotspot/WiFi optimization) -->
+    <uses-permission android:name="android.permission.WRITE_SETTINGS" />
+
+    
     <uses-feature android:name="android.hardware.bluetooth" android:required="false" />
     <uses-feature android:name="android.hardware.wifi" android:required="false" />
     <uses-feature android:name="android.hardware.camera" android:required="false" />
     <uses-feature android:name="android.hardware.camera.autofocus" android:required="false" />
 
     <application
-        android:label="PeerChat Secure"
+        android:label="PeerChat"
         android:name="${applicationName}"
         android:icon="@mipmap/ic_launcher"
         android:requestLegacyExternalStorage="true">
@@ -74,7 +86,7 @@
     <!-- Required to query activities that can process text, see:
          https://developer.android.com/training/package-visibility and
          https://developer.android.com/reference/android/content/Intent#ACTION_PROCESS_TEXT.
-
+ 
          In particular, this is used by the Flutter engine in io.flutter.plugin.text.ProcessTextPlugin. -->
     <queries>
         <intent>

android/app/src/main/kotlin/com/example/peerchat_secure/MainActivity.kt

@@ -2,17 +2,32 @@ package com.example.peerchat_secure
 
 import android.content.Context
 import android.content.Intent
+import android.content.IntentFilter
 import android.os.BatteryManager
 import android.provider.Settings
+import android.provider.MediaStore
+import android.net.Uri
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.drawable.BitmapDrawable
+import android.graphics.drawable.Drawable
+import java.io.ByteArrayOutputStream
+import android.content.BroadcastReceiver
+import android.bluetooth.BluetoothAdapter
 import io.flutter.embedding.engine.FlutterEngine
 import io.flutter.embedding.android.FlutterActivity
 import io.flutter.plugin.common.MethodChannel
+import io.flutter.plugin.common.EventChannel
+import android.net.wifi.WifiManager
 
 class MainActivity : FlutterActivity() {
     companion object {
         private const val DEVICE_STATUS_CHANNEL = "peerchat_secure/device_status"
+        private const val BLUETOOTH_STATE_CHANNEL = "peerchat_secure/bluetooth_state"
     }
 
+    private var bluetoothReceiver: BroadcastReceiver? = null
+
     override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
         super.configureFlutterEngine(flutterEngine)
 
@@ -41,12 +56,216 @@ class MainActivity : FlutterActivity() {
                     )
                 }
 
+                "getAppIcon" -> {
+                    val packageName = call.argument<String>("packageName")
+                    if (packageName != null) {
+                        try {
+                            val pm = packageManager
+                            val icon = pm.getApplicationIcon(packageName)
+                            val bitmap = drawableToBitmap(icon)
+                            
+                            val scaledBitmap = Bitmap.createScaledBitmap(bitmap, 128, 128, true)
+                            
+                            val stream = ByteArrayOutputStream()
+                            scaledBitmap.compress(Bitmap.CompressFormat.PNG, 100, stream)
+                            result.success(stream.toByteArray())
+                        } catch (e: Exception) {
+                            result.error("ICON_ERROR", e.message, null)
+                        }
+                    } else {
+                        result.error("INVALID_ARGS", "Package name is null", null)
+                    }
+                }
+
                 "openLocationSettings" -> {
                     try {
                         val intent = Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS)
                         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
                         startActivity(intent)
                         result.success(true)
+                    } catch (e: Exception) {
+                        result.success(null)
+                    }
+                }
+
+                "checkSystemSettingsPermission" -> {
+                    result.success(Settings.System.canWrite(this))
+                }
+
+                "openSystemSettingsPermission" -> {
+                    try {
+                        val intent = Intent(Settings.ACTION_MANAGE_WRITE_SETTINGS)
+                        intent.data = android.net.Uri.parse("package:$packageName")
+                        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                        startActivity(intent)
+                        result.success(true)
+                    } catch (e: Exception) {
+                        result.success(false)
+                    }
+                }
+
+                "toggleBluetooth" -> {
+                    val enable = call.argument<Boolean>("enable") ?: false
+                    try {
+                        val bluetoothAdapter = android.bluetooth.BluetoothAdapter.getDefaultAdapter()
+                        if (bluetoothAdapter != null) {
+                            if (enable) bluetoothAdapter.enable() else bluetoothAdapter.disable()
+                            result.success(true)
+                        } else {
+                            result.success(false)
+                        }
+                    } catch (e: Exception) {
+                        result.error("BT_ERROR", e.message, null)
+                    }
+                }
+
+                "isBluetoothEnabled" -> {
+                    try {
+                        val bluetoothAdapter = android.bluetooth.BluetoothAdapter.getDefaultAdapter()
+                        result.success(bluetoothAdapter?.isEnabled == true)
+                    } catch (e: Exception) {
+                        result.error("BT_STATE_ERROR", e.message, null)
+                    }
+                }
+
+                "isHotspotEnabled" -> {
+                    try {
+                        val wifiManager = applicationContext.getSystemService(Context.WIFI_SERVICE) as WifiManager
+                        val method = wifiManager.javaClass.getDeclaredMethod("getWifiApState")
+                        val state = method.invoke(wifiManager) as Int
+                        // 13 is WIFI_AP_STATE_ENABLED
+                        result.success(state == 13)
+                    } catch (e: Exception) {
+                        result.success(false)
+                    }
+                }
+
+                "getInstalledApps" -> {
+                    try {
+                        val pm = packageManager
+                        val apps = pm.getInstalledApplications(android.content.pm.PackageManager.GET_META_DATA)
+                        val appList = mutableListOf<Map<String, Any>>()
+
+                        for (app in apps) {
+                            val launchIntent = pm.getLaunchIntentForPackage(app.packageName)
+                            if (launchIntent != null) {
+                                val label = app.loadLabel(pm).toString()
+                                val apkPath = app.sourceDir
+                                val size = java.io.File(apkPath).length()
+                                
+                                val appMap = mapOf(
+                                    "name" to label,
+                                    "packageName" to app.packageName,
+                                    "apkPath" to apkPath,
+                                    "size" to size
+                                )
+                                appList.add(appMap)
+                            }
+                        }
+                        result.success(appList)
+                    } catch (e: Exception) {
+                        result.error("APP_LIST_ERROR", e.message, null)
+                    }
+                }
+
+                "checkAllFilesPermission" -> {
+                    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.R) {
+                        result.success(android.os.Environment.isExternalStorageManager())
+                    } else {
+                        result.success(true)
+                    }
+                }
+
+                "openAllFilesPermission" -> {
+                    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.R) {
+                        try {
+                            val intent = Intent(Settings.ACTION_MANAGE_APP_ALL_FILES_ACCESS_PERMISSION)
+                            intent.data = android.net.Uri.parse("package:$packageName")
+                            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                            startActivity(intent)
+                            result.success(true)
+                        } catch (e: Exception) {
+                            val intent = Intent(Settings.ACTION_MANAGE_ALL_FILES_ACCESS_PERMISSION)
+                            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                            startActivity(intent)
+                            result.success(true)
+                        }
+                    } else {
+                        result.success(true)
+                    }
+                }
+
+                "getMediaAssets" -> {
+                    val type = call.argument<String>("type") ?: "image"
+                    try {
+                        val mediaList = mutableListOf<Map<String, Any>>()
+                        val projection = arrayOf<String>(
+                            MediaStore.MediaColumns.DISPLAY_NAME,
+                            MediaStore.MediaColumns.DATA,
+                            MediaStore.MediaColumns.SIZE,
+                            MediaStore.MediaColumns.MIME_TYPE,
+                            MediaStore.MediaColumns.DATE_ADDED
+                        )
+                        
+                        val uri = if (type == "video") {
+                            MediaStore.Video.Media.EXTERNAL_CONTENT_URI
+                        } else {
+                            MediaStore.Images.Media.EXTERNAL_CONTENT_URI
+                        }
+
+                        val sortOrder = "${MediaStore.MediaColumns.DATE_ADDED} DESC"
+
+                        contentResolver.query(uri, projection, null, null, sortOrder)?.use { cursor ->
+                            val nameCol = cursor.getColumnIndexOrThrow(MediaStore.MediaColumns.DISPLAY_NAME)
+                            val dataCol = cursor.getColumnIndexOrThrow(MediaStore.MediaColumns.DATA)
+                            val sizeCol = cursor.getColumnIndexOrThrow(MediaStore.MediaColumns.SIZE)
+                            val mimeCol = cursor.getColumnIndexOrThrow(MediaStore.MediaColumns.MIME_TYPE)
+
+                            var count = 0
+                            while (cursor.moveToNext() && count < 500) {
+                                val path = cursor.getString(dataCol)
+                                if (path != null && java.io.File(path).exists()) {
+                                    mediaList.add(mapOf(
+                                        "name" to (cursor.getString(nameCol) ?: "Unknown"),
+                                        "path" to path,
+                                        "size" to cursor.getLong(sizeCol),
+                                        "mimeType" to (cursor.getString(mimeCol) ?: "")
+                                    ))
+                                    count++
+                                }
+                            }
+                        }
+                        result.success(mediaList)
+                    } catch (e: Exception) {
+                        result.error("MEDIA_SCAN_ERROR", e.message, null)
+                    }
+                }
+
+                "openHotspotSettings" -> {
+                    try {
+                        val intent = Intent()
+                        intent.action = "android.settings.TETHER_SETTINGS"
+                        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                        startActivity(intent)
+                        result.success(true)
+                    } catch (e: Exception) {
+                        try {
+                            val intent = Intent(Settings.ACTION_WIRELESS_SETTINGS)
+                            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                            startActivity(intent)
+                            result.success(true)
+                        } catch (e2: Exception) {
+                            result.success(false)
+                        }
+                    }
+                }
+
+                "openBluetoothSettings" -> {
+                    try {
+                        val intent = Intent(Settings.ACTION_BLUETOOTH_SETTINGS)
+                        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                        startActivity(intent)
+                        result.success(true)
                     } catch (e: Exception) {
                         result.success(false)
                     }
@@ -55,5 +274,46 @@ class MainActivity : FlutterActivity() {
                 else -> result.notImplemented()
             }
         }
+
+        EventChannel(flutterEngine.dartExecutor.binaryMessenger, BLUETOOTH_STATE_CHANNEL).setStreamHandler(
+            object : EventChannel.StreamHandler {
+                override fun onListen(arguments: Any?, events: EventChannel.EventSink?) {
+                    bluetoothReceiver = object : BroadcastReceiver() {
+                        override fun onReceive(context: Context?, intent: Intent?) {
+                            if (intent?.action == BluetoothAdapter.ACTION_STATE_CHANGED) {
+                                val state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.ERROR)
+                                val isEnabled = (state == BluetoothAdapter.STATE_ON)
+                                events?.success(isEnabled)
+                            }
+                        }
+                    }
+                    val filter = IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED)
+                    registerReceiver(bluetoothReceiver, filter)
+                    
+                    val adapter = BluetoothAdapter.getDefaultAdapter()
+                    events?.success(adapter?.isEnabled == true)
+                }
+
+                override fun onCancel(arguments: Any?) {
+                    unregisterReceiver(bluetoothReceiver)
+                    bluetoothReceiver = null
+                }
+            }
+        )
+    }
+
+    private fun drawableToBitmap(drawable: Drawable): Bitmap {
+        if (drawable is BitmapDrawable) {
+            return drawable.bitmap
+        }
+        val bitmap = Bitmap.createBitmap(
+            drawable.intrinsicWidth.coerceAtLeast(1),
+            drawable.intrinsicHeight.coerceAtLeast(1),
+            Bitmap.Config.ARGB_8888
+        )
+        val canvas = Canvas(bitmap)
+        drawable.setBounds(0, 0, canvas.width, canvas.height)
+        drawable.draw(canvas)
+        return bitmap
     }
 }