├── app
    ├── .gitignore
    ├── src
    │   ├── main
    │   │   ├── res
    │   │   │   ├── values
    │   │   │   │   ├── strings.xml
    │   │   │   │   ├── themes.xml
    │   │   │   │   └── colors.xml
    │   │   │   └── xml
    │   │   │   │   ├── backup_rules.xml
    │   │   │   │   └── data_extraction_rules.xml
    │   │   ├── java
    │   │   │   └── com
    │   │   │   │   └── example
    │   │   │   │       └── cameralink
    │   │   │   │           ├── ui
    │   │   │   │               └── theme
    │   │   │   │               │   ├── Color.kt
    │   │   │   │               │   ├── Type.kt
    │   │   │   │               │   └── Theme.kt
    │   │   │   │           ├── TailscalePingWorker.kt
    │   │   │   │           ├── TailscalePingScheduler.kt
    │   │   │   │           ├── TailscalePingService.kt
    │   │   │   │           ├── TailscalePinger.kt
    │   │   │   │           ├── CameraStreamingService.kt
    │   │   │   │           ├── CameraScreen.kt
    │   │   │   │           ├── MainActivity.kt
    │   │   │   │           └── StreamingServer.kt
    │   │   └── AndroidManifest.xml
    │   ├── test
    │   │   └── java
    │   │   │   └── com
    │   │   │       └── example
    │   │   │           └── cameralink
    │   │   │               └── ExampleUnitTest.kt
    │   └── androidTest
    │   │   └── java
    │   │       └── com
    │   │           └── example
    │   │               └── cameralink
    │   │                   └── ExampleInstrumentedTest.kt
    ├── proguard-rules.pro
    └── build.gradle.kts
├── .gitignore
├── .DS_Store
├── gradle
    └── wrapper
    │   └── gradle-wrapper.properties
├── local.properties
├── settings.gradle.kts
├── LICENSE
├── gradle.properties
├── test_stream.bat
└── README.md


/app/.gitignore:
--------------------------------------------------------------------------------
1 | /build


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # Project exclude paths
2 | /.gradle/


--------------------------------------------------------------------------------
/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/onepersonhere/camera-link/HEAD/.DS_Store


--------------------------------------------------------------------------------
/app/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
1 | <resources>
2 |     <string name="app_name">Camera Link</string>
3 | </resources>


--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.properties:
--------------------------------------------------------------------------------
1 | #Sat Nov 01 20:48:20 SGT 2025
2 | distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
3 | 


--------------------------------------------------------------------------------
/app/src/main/res/values/themes.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <resources>
3 |     <style name="Theme.CameraLink" parent="android:Theme.Material.Light.NoActionBar"/>
4 | </resources>


--------------------------------------------------------------------------------
/local.properties:
--------------------------------------------------------------------------------
1 | ## This file must *NOT* be checked into Version Control Systems,
2 | # as it contains information specific to your local configuration.
3 | #
4 | # Location of the SDK. This is only used by Gradle.
5 | # For customization when using a Version Control System, please read the
6 | # header note.
7 | #Sun Nov 02 07:45:56 SGT 2025
8 | sdk.dir=/Users/wh/Library/Android/sdk
9 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/example/cameralink/ui/theme/Color.kt:
--------------------------------------------------------------------------------
 1 | package com.example.cameralink.ui.theme
 2 | 
 3 | import androidx.compose.ui.graphics.Color
 4 | 
 5 | val Purple80 = Color(0xFFD0BCFF)
 6 | val PurpleGrey80 = Color(0xFFCCC2DC)
 7 | val Pink80 = Color(0xFFEFB8C8)
 8 | 
 9 | val Purple40 = Color(0xFF6650a4)
10 | val PurpleGrey40 = Color(0xFF625b71)
11 | val Pink40 = Color(0xFF7D5260)


--------------------------------------------------------------------------------
/app/src/main/res/values/colors.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <resources>
 3 |     <color name="purple_200">#FFBB86FC</color>
 4 |     <color name="purple_500">#FF6200EE</color>
 5 |     <color name="purple_700">#FF3700B3</color>
 6 |     <color name="teal_200">#FF03DAC5</color>
 7 |     <color name="teal_700">#FF018786</color>
 8 |     <color name="black">#FF000000</color>
 9 |     <color name="white">#FFFFFFFF</color>
10 | </resources>


--------------------------------------------------------------------------------
/app/src/test/java/com/example/cameralink/ExampleUnitTest.kt:
--------------------------------------------------------------------------------
 1 | package com.example.cameralink
 2 | 
 3 | import org.junit.Test
 4 | 
 5 | import org.junit.Assert.*
 6 | 
 7 | /**
 8 |  * Example local unit test, which will execute on the development machine (host).
 9 |  *
10 |  * See [testing documentation](http://d.android.com/tools/testing).
11 |  */
12 | class ExampleUnitTest {
13 |     @Test
14 |     fun addition_isCorrect() {
15 |         assertEquals(4, 2 + 2)
16 |     }
17 | }


--------------------------------------------------------------------------------
/app/src/main/res/xml/backup_rules.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!--
 3 |    Sample backup rules file; uncomment and customize as necessary.
 4 |    See https://developer.android.com/guide/topics/data/autobackup
 5 |    for details.
 6 |    Note: This file is ignored for devices older than API 31
 7 |    See https://developer.android.com/about/versions/12/backup-restore
 8 | -->
 9 | <full-backup-content>
10 |     <!--
11 |    <include domain="sharedpref" path="."/>
12 |    <exclude domain="sharedpref" path="device.xml"/>
13 | -->
14 | </full-backup-content>


--------------------------------------------------------------------------------
/settings.gradle.kts:
--------------------------------------------------------------------------------
 1 | pluginManagement {
 2 |     repositories {
 3 |         google {
 4 |             content {
 5 |                 includeGroupByRegex("com\\.android.*")
 6 |                 includeGroupByRegex("com\\.google.*")
 7 |                 includeGroupByRegex("androidx.*")
 8 |             }
 9 |         }
10 |         mavenCentral()
11 |         gradlePluginPortal()
12 |     }
13 | }
14 | dependencyResolutionManagement {
15 |     repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
16 |     repositories {
17 |         google()
18 |         mavenCentral()
19 |     }
20 | }
21 | 
22 | rootProject.name = "Camera Link"
23 | include(":app")
24 |  


--------------------------------------------------------------------------------
/app/src/main/res/xml/data_extraction_rules.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!--
 3 |    Sample data extraction rules file; uncomment and customize as necessary.
 4 |    See https://developer.android.com/about/versions/12/backup-restore#xml-changes
 5 |    for details.
 6 | -->
 7 | <data-extraction-rules>
 8 |     <cloud-backup>
 9 |         <!-- TODO: Use <include> and <exclude> to control what is backed up.
10 |         <include .../>
11 |         <exclude .../>
12 |         -->
13 |     </cloud-backup>
14 |     <!--
15 |     <device-transfer>
16 |         <include .../>
17 |         <exclude .../>
18 |     </device-transfer>
19 |     -->
20 | </data-extraction-rules>


--------------------------------------------------------------------------------
/app/src/androidTest/java/com/example/cameralink/ExampleInstrumentedTest.kt:
--------------------------------------------------------------------------------
 1 | package com.example.cameralink
 2 | 
 3 | import androidx.test.platform.app.InstrumentationRegistry
 4 | import androidx.test.ext.junit.runners.AndroidJUnit4
 5 | 
 6 | import org.junit.Test
 7 | import org.junit.runner.RunWith
 8 | 
 9 | import org.junit.Assert.*
10 | 
11 | /**
12 |  * Instrumented test, which will execute on an Android device.
13 |  *
14 |  * See [testing documentation](http://d.android.com/tools/testing).
15 |  */
16 | @RunWith(AndroidJUnit4::class)
17 | class ExampleInstrumentedTest {
18 |     @Test
19 |     fun useAppContext() {
20 |         // Context of the app under test.
21 |         val appContext = InstrumentationRegistry.getInstrumentation().targetContext
22 |         assertEquals("com.example.cameralink", appContext.packageName)
23 |     }
24 | }


--------------------------------------------------------------------------------
/app/proguard-rules.pro:
--------------------------------------------------------------------------------
 1 | # Add project specific ProGuard rules here.
 2 | # You can control the set of applied configuration files using the
 3 | # proguardFiles setting in build.gradle.
 4 | #
 5 | # For more details, see
 6 | #   http://developer.android.com/guide/developing/tools/proguard.html
 7 | 
 8 | # If your project uses WebView with JS, uncomment the following
 9 | # and specify the fully qualified class name to the JavaScript interface
10 | # class:
11 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
12 | #   public *;
13 | #}
14 | 
15 | # Uncomment this to preserve the line number information for
16 | # debugging stack traces.
17 | #-keepattributes SourceFile,LineNumberTable
18 | 
19 | # If you keep the line number information, uncomment this to
20 | # hide the original source file name.
21 | #-renamesourcefileattribute SourceFile


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2025 CameraLink contributors
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 
23 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/example/cameralink/ui/theme/Type.kt:
--------------------------------------------------------------------------------
 1 | package com.example.cameralink.ui.theme
 2 | 
 3 | import androidx.compose.material3.Typography
 4 | import androidx.compose.ui.text.TextStyle
 5 | import androidx.compose.ui.text.font.FontFamily
 6 | import androidx.compose.ui.text.font.FontWeight
 7 | import androidx.compose.ui.unit.sp
 8 | 
 9 | // Set of Material typography styles to start with
10 | val Typography = Typography(
11 |     bodyLarge = TextStyle(
12 |         fontFamily = FontFamily.Default,
13 |         fontWeight = FontWeight.Normal,
14 |         fontSize = 16.sp,
15 |         lineHeight = 24.sp,
16 |         letterSpacing = 0.5.sp
17 |     )
18 |     /* Other default text styles to override
19 |     titleLarge = TextStyle(
20 |         fontFamily = FontFamily.Default,
21 |         fontWeight = FontWeight.Normal,
22 |         fontSize = 22.sp,
23 |         lineHeight = 28.sp,
24 |         letterSpacing = 0.sp
25 |     ),
26 |     labelSmall = TextStyle(
27 |         fontFamily = FontFamily.Default,
28 |         fontWeight = FontWeight.Medium,
29 |         fontSize = 11.sp,
30 |         lineHeight = 16.sp,
31 |         letterSpacing = 0.5.sp
32 |     )
33 |     */
34 | )


--------------------------------------------------------------------------------
/gradle.properties:
--------------------------------------------------------------------------------
 1 | # Project-wide Gradle settings.
 2 | # IDE (e.g. Android Studio) users:
 3 | # Gradle settings configured through the IDE *will override*
 4 | # any settings specified in this file.
 5 | # For more details on how to configure your build environment visit
 6 | # http://www.gradle.org/docs/current/userguide/build_environment.html
 7 | # Specifies the JVM arguments used for the daemon process.
 8 | # The setting is particularly useful for tweaking memory settings.
 9 | org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
10 | # When configured, Gradle will run in incubating parallel mode.
11 | # This option should only be used with decoupled projects. For more details, visit
12 | # https://developer.android.com/r/tools/gradle-multi-project-decoupled-projects
13 | # org.gradle.parallel=true
14 | # AndroidX package structure to make it clearer which packages are bundled with the
15 | # Android operating system, and which are packaged with your app's APK
16 | # https://developer.android.com/topic/libraries/support-library/androidx-rn
17 | android.useAndroidX=true
18 | # Kotlin code style for this project: "official" or "obsolete":
19 | kotlin.code.style=official
20 | # Enables namespacing of each library's R class so that its R class includes only the
21 | # resources declared in the library itself and none from the library's dependencies,
22 | # thereby reducing the size of the R class for that library
23 | android.nonTransitiveRClass=true


--------------------------------------------------------------------------------
/app/src/main/java/com/example/cameralink/TailscalePingWorker.kt:
--------------------------------------------------------------------------------
 1 | package com.example.cameralink
 2 | import android.content.Context
 3 | import android.util.Log
 4 | import androidx.work.CoroutineWorker
 5 | import androidx.work.WorkerParameters
 6 | import kotlinx.coroutines.Dispatchers
 7 | import kotlinx.coroutines.withContext
 8 | /**
 9 |  * WorkManager Worker that periodically pings all Tailscale connections
10 |  */
11 | class TailscalePingWorker(
12 |     context: Context,
13 |     params: WorkerParameters
14 | ) : CoroutineWorker(context, params) {
15 |     companion object {
16 |         private const val TAG = "TailscalePingWorker"
17 |         const val WORK_NAME = "tailscale_ping_work"
18 |     }
19 |     override suspend fun doWork(): Result = withContext(Dispatchers.IO) {
20 |         try {
21 |             Log.d(TAG, "Starting Tailscale ping job")
22 |             // Ping all Tailscale connections
23 |             val results = TailscalePinger.pingAllTailscaleConnections()
24 |             if (results.isEmpty()) {
25 |                 Log.i(TAG, "No Tailscale connections to ping")
26 |             } else {
27 |                 val successCount = results.values.count { it }
28 |                 Log.i(TAG, "Pinged ${results.size} Tailscale connection(s): $successCount successful")
29 |             }
30 |             Result.success()
31 |         } catch (e: Exception) {
32 |             Log.e(TAG, "Error in Tailscale ping worker", e)
33 |             Result.retry()
34 |         }
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/example/cameralink/ui/theme/Theme.kt:
--------------------------------------------------------------------------------
 1 | package com.example.cameralink.ui.theme
 2 | 
 3 | import android.app.Activity
 4 | import android.os.Build
 5 | import androidx.compose.foundation.isSystemInDarkTheme
 6 | import androidx.compose.material3.MaterialTheme
 7 | import androidx.compose.material3.darkColorScheme
 8 | import androidx.compose.material3.dynamicDarkColorScheme
 9 | import androidx.compose.material3.dynamicLightColorScheme
10 | import androidx.compose.material3.lightColorScheme
11 | import androidx.compose.runtime.Composable
12 | import androidx.compose.ui.platform.LocalContext
13 | 
14 | private val DarkColorScheme = darkColorScheme(
15 |     primary = Purple80,
16 |     secondary = PurpleGrey80,
17 |     tertiary = Pink80
18 | )
19 | 
20 | private val LightColorScheme = lightColorScheme(
21 |     primary = Purple40,
22 |     secondary = PurpleGrey40,
23 |     tertiary = Pink40
24 | 
25 |     /* Other default colors to override
26 |     background = Color(0xFFFFFBFE),
27 |     surface = Color(0xFFFFFBFE),
28 |     onPrimary = Color.White,
29 |     onSecondary = Color.White,
30 |     onTertiary = Color.White,
31 |     onBackground = Color(0xFF1C1B1F),
32 |     onSurface = Color(0xFF1C1B1F),
33 |     */
34 | )
35 | 
36 | @Composable
37 | fun CameraLinkTheme(
38 |     darkTheme: Boolean = isSystemInDarkTheme(),
39 |     // Dynamic color is available on Android 12+
40 |     dynamicColor: Boolean = true,
41 |     content: @Composable () -> Unit
42 | ) {
43 |     val colorScheme = when {
44 |         dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
45 |             val context = LocalContext.current
46 |             if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
47 |         }
48 | 
49 |         darkTheme -> DarkColorScheme
50 |         else -> LightColorScheme
51 |     }
52 | 
53 |     MaterialTheme(
54 |         colorScheme = colorScheme,
55 |         typography = Typography,
56 |         content = content
57 |     )
58 | }


--------------------------------------------------------------------------------
/app/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <manifest xmlns:android="http://schemas.android.com/apk/res/android"
 3 |           xmlns:tools="http://schemas.android.com/tools">
 4 | 
 5 |     <uses-feature android:name="android.hardware.camera" android:required="true" />
 6 |     <uses-permission android:name="android.permission.CAMERA" />
 7 |     <uses-permission android:name="android.permission.INTERNET" />
 8 |     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
 9 |     <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
10 |     <uses-permission android:name="android.permission.WAKE_LOCK" />
11 |     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
12 |     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_CAMERA" />
13 |     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
14 | 
15 |     <application
16 |             android:allowBackup="true"
17 |             android:dataExtractionRules="@xml/data_extraction_rules"
18 |             android:fullBackupContent="@xml/backup_rules"
19 |             android:label="@string/app_name"
20 |             android:supportsRtl="true"
21 |             android:theme="@style/Theme.CameraLink">
22 |         <activity
23 |                 android:name=".MainActivity"
24 |                 android:exported="true"
25 |                 android:label="@string/app_name"
26 |                 android:theme="@style/Theme.CameraLink">
27 |             <intent-filter>
28 |                 <action android:name="android.intent.action.MAIN"/>
29 | 
30 |                 <category android:name="android.intent.category.LAUNCHER"/>
31 |             </intent-filter>
32 |         </activity>
33 | 
34 |         <service
35 |                 android:name=".CameraStreamingService"
36 |                 android:enabled="true"
37 |                 android:exported="false"
38 |                 android:foregroundServiceType="camera" />
39 | 
40 |         <service
41 |                 android:name=".TailscalePingService"
42 |                 android:enabled="true"
43 |                 android:exported="false" />
44 |     </application>
45 | 
46 | </manifest>


--------------------------------------------------------------------------------
/app/src/main/java/com/example/cameralink/TailscalePingScheduler.kt:
--------------------------------------------------------------------------------
 1 | package com.example.cameralink
 2 | 
 3 | import android.content.Context
 4 | import android.util.Log
 5 | import androidx.work.Constraints
 6 | import androidx.work.ExistingPeriodicWorkPolicy
 7 | import androidx.work.NetworkType
 8 | import androidx.work.PeriodicWorkRequestBuilder
 9 | import androidx.work.WorkManager
10 | import java.util.concurrent.TimeUnit
11 | 
12 | /**
13 |  * Manager class to schedule and manage Tailscale ping jobs
14 |  */
15 | object TailscalePingScheduler {
16 |     private const val TAG = "TailscalePingScheduler"
17 | 
18 |     /**
19 |      * Schedule periodic Tailscale pinging every 15 seconds
20 |      * Note: Due to WorkManager limitations, we use 15-minute intervals with repeating work.
21 |      * For true 15-second intervals, use startForegroundPinging() instead.
22 |      */
23 |     fun schedulePeriodicPing(context: Context) {
24 |         val constraints = Constraints.Builder()
25 |             .setRequiredNetworkType(NetworkType.CONNECTED)
26 |             .build()
27 | 
28 |         val pingWorkRequest = PeriodicWorkRequestBuilder<TailscalePingWorker>(
29 |             15, TimeUnit.MINUTES, // Minimum allowed by WorkManager
30 |             5, TimeUnit.MINUTES // Flex period
31 |         )
32 |             .setConstraints(constraints)
33 |             .setInitialDelay(0, TimeUnit.SECONDS)
34 |             .build()
35 | 
36 |         WorkManager.getInstance(context).enqueueUniquePeriodicWork(
37 |             TailscalePingWorker.WORK_NAME,
38 |             ExistingPeriodicWorkPolicy.KEEP, // Keep existing work if already scheduled
39 |             pingWorkRequest
40 |         )
41 | 
42 |         Log.i(TAG, "Scheduled Tailscale ping job to run every 15 minutes (WorkManager limitation)")
43 |     }
44 | 
45 |     /**
46 |      * Cancel the periodic Tailscale ping job
47 |      */
48 |     fun cancelPeriodicPing(context: Context) {
49 |         WorkManager.getInstance(context).cancelUniqueWork(TailscalePingWorker.WORK_NAME)
50 |         Log.i(TAG, "Cancelled Tailscale ping job")
51 |     }
52 | 
53 |     /**
54 |      * Check if the periodic ping job is currently scheduled
55 |      */
56 |     fun isScheduled(context: Context): Boolean {
57 |         val workInfos = WorkManager.getInstance(context)
58 |             .getWorkInfosForUniqueWork(TailscalePingWorker.WORK_NAME)
59 |             .get()
60 |         return workInfos.any { !it.state.isFinished }
61 |     }
62 | }
63 | 
64 | 


--------------------------------------------------------------------------------
/app/build.gradle.kts:
--------------------------------------------------------------------------------
 1 | plugins {
 2 |     id("com.android.application")
 3 |     id("org.jetbrains.kotlin.android")
 4 |     id("org.jetbrains.kotlin.plugin.compose")
 5 | }
 6 | 
 7 | android {
 8 |     namespace = "com.example.cameralink"
 9 |     compileSdk = 36
10 | 
11 |     defaultConfig {
12 |         applicationId = "com.example.cameralink"
13 |         minSdk = 31
14 |         targetSdk = 36
15 |         versionCode = 1
16 |         versionName = "1.0"
17 | 
18 |         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
19 |     }
20 | 
21 |     buildTypes {
22 |         release {
23 |             isMinifyEnabled = false
24 |             proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
25 |         }
26 |     }
27 |     compileOptions {
28 |         sourceCompatibility = JavaVersion.VERSION_11
29 |         targetCompatibility = JavaVersion.VERSION_11
30 |     }
31 |     kotlinOptions {
32 |         jvmTarget = "11"
33 |     }
34 |     buildFeatures {
35 |         compose = true
36 |     }
37 | }
38 | 
39 | dependencies {
40 | 
41 |     implementation("androidx.core:core-ktx:1.10.1")
42 |     implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.6.1")
43 |     implementation("androidx.lifecycle:lifecycle-service:2.6.1")
44 |     implementation("androidx.activity:activity-compose:1.8.0")
45 |     implementation(platform("androidx.compose:compose-bom:2024.09.00"))
46 |     implementation("androidx.compose.ui:ui")
47 |     implementation("androidx.compose.ui:ui-graphics")
48 |     implementation("androidx.compose.ui:ui-tooling-preview")
49 |     implementation("androidx.compose.material3:material3")
50 | 
51 |     // CameraX dependencies
52 |     implementation("androidx.camera:camera-camera2:1.3.0")
53 |     implementation("androidx.camera:camera-lifecycle:1.3.0")
54 |     implementation("androidx.camera:camera-view:1.3.0")
55 | 
56 |     // HTTP Server for streaming
57 |     implementation("org.nanohttpd:nanohttpd:2.3.1")
58 | 
59 |     // Permissions
60 |     implementation("com.google.accompanist:accompanist-permissions:0.33.2-alpha")
61 | 
62 |     // WorkManager for periodic tasks
63 |     implementation("androidx.work:work-runtime-ktx:2.9.0")
64 | 
65 |     testImplementation("junit:junit:4.13.2")
66 |     androidTestImplementation("androidx.test.ext:junit:1.1.5")
67 |     androidTestImplementation("androidx.test.espresso:espresso-core:3.5.1")
68 |     androidTestImplementation(platform("androidx.compose:compose-bom:2024.09.00"))
69 |     androidTestImplementation("androidx.compose.ui:ui-test-junit4")
70 |     debugImplementation("androidx.compose.ui:ui-tooling")
71 |     debugImplementation("androidx.compose.ui:ui-test-manifest")
72 | }


--------------------------------------------------------------------------------
/test_stream.bat:
--------------------------------------------------------------------------------
  1 | @echo off
  2 | REM CameraLink - Quick Test Script
  3 | REM This script helps you test the streaming functionality
  4 | 
  5 | echo ============================================
  6 | echo CameraLink - Stream Testing Helper
  7 | echo ============================================
  8 | echo.
  9 | 
 10 | :MENU
 11 | echo Select an option:
 12 | echo 1. Check if phone is connected
 13 | echo 2. View app logs (monitor streaming)
 14 | echo 3. Get phone's IP address
 15 | echo 4. Install APK to phone
 16 | echo 5. Test stream URL from this computer
 17 | echo 6. Open stream in browser
 18 | echo 7. Exit
 19 | echo.
 20 | set /p choice="Enter your choice (1-7): "
 21 | 
 22 | if "%choice%"=="1" goto CHECK_DEVICE
 23 | if "%choice%"=="2" goto VIEW_LOGS
 24 | if "%choice%"=="3" goto GET_IP
 25 | if "%choice%"=="4" goto INSTALL_APK
 26 | if "%choice%"=="5" goto TEST_URL
 27 | if "%choice%"=="6" goto OPEN_BROWSER
 28 | if "%choice%"=="7" goto END
 29 | 
 30 | echo Invalid choice. Please try again.
 31 | echo.
 32 | goto MENU
 33 | 
 34 | :CHECK_DEVICE
 35 | echo.
 36 | echo Checking for connected Android devices...
 37 | adb devices
 38 | echo.
 39 | echo If you see your device listed above, it's connected!
 40 | echo If not, make sure:
 41 | echo - USB Debugging is enabled on your phone
 42 | echo - Phone is connected via USB
 43 | echo - USB drivers are installed
 44 | echo.
 45 | pause
 46 | goto MENU
 47 | 
 48 | :VIEW_LOGS
 49 | echo.
 50 | echo Monitoring CameraLink logs... (Press Ctrl+C to stop)
 51 | echo.
 52 | adb logcat -s CameraStreamingService:* StreamingServer:* MainActivity:*
 53 | pause
 54 | goto MENU
 55 | 
 56 | :GET_IP
 57 | echo.
 58 | echo Getting phone's IP address...
 59 | echo.
 60 | echo Method 1: From phone shell
 61 | adb shell ip addr show wlan0 | findstr "inet "
 62 | echo.
 63 | echo Method 2: Alternative
 64 | adb shell ifconfig wlan0 | findstr "inet "
 65 | echo.
 66 | echo Look for the IP address (usually 192.168.x.x or 10.x.x.x)
 67 | echo.
 68 | pause
 69 | goto MENU
 70 | 
 71 | :INSTALL_APK
 72 | echo.
 73 | echo Installing CameraLink APK...
 74 | echo.
 75 | set /p apk_path="Enter full path to APK file (or press Enter for default): "
 76 | if "%apk_path%"=="" set apk_path=app\build\outputs\apk\debug\app-debug.apk
 77 | echo Installing from: %apk_path%
 78 | adb install -r "%apk_path%"
 79 | echo.
 80 | echo Installation complete!
 81 | echo.
 82 | pause
 83 | goto MENU
 84 | 
 85 | :TEST_URL
 86 | echo.
 87 | set /p stream_ip="Enter your phone's IP address: "
 88 | set stream_url=http://%stream_ip%:8080
 89 | echo.
 90 | echo Testing connection to %stream_url%
 91 | echo.
 92 | curl -I %stream_url%
 93 | echo.
 94 | echo If you see "HTTP/1.1 200 OK" above, the stream is working!
 95 | echo.
 96 | pause
 97 | goto MENU
 98 | 
 99 | :OPEN_BROWSER
100 | echo.
101 | set /p stream_ip="Enter your phone's IP address: "
102 | set stream_url=http://%stream_ip%:8080
103 | echo.
104 | echo Opening %stream_url% in your default browser...
105 | start %stream_url%
106 | echo.
107 | pause
108 | goto MENU
109 | 
110 | :END
111 | echo.
112 | echo Thank you for using CameraLink!
113 | echo.
114 | exit /b
115 | 
116 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # CameraLink
 2 | 
 3 | CameraLink turns any Android 12+ phone into an HTTP-based IP camera with an optional Tailscale keep-alive service. The app keeps streaming even with the screen off, exposes a browser-friendly MJPEG feed, and periodically pings configured Tailscale peers so remote access stays responsive.
 4 | 
 5 | ## Feature Highlights
 6 | - Live MJPEG streaming over HTTP, viewable from any modern browser or VLC
 7 | - Foreground camera service with wake lock for reliable screen-off streaming
 8 | - Built-in HTTP endpoints for `/`, `/stream`, `/snapshot`, and `/test`
 9 | - Background Tailscale ping service with configurable peers and interval
10 | - Persistent notifications for both streaming and pinging with quick controls
11 | - Snapshot capture, multi-viewer support, and MagicDNS hostname resolution
12 | 
13 | ## Architecture Overview
14 | - **CameraStreamingService**: Foreground service that owns CameraX capture, wake locks, and lifecycle.
15 | - **StreamingServer**: Embedded NanoHTTPD server that serves frames as MJPEG or single JPEG snapshots.
16 | - **TailscalePingService + TailscalePinger**: Foreground service that resolves peers, issues ICMP pings every 15 seconds by default, and updates status in notifications/UI.
17 | - **MainActivity**: Compose UI for starting/stopping services, showing stream URLs, peer status, and editing peer lists.
18 | 
19 | The app targets Android API level 31+ and is written entirely in Kotlin with Jetpack Compose and CameraX.
20 | 
21 | ## Getting Started
22 | 
23 | ### Prerequisites
24 | - Android Studio Ladybug or newer
25 | - Android SDK 31 or higher installed locally
26 | - A physical Android device running Android 12+ with USB debugging enabled
27 | - Java 17+ if building from the command line
28 | 
29 | ### Clone and Build
30 | ```bash
31 | git clone https://github.com/yourusername/camera-link.git
32 | cd camera-link
33 | ./gradlew assembleDebug
34 | ```
35 | 
36 | ### Install
37 | - **Android Studio**: Open the project, sync Gradle, connect a device, and press Run to deploy the debug build.
38 | - **Command line**:
39 |   ```bash
40 |   ./gradlew installDebug
41 |   # or manually install the generated APK
42 |   adb install app/build/outputs/apk/debug/app-debug.apk
43 |   ```
44 | 
45 | ## Usage
46 | 
47 | ### Start Streaming
48 | 1. Launch CameraLink on the device.
49 | 2. Grant camera, notification, and foreground service permissions when prompted.
50 | 3. Tap **Start Streaming**. The UI and notification display the local stream URL (default `http://<device-ip>:8080`).
51 | 4. Open the URL from any device on the same network to view the live feed or trigger `/snapshot`.
52 | 5. Stop streaming from the in-app button or the notification action.
53 | 
54 | Screen-off and background streaming remain active as long as the foreground service runs. Disable battery optimizations for best reliability.
55 | 
56 | ### Tailscale Keep-Alive
57 | 1. TailscalePingService starts automatically (configurable in `MainActivity`).
58 | 2. Every 15 seconds (default) it resolves configured peers (MagicDNS or 100.64.0.0/10 addresses) and pings them.
59 | 3. Status appears in app and notification (successful/failed counts).
60 | 4. Use the **Manage Tailscale Peers** section to add or remove peers at runtime.
61 | 
62 | ## Configuration
63 | - **Ping interval**: `app/src/main/java/.../TailscalePingService.kt`, `PING_INTERVAL_MS` constant.
64 | - **Default peers**: `TailscalePinger.kt`, `configuredTailscaleIps` set.
65 | - **HTTP port**: `CameraStreamingService.kt` and `MainActivity.kt` `port` value (default 8080).
66 | - **Camera selection**: Update `cameraSelector` in `CameraStreamingService.startCamera()` to choose front or back camera.
67 | - **JPEG quality / FPS**: Adjust compression quality in `StreamingServer.imageProxyToJpeg()` and sleep duration in the streaming loop respectively.
68 | 
69 | ## Testing
70 | - **Local browser/VLC test**: Start streaming, visit `/stream` or `/snapshot` from another device, or add the URL to VLC via “Open Network Stream.”
71 | - **Service longevity**: Leave the stream running 30+ minutes with the screen off to confirm wake lock behavior.
72 | - **Tailscale ping verification**: Run `adb logcat | grep TailscalePing` to confirm resolution and ping outcomes.
73 | 
74 | ## Development Notes
75 | - Project structure follows the standard Android Gradle layout under `app/src/main`.
76 | - Dependencies include CameraX, Jetpack Compose, NanoHTTPD, Lifecycle runtime/service, Accompanist Permissions, WorkManager, and Kotlin coroutines.
77 | - Common commands:
78 |   ```bash
79 |   ./gradlew lint
80 |   ./gradlew test
81 |   ./gradlew assembleRelease
82 |   ```
83 | - When modifying streaming code, test on physical hardware; emulators lack the necessary camera and network characteristics.
84 | 
85 | ## Contributing
86 | Issues and pull requests are welcome. Please include reproducible steps, device details, and logs for bug reports. For larger changes, open an issue first so we can discuss design and testing expectations.
87 | 
88 | ## License
89 | CameraLink is distributed under the [MIT License](./LICENSE). By contributing, you agree that your contributions will be licensed under the same terms.
90 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/example/cameralink/TailscalePingService.kt:
--------------------------------------------------------------------------------
  1 | package com.example.cameralink
  2 | 
  3 | import android.app.Notification
  4 | import android.app.NotificationChannel
  5 | import android.app.NotificationManager
  6 | import android.app.PendingIntent
  7 | import android.app.Service
  8 | import android.content.Context
  9 | import android.content.Intent
 10 | import android.os.Build
 11 | import android.os.Handler
 12 | import android.os.IBinder
 13 | import android.os.Looper
 14 | import android.util.Log
 15 | import androidx.core.app.NotificationCompat
 16 | import kotlinx.coroutines.CoroutineScope
 17 | import kotlinx.coroutines.Dispatchers
 18 | import kotlinx.coroutines.Job
 19 | import kotlinx.coroutines.launch
 20 | 
 21 | /**
 22 |  * Foreground service that pings Tailscale connections every 15 seconds
 23 |  */
 24 | class TailscalePingService : Service() {
 25 | 
 26 |     private val handler = Handler(Looper.getMainLooper())
 27 |     private val serviceScope = CoroutineScope(Dispatchers.Default + Job())
 28 |     private var pingRunnable: Runnable? = null
 29 | 
 30 |     companion object {
 31 |         private const val TAG = "TailscalePingService"
 32 |         private const val PING_INTERVAL_MS = 15000L // 15 seconds
 33 |         private const val NOTIFICATION_ID = 2001
 34 |         private const val CHANNEL_ID = "tailscale_ping_channel"
 35 | 
 36 |         fun start(context: Context) {
 37 |             val intent = Intent(context, TailscalePingService::class.java)
 38 |             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
 39 |                 context.startForegroundService(intent)
 40 |             } else {
 41 |                 context.startService(intent)
 42 |             }
 43 |             Log.i(TAG, "Starting TailscalePingService")
 44 |         }
 45 | 
 46 |         fun stop(context: Context) {
 47 |             val intent = Intent(context, TailscalePingService::class.java)
 48 |             context.stopService(intent)
 49 |             Log.i(TAG, "Stopping TailscalePingService")
 50 |         }
 51 |     }
 52 | 
 53 |     override fun onCreate() {
 54 |         super.onCreate()
 55 |         createNotificationChannel()
 56 |         Log.i(TAG, "TailscalePingService created")
 57 | 
 58 |         // Start as foreground service
 59 |         startForeground(NOTIFICATION_ID, createNotification("Starting Tailscale ping service...", 0, 0))
 60 | 
 61 |         startPinging()
 62 |     }
 63 | 
 64 |     private fun startPinging() {
 65 |         pingRunnable = object : Runnable {
 66 |             override fun run() {
 67 |                 serviceScope.launch {
 68 |                     try {
 69 |                         Log.d(TAG, "🔄 Starting ping cycle...")
 70 |                         val results = TailscalePinger.pingAllTailscaleConnections()
 71 |                         if (results.isNotEmpty()) {
 72 |                             val successCount = results.values.count { it }
 73 |                             val totalCount = results.size
 74 |                             Log.i(TAG, "✅ Ping cycle complete: $successCount/$totalCount successful")
 75 | 
 76 |                             // Update notification with results
 77 |                             val notification = createNotification(
 78 |                                 "Tailscale Ping Active",
 79 |                                 successCount,
 80 |                                 totalCount
 81 |                             )
 82 |                             val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 83 |                             notificationManager.notify(NOTIFICATION_ID, notification)
 84 |                         } else {
 85 |                             Log.w(TAG, "⚠️ No Tailscale targets configured")
 86 |                         }
 87 |                     } catch (e: Exception) {
 88 |                         Log.e(TAG, "❌ Error during ping cycle", e)
 89 |                     }
 90 |                 }
 91 |                 // Schedule next ping
 92 |                 handler.postDelayed(this, PING_INTERVAL_MS)
 93 |             }
 94 |         }
 95 |         // Start first ping immediately
 96 |         handler.post(pingRunnable!!)
 97 |         Log.i(TAG, "🚀 Started pinging every ${PING_INTERVAL_MS / 1000} seconds")
 98 |     }
 99 | 
100 |     private fun createNotificationChannel() {
101 |         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
102 |             val channel = NotificationChannel(
103 |                 CHANNEL_ID,
104 |                 "Tailscale Ping Service",
105 |                 NotificationManager.IMPORTANCE_LOW
106 |             ).apply {
107 |                 description = "Keeps Tailscale connections alive by pinging peers"
108 |                 setShowBadge(false)
109 |             }
110 | 
111 |             val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
112 |             notificationManager.createNotificationChannel(channel)
113 |         }
114 |     }
115 | 
116 |     private fun createNotification(title: String, successCount: Int, totalCount: Int): Notification {
117 |         val contentIntent = Intent(this, MainActivity::class.java)
118 |         val contentPendingIntent = PendingIntent.getActivity(
119 |             this,
120 |             0,
121 |             contentIntent,
122 |             PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
123 |         )
124 | 
125 |         val contentText = if (totalCount > 0) {
126 |             "Pinging $totalCount device(s): $successCount online"
127 |         } else {
128 |             "Monitoring Tailscale connections"
129 |         }
130 | 
131 |         return NotificationCompat.Builder(this, CHANNEL_ID)
132 |             .setContentTitle(title)
133 |             .setContentText(contentText)
134 |             .setSmallIcon(android.R.drawable.ic_menu_mylocation)
135 |             .setOngoing(true)
136 |             .setContentIntent(contentPendingIntent)
137 |             .setPriority(NotificationCompat.PRIORITY_LOW)
138 |             .build()
139 |     }
140 | 
141 |     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
142 |         Log.d(TAG, "onStartCommand called")
143 |         return START_STICKY
144 |     }
145 | 
146 |     override fun onDestroy() {
147 |         super.onDestroy()
148 |         pingRunnable?.let { handler.removeCallbacks(it) }
149 |         Log.i(TAG, "🛑 TailscalePingService destroyed")
150 |     }
151 | 
152 |     override fun onBind(intent: Intent): IBinder? {
153 |         return null
154 |     }
155 | }
156 | 
157 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/example/cameralink/TailscalePinger.kt:
--------------------------------------------------------------------------------
  1 | package com.example.cameralink
  2 | 
  3 | import android.util.Log
  4 | import kotlinx.coroutines.Dispatchers
  5 | import kotlinx.coroutines.withContext
  6 | import java.net.InetAddress
  7 | import java.net.NetworkInterface
  8 | 
  9 | /**
 10 |  * Utility class to detect and ping Tailscale network connections
 11 |  */
 12 | object TailscalePinger {
 13 |     private const val TAG = "TailscalePinger"
 14 |     private const val PING_TIMEOUT_MS = 2000
 15 | 
 16 |     // Tailscale uses 100.64.0.0/10 CGNAT range
 17 |     // This means IPs from 100.64.0.0 to 100.127.255.255
 18 | 
 19 |     // Manually configured Tailscale peer IPs/hostnames to ping
 20 |     // Add your Tailscale device IPs or MagicDNS names here
 21 |     private val configuredTailscaleIps = mutableSetOf<String>(
 22 |         // Default Tailscale MagicDNS hostnames
 23 |         "erics-macbook-pro-2",
 24 |         "iphone-14-pro-max",
 25 |         "laptop-l2vhnlt6",
 26 |         "whs-macbook-pro-1",
 27 |         "matt.tail08eb66.ts.net",
 28 |         "oppo-cph2697.tail08eb66.ts.net"
 29 |     )
 30 | 
 31 |     /**
 32 |      * Add a Tailscale IP or MagicDNS hostname to the list of targets to ping
 33 |      */
 34 |     fun addTailscaleIp(ip: String) {
 35 |         val trimmed = ip.trim()
 36 |         if (trimmed.isNotEmpty()) {
 37 |             // Accept both IPs and hostnames
 38 |             if (isTailscaleIp(trimmed) || isValidHostname(trimmed)) {
 39 |                 configuredTailscaleIps.add(trimmed)
 40 |                 Log.i(TAG, "Added Tailscale target to ping list: $trimmed")
 41 |             } else {
 42 |                 Log.w(TAG, "Target $trimmed is not a valid Tailscale IP (100.64.0.0 - 100.127.255.255) or hostname")
 43 |             }
 44 |         }
 45 |     }
 46 | 
 47 |     /**
 48 |      * Remove a Tailscale IP/hostname from the ping list
 49 |      */
 50 |     fun removeTailscaleIp(ip: String) {
 51 |         configuredTailscaleIps.remove(ip)
 52 |         Log.i(TAG, "Removed Tailscale target from ping list: $ip")
 53 |     }
 54 | 
 55 |     /**
 56 |      * Get all configured Tailscale IPs/hostnames
 57 |      */
 58 |     fun getConfiguredIps(): Set<String> = configuredTailscaleIps.toSet()
 59 | 
 60 |     /**
 61 |      * Clear all configured IPs/hostnames
 62 |      */
 63 |     fun clearConfiguredIps() {
 64 |         configuredTailscaleIps.clear()
 65 |         Log.i(TAG, "Cleared all configured Tailscale targets")
 66 |     }
 67 | 
 68 |     /**
 69 |      * Check if a string is a valid hostname
 70 |      */
 71 |     private fun isValidHostname(hostname: String): Boolean {
 72 |         // Simple hostname validation
 73 |         return hostname.matches(Regex("^[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9]$")) ||
 74 |                hostname.matches(Regex("^[a-zA-Z0-9]+$"))
 75 |     }
 76 | 
 77 |     /**
 78 |      * Check if an IP is in the Tailscale CGNAT range (100.64.0.0/10)
 79 |      */
 80 |     private fun isTailscaleIp(ip: String): Boolean {
 81 |         try {
 82 |             val parts = ip.split(".")
 83 |             if (parts.size != 4) return false
 84 | 
 85 |             val first = parts[0].toIntOrNull() ?: return false
 86 |             val second = parts[1].toIntOrNull() ?: return false
 87 | 
 88 |             // Tailscale uses 100.64.0.0/10
 89 |             // First octet must be 100
 90 |             // Second octet must be 64-127 (binary: 01xxxxxx)
 91 |             return first == 100 && second in 64..127
 92 |         } catch (e: Exception) {
 93 |             return false
 94 |         }
 95 |     }
 96 | 
 97 |     /**
 98 |      * Get all Tailscale IP addresses from network interfaces (IPs assigned to THIS device)
 99 |      */
100 |     fun getLocalTailscaleIps(): List<String> {
101 |         val tailscaleIps = mutableListOf<String>()
102 |         val allIps = mutableListOf<String>()
103 |         try {
104 |             val interfaces = NetworkInterface.getNetworkInterfaces()
105 |             Log.d(TAG, "Scanning network interfaces for Tailscale IPs...")
106 | 
107 |             for (intf in interfaces) {
108 |                 val intfName = intf.name?.lowercase() ?: ""
109 |                 val isTailscaleInterface = intfName.contains("tailscale") ||
110 |                                           intfName.startsWith("ts") ||
111 |                                           intfName.contains("utun") // iOS/Android VPN tunnel
112 | 
113 |                 if (isTailscaleInterface) {
114 |                     Log.d(TAG, "Found Tailscale interface: ${intf.name}")
115 |                 }
116 | 
117 |                 val addrs = intf.inetAddresses
118 |                 for (addr in addrs) {
119 |                     val hostAddress = addr.hostAddress
120 |                     if (hostAddress != null &&
121 |                         !addr.isLoopbackAddress &&
122 |                         hostAddress.indexOf(':') < 0) { // IPv4 only
123 | 
124 |                         allIps.add(hostAddress)
125 |                         Log.d(TAG, "Found IP: $hostAddress on ${intf.name}")
126 | 
127 |                         if (isTailscaleIp(hostAddress)) {
128 |                             tailscaleIps.add(hostAddress)
129 |                             Log.i(TAG, "✅ Found LOCAL Tailscale IP: $hostAddress on ${intf.name}")
130 |                         }
131 |                     }
132 |                 }
133 |             }
134 | 
135 |             Log.i(TAG, "Total IPs found: ${allIps.size}, Tailscale IPs: ${tailscaleIps.size}")
136 | 
137 |             // For testing: if no Tailscale IPs found, return all non-loopback IPs
138 |             if (tailscaleIps.isEmpty() && allIps.isNotEmpty()) {
139 |                 Log.w(TAG, "⚠️ No LOCAL Tailscale IPs found. Using all available IPs for testing: $allIps")
140 |                 return allIps
141 |             }
142 | 
143 |         } catch (e: Exception) {
144 |             Log.e(TAG, "Error getting Tailscale IPs", e)
145 |         }
146 |         return tailscaleIps
147 |     }
148 | 
149 |     /**
150 |      * Get all Tailscale IPs/hostnames to ping (local + configured remote peers)
151 |      */
152 |     fun getTailscaleIps(): List<String> {
153 |         val localIps = getLocalTailscaleIps()
154 |         val allTargets = (localIps + configuredTailscaleIps).distinct()
155 | 
156 |         Log.i(TAG, "Total Tailscale targets to ping: ${allTargets.size} (${localIps.size} local + ${configuredTailscaleIps.size} configured)")
157 | 
158 |         return allTargets
159 |     }
160 | 
161 |     /**
162 |      * Ping a single IP address or hostname
163 |      * @return true if the ping was successful, false otherwise
164 |      */
165 |     suspend fun pingIp(target: String): Boolean = withContext(Dispatchers.IO) {
166 |         try {
167 |             Log.d(TAG, "Attempting to ping: $target")
168 |             val inetAddress = InetAddress.getByName(target)
169 |             Log.d(TAG, "Resolved $target to ${inetAddress.hostAddress}")
170 | 
171 |             val reachable = inetAddress.isReachable(PING_TIMEOUT_MS)
172 |             if (reachable) {
173 |                 Log.d(TAG, "✅ Successfully pinged $target (${inetAddress.hostAddress})")
174 |             } else {
175 |                 Log.w(TAG, "❌ Failed to ping $target (${inetAddress.hostAddress})")
176 |             }
177 |             reachable
178 |         } catch (e: Exception) {
179 |             Log.e(TAG, "❌ Error pinging $target: ${e.message}", e)
180 |             false
181 |         }
182 |     }
183 | 
184 |     /**
185 |      * Ping all Tailscale connections (IPs and hostnames)
186 |      * @return Map of target (IP/hostname) to ping success status
187 |      */
188 |     suspend fun pingAllTailscaleConnections(): Map<String, Boolean> = withContext(Dispatchers.IO) {
189 |         val targets = getTailscaleIps()
190 | 
191 |         if (targets.isEmpty()) {
192 |             Log.i(TAG, "No Tailscale connections found")
193 |             return@withContext emptyMap()
194 |         }
195 | 
196 |         Log.i(TAG, "Pinging ${targets.size} Tailscale target(s)")
197 | 
198 |         val results = mutableMapOf<String, Boolean>()
199 |         for (target in targets) {
200 |             val success = pingIp(target)
201 |             results[target] = success
202 |         }
203 | 
204 |         val successCount = results.values.count { it }
205 |         Log.i(TAG, "Ping complete: $successCount/${targets.size} successful")
206 | 
207 |         results
208 |     }
209 | }
210 | 
211 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/example/cameralink/CameraStreamingService.kt:
--------------------------------------------------------------------------------
  1 | package com.example.cameralink
  2 | 
  3 | import android.app.Notification
  4 | import android.app.NotificationChannel
  5 | import android.app.NotificationManager
  6 | import android.app.PendingIntent
  7 | import android.app.Service
  8 | import android.content.Context
  9 | import android.content.Intent
 10 | import android.os.Build
 11 | import android.os.IBinder
 12 | import android.os.PowerManager
 13 | import androidx.camera.core.CameraSelector
 14 | import androidx.camera.core.ImageAnalysis
 15 | import androidx.camera.lifecycle.ProcessCameraProvider
 16 | import androidx.core.app.NotificationCompat
 17 | import androidx.core.content.ContextCompat
 18 | import androidx.lifecycle.LifecycleService
 19 | import java.net.NetworkInterface
 20 | import java.util.concurrent.Executors
 21 | 
 22 | class CameraStreamingService : LifecycleService() {
 23 | 
 24 |     private var streamingServer: StreamingServer? = null
 25 |     private var wakeLock: PowerManager.WakeLock? = null
 26 |     private val cameraExecutor = Executors.newSingleThreadExecutor()
 27 |     private var cameraProvider: ProcessCameraProvider? = null
 28 | 
 29 |     companion object {
 30 |         private const val NOTIFICATION_ID = 1001
 31 |         private const val CHANNEL_ID = "camera_streaming_channel"
 32 |         const val ACTION_START_STREAMING = "com.example.cameralink.START_STREAMING"
 33 |         const val ACTION_STOP_STREAMING = "com.example.cameralink.STOP_STREAMING"
 34 |         const val EXTRA_PORT = "port"
 35 | 
 36 |         fun startService(context: Context, port: Int = 8080) {
 37 |             val intent = Intent(context, CameraStreamingService::class.java).apply {
 38 |                 action = ACTION_START_STREAMING
 39 |                 putExtra(EXTRA_PORT, port)
 40 |             }
 41 |             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
 42 |                 context.startForegroundService(intent)
 43 |             } else {
 44 |                 context.startService(intent)
 45 |             }
 46 |         }
 47 | 
 48 |         fun stopService(context: Context) {
 49 |             val intent = Intent(context, CameraStreamingService::class.java).apply {
 50 |                 action = ACTION_STOP_STREAMING
 51 |             }
 52 |             context.startService(intent)
 53 |         }
 54 |     }
 55 | 
 56 |     override fun onCreate() {
 57 |         super.onCreate()
 58 |         createNotificationChannel()
 59 |         acquireWakeLock()
 60 |     }
 61 | 
 62 |     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
 63 |         super.onStartCommand(intent, flags, startId)
 64 | 
 65 |         when (intent?.action) {
 66 |             ACTION_START_STREAMING -> {
 67 |                 val port = intent.getIntExtra(EXTRA_PORT, 8080)
 68 |                 startStreaming(port)
 69 |             }
 70 |             ACTION_STOP_STREAMING -> {
 71 |                 stopStreaming()
 72 |                 stopSelf()
 73 |             }
 74 |         }
 75 | 
 76 |         return START_STICKY
 77 |     }
 78 | 
 79 |     private fun startStreaming(port: Int) {
 80 |         // Start foreground service with notification
 81 |         val notification = createNotification("Starting camera stream...", getIpAddress(), port)
 82 |         startForeground(NOTIFICATION_ID, notification)
 83 | 
 84 |         // Start streaming server
 85 |         streamingServer = StreamingServer(port).apply {
 86 |             start()
 87 |         }
 88 | 
 89 |         // Start camera
 90 |         startCamera()
 91 | 
 92 |         // Update notification with streaming info
 93 |         val updatedNotification = createNotification("Camera streaming active", getIpAddress(), port)
 94 |         val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 95 |         notificationManager.notify(NOTIFICATION_ID, updatedNotification)
 96 |     }
 97 | 
 98 |     private fun startCamera() {
 99 |         val cameraProviderFuture = ProcessCameraProvider.getInstance(this)
100 |         cameraProviderFuture.addListener({
101 |             try {
102 |                 cameraProvider = cameraProviderFuture.get()
103 | 
104 |                 val imageAnalyzer = ImageAnalysis.Builder()
105 |                     .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
106 |                     .build()
107 |                     .also {
108 |                         it.setAnalyzer(cameraExecutor) { imageProxy ->
109 |                             streamingServer?.updateFrame(imageProxy)
110 |                             imageProxy.close()
111 |                         }
112 |                     }
113 | 
114 |                 val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA
115 | 
116 |                 cameraProvider?.unbindAll()
117 |                 cameraProvider?.bindToLifecycle(
118 |                     this,
119 |                     cameraSelector,
120 |                     imageAnalyzer
121 |                 )
122 |             } catch (e: Exception) {
123 |                 e.printStackTrace()
124 |             }
125 |         }, ContextCompat.getMainExecutor(this))
126 |     }
127 | 
128 |     private fun stopStreaming() {
129 |         streamingServer?.stop()
130 |         streamingServer = null
131 |         cameraProvider?.unbindAll()
132 |         cameraExecutor.shutdown()
133 |         releaseWakeLock()
134 |     }
135 | 
136 |     private fun acquireWakeLock() {
137 |         val powerManager = getSystemService(Context.POWER_SERVICE) as PowerManager
138 |         wakeLock = powerManager.newWakeLock(
139 |             PowerManager.PARTIAL_WAKE_LOCK,
140 |             "CameraLink::StreamingWakeLock"
141 |         ).apply {
142 |             acquire(10 * 60 * 60 * 1000L /*10 hours*/)
143 |         }
144 |     }
145 | 
146 |     private fun releaseWakeLock() {
147 |         wakeLock?.let {
148 |             if (it.isHeld) {
149 |                 it.release()
150 |             }
151 |         }
152 |         wakeLock = null
153 |     }
154 | 
155 |     private fun createNotificationChannel() {
156 |         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
157 |             val channel = NotificationChannel(
158 |                 CHANNEL_ID,
159 |                 "Camera Streaming",
160 |                 NotificationManager.IMPORTANCE_LOW
161 |             ).apply {
162 |                 description = "Notification for camera streaming service"
163 |                 setShowBadge(false)
164 |             }
165 | 
166 |             val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
167 |             notificationManager.createNotificationChannel(channel)
168 |         }
169 |     }
170 | 
171 |     private fun createNotification(title: String, ipAddress: String, port: Int): Notification {
172 |         val stopIntent = Intent(this, CameraStreamingService::class.java).apply {
173 |             action = ACTION_STOP_STREAMING
174 |         }
175 |         val stopPendingIntent = PendingIntent.getService(
176 |             this,
177 |             0,
178 |             stopIntent,
179 |             PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
180 |         )
181 | 
182 |         val contentIntent = Intent(this, MainActivity::class.java)
183 |         val contentPendingIntent = PendingIntent.getActivity(
184 |             this,
185 |             0,
186 |             contentIntent,
187 |             PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
188 |         )
189 | 
190 |         val contentText = if (ipAddress.isNotEmpty() && ipAddress != "Unable to get IP") {
191 |             "Stream URL: http://$ipAddress:$port"
192 |         } else {
193 |             "Waiting for network connection..."
194 |         }
195 | 
196 |         return NotificationCompat.Builder(this, CHANNEL_ID)
197 |             .setContentTitle(title)
198 |             .setContentText(contentText)
199 |             .setSmallIcon(android.R.drawable.ic_menu_camera)
200 |             .setOngoing(true)
201 |             .setContentIntent(contentPendingIntent)
202 |             .addAction(
203 |                 android.R.drawable.ic_menu_close_clear_cancel,
204 |                 "Stop",
205 |                 stopPendingIntent
206 |             )
207 |             .setStyle(
208 |                 NotificationCompat.BigTextStyle()
209 |                     .bigText("$contentText\n\nTap to open app. Camera will continue streaming even with screen off.")
210 |             )
211 |             .setPriority(NotificationCompat.PRIORITY_LOW)
212 |             .build()
213 |     }
214 | 
215 |     private fun getIpAddress(): String {
216 |         try {
217 |             val interfaces = NetworkInterface.getNetworkInterfaces()
218 |             for (intf in interfaces) {
219 |                 val addrs = intf.inetAddresses
220 |                 for (addr in addrs) {
221 |                     if (!addr.isLoopbackAddress) {
222 |                         val hostAddress = addr.hostAddress
223 |                         if (hostAddress != null && hostAddress.indexOf(':') < 0) {
224 |                             return hostAddress
225 |                         }
226 |                     }
227 |                 }
228 |             }
229 |         } catch (e: Exception) {
230 |             e.printStackTrace()
231 |         }
232 |         return ""
233 |     }
234 | 
235 |     override fun onDestroy() {
236 |         super.onDestroy()
237 |         stopStreaming()
238 |     }
239 | 
240 |     override fun onBind(intent: Intent): IBinder? {
241 |         super.onBind(intent)
242 |         return null
243 |     }
244 | }
245 | 
246 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/example/cameralink/CameraScreen.kt:
--------------------------------------------------------------------------------
  1 | package com.example.cameralink
  2 | 
  3 | import android.content.Context
  4 | import androidx.camera.core.CameraSelector
  5 | import androidx.camera.core.ImageAnalysis
  6 | import androidx.camera.core.Preview
  7 | import androidx.camera.lifecycle.ProcessCameraProvider
  8 | import androidx.camera.view.PreviewView
  9 | import androidx.compose.foundation.background
 10 | import androidx.compose.foundation.layout.*
 11 | import androidx.compose.foundation.shape.RoundedCornerShape
 12 | import androidx.compose.material3.*
 13 | import androidx.compose.runtime.*
 14 | import androidx.compose.ui.Alignment
 15 | import androidx.compose.ui.Modifier
 16 | import androidx.compose.ui.graphics.Color
 17 | import androidx.compose.ui.platform.LocalContext
 18 | import androidx.compose.ui.platform.LocalLifecycleOwner
 19 | import androidx.compose.ui.text.font.FontWeight
 20 | import androidx.compose.ui.text.style.TextAlign
 21 | import androidx.compose.ui.unit.dp
 22 | import androidx.compose.ui.viewinterop.AndroidView
 23 | import androidx.core.content.ContextCompat
 24 | import java.net.NetworkInterface
 25 | import java.util.concurrent.Executors
 26 | 
 27 | @Composable
 28 | fun CameraScreen() {
 29 |     val context = LocalContext.current
 30 |     val lifecycleOwner = LocalLifecycleOwner.current
 31 | 
 32 |     var isStreaming by remember { mutableStateOf(false) }
 33 |     var streamingServer by remember { mutableStateOf<StreamingServer?>(null) }
 34 |     var ipAddress by remember { mutableStateOf("") }
 35 |     val port = 8080
 36 | 
 37 |     val cameraExecutor = remember { Executors.newSingleThreadExecutor() }
 38 | 
 39 |     DisposableEffect(Unit) {
 40 |         onDispose {
 41 |             streamingServer?.stop()
 42 |             cameraExecutor.shutdown()
 43 |         }
 44 |     }
 45 | 
 46 |     Column(
 47 |         modifier = Modifier
 48 |             .fillMaxSize()
 49 |             .background(Color(0xFF1a1a1a))
 50 |             .padding(16.dp)
 51 |     ) {
 52 |         Text(
 53 |             text = "📹 CameraLink",
 54 |             style = MaterialTheme.typography.headlineMedium,
 55 |             fontWeight = FontWeight.Bold,
 56 |             color = Color(0xFF4CAF50),
 57 |             modifier = Modifier.padding(bottom = 16.dp)
 58 |         )
 59 | 
 60 |         // Camera Preview
 61 |         Box(
 62 |             modifier = Modifier
 63 |                 .fillMaxWidth()
 64 |                 .aspectRatio(4f / 3f)
 65 |                 .background(Color.Black, RoundedCornerShape(8.dp))
 66 |         ) {
 67 |             AndroidView(
 68 |                 factory = { ctx ->
 69 |                     PreviewView(ctx).apply {
 70 |                         implementationMode = PreviewView.ImplementationMode.COMPATIBLE
 71 |                     }
 72 |                 },
 73 |                 modifier = Modifier.fillMaxSize(),
 74 |                 update = { previewView ->
 75 |                     val cameraProviderFuture = ProcessCameraProvider.getInstance(context)
 76 |                     cameraProviderFuture.addListener({
 77 |                         val cameraProvider = cameraProviderFuture.get()
 78 | 
 79 |                         val preview = Preview.Builder().build().also {
 80 |                             it.setSurfaceProvider(previewView.surfaceProvider)
 81 |                         }
 82 | 
 83 |                         val imageAnalyzer = ImageAnalysis.Builder()
 84 |                             .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
 85 |                             .build()
 86 |                             .also {
 87 |                                 it.setAnalyzer(cameraExecutor) { imageProxy ->
 88 |                                     streamingServer?.updateFrame(imageProxy)
 89 |                                     imageProxy.close()
 90 |                                 }
 91 |                             }
 92 | 
 93 |                         val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA
 94 | 
 95 |                         try {
 96 |                             cameraProvider.unbindAll()
 97 |                             cameraProvider.bindToLifecycle(
 98 |                                 lifecycleOwner,
 99 |                                 cameraSelector,
100 |                                 preview,
101 |                                 imageAnalyzer
102 |                             )
103 |                         } catch (e: Exception) {
104 |                             e.printStackTrace()
105 |                         }
106 |                     }, ContextCompat.getMainExecutor(context))
107 |                 }
108 |             )
109 | 
110 |             if (isStreaming) {
111 |                 Surface(
112 |                     modifier = Modifier
113 |                         .align(Alignment.TopEnd)
114 |                         .padding(8.dp),
115 |                     color = Color.Red,
116 |                     shape = RoundedCornerShape(4.dp)
117 |                 ) {
118 |                     Text(
119 |                         text = "🔴 LIVE",
120 |                         modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp),
121 |                         color = Color.White,
122 |                         style = MaterialTheme.typography.labelSmall,
123 |                         fontWeight = FontWeight.Bold
124 |                     )
125 |                 }
126 |             }
127 |         }
128 | 
129 |         Spacer(modifier = Modifier.height(24.dp))
130 | 
131 |         // Control Panel
132 |         Card(
133 |             modifier = Modifier.fillMaxWidth(),
134 |             colors = CardDefaults.cardColors(containerColor = Color(0xFF2a2a2a))
135 |         ) {
136 |             Column(
137 |                 modifier = Modifier.padding(16.dp),
138 |                 horizontalAlignment = Alignment.CenterHorizontally
139 |             ) {
140 |                 Button(
141 |                     onClick = {
142 |                         if (isStreaming) {
143 |                             streamingServer?.stop()
144 |                             streamingServer = null
145 |                             isStreaming = false
146 |                         } else {
147 |                             ipAddress = getIpAddress(context)
148 |                             streamingServer = StreamingServer(port).apply {
149 |                                 start()
150 |                             }
151 |                             isStreaming = true
152 |                         }
153 |                     },
154 |                     modifier = Modifier
155 |                         .fillMaxWidth()
156 |                         .height(56.dp),
157 |                     colors = ButtonDefaults.buttonColors(
158 |                         containerColor = if (isStreaming) Color.Red else Color(0xFF4CAF50)
159 |                     )
160 |                 ) {
161 |                     Text(
162 |                         text = if (isStreaming) "⏹ Stop Streaming" else "▶ Start Streaming",
163 |                         style = MaterialTheme.typography.titleMedium,
164 |                         fontWeight = FontWeight.Bold
165 |                     )
166 |                 }
167 | 
168 |                 if (isStreaming && ipAddress.isNotEmpty()) {
169 |                     Spacer(modifier = Modifier.height(16.dp))
170 | 
171 |                     Card(
172 |                         modifier = Modifier.fillMaxWidth(),
173 |                         colors = CardDefaults.cardColors(containerColor = Color(0xFF1a1a1a))
174 |                     ) {
175 |                         Column(
176 |                             modifier = Modifier.padding(16.dp),
177 |                             horizontalAlignment = Alignment.CenterHorizontally
178 |                         ) {
179 |                             Text(
180 |                                 text = "Stream URL:",
181 |                                 style = MaterialTheme.typography.titleSmall,
182 |                                 color = Color.Gray
183 |                             )
184 |                             Spacer(modifier = Modifier.height(8.dp))
185 |                             Text(
186 |                                 text = "http://$ipAddress:$port",
187 |                                 style = MaterialTheme.typography.titleLarge,
188 |                                 fontWeight = FontWeight.Bold,
189 |                                 color = Color(0xFF4CAF50),
190 |                                 textAlign = TextAlign.Center
191 |                             )
192 |                             Spacer(modifier = Modifier.height(8.dp))
193 |                             Text(
194 |                                 text = "Open this URL in any web browser on your network",
195 |                                 style = MaterialTheme.typography.bodySmall,
196 |                                 color = Color.Gray,
197 |                                 textAlign = TextAlign.Center
198 |                             )
199 |                         }
200 |                     }
201 |                 }
202 |             }
203 |         }
204 | 
205 |         Spacer(modifier = Modifier.height(16.dp))
206 | 
207 |         // Instructions
208 |         Card(
209 |             modifier = Modifier.fillMaxWidth(),
210 |             colors = CardDefaults.cardColors(containerColor = Color(0xFF2a2a2a))
211 |         ) {
212 |             Column(modifier = Modifier.padding(16.dp)) {
213 |                 Text(
214 |                     text = "📱 Instructions",
215 |                     style = MaterialTheme.typography.titleMedium,
216 |                     fontWeight = FontWeight.Bold,
217 |                     color = Color(0xFF4CAF50)
218 |                 )
219 |                 Spacer(modifier = Modifier.height(8.dp))
220 |                 Text(
221 |                     text = "1. Make sure your phone and viewing device are on the same network\n" +
222 |                            "2. Tap 'Start Streaming'\n" +
223 |                            "3. Open the displayed URL in a web browser\n" +
224 |                            "4. View your live camera feed!",
225 |                     style = MaterialTheme.typography.bodyMedium,
226 |                     color = Color.LightGray
227 |                 )
228 |             }
229 |         }
230 |     }
231 | }
232 | 
233 | private fun getIpAddress(context: Context): String {
234 |     try {
235 |         val interfaces = NetworkInterface.getNetworkInterfaces()
236 |         for (intf in interfaces) {
237 |             val addrs = intf.inetAddresses
238 |             for (addr in addrs) {
239 |                 if (!addr.isLoopbackAddress) {
240 |                     val hostAddress = addr.hostAddress
241 |                     if (hostAddress != null && hostAddress.indexOf(':') < 0) { // Filter IPv4
242 |                         return hostAddress
243 |                     }
244 |                 }
245 |             }
246 |         }
247 |     } catch (e: Exception) {
248 |         e.printStackTrace()
249 |     }
250 |     return "Unable to get IP"
251 | }
252 | 
253 | 


--------------------------------------------------------------------------------
/app/src/main/java/com/example/cameralink/MainActivity.kt:
--------------------------------------------------------------------------------
  1 | package com.example.cameralink
  2 | 
  3 | import android.Manifest
  4 | import android.os.Build
  5 | import android.os.Bundle
  6 | import androidx.activity.ComponentActivity
  7 | import androidx.activity.compose.setContent
  8 | import androidx.activity.enableEdgeToEdge
  9 | import androidx.compose.foundation.background
 10 | import androidx.compose.foundation.layout.*
 11 | import androidx.compose.foundation.rememberScrollState
 12 | import androidx.compose.foundation.verticalScroll
 13 | import androidx.compose.material3.*
 14 | import androidx.compose.runtime.*
 15 | import androidx.compose.ui.Alignment
 16 | import androidx.compose.ui.Modifier
 17 | import androidx.compose.ui.graphics.Color
 18 | import androidx.compose.ui.platform.LocalContext
 19 | import androidx.compose.ui.text.font.FontWeight
 20 | import androidx.compose.ui.text.style.TextAlign
 21 | import androidx.compose.ui.unit.dp
 22 | import android.util.Log
 23 | import com.example.cameralink.ui.theme.CameraLinkTheme
 24 | import com.google.accompanist.permissions.ExperimentalPermissionsApi
 25 | import com.google.accompanist.permissions.rememberMultiplePermissionsState
 26 | import kotlinx.coroutines.launch
 27 | import kotlinx.coroutines.Dispatchers
 28 | import kotlinx.coroutines.withContext
 29 | import java.net.NetworkInterface
 30 | import java.text.SimpleDateFormat
 31 | import java.util.Date
 32 | import java.util.Locale
 33 | 
 34 | class MainActivity : ComponentActivity() {
 35 |     override fun onCreate(savedInstanceState: Bundle?) {
 36 |         super.onCreate(savedInstanceState)
 37 |         enableEdgeToEdge()
 38 | 
 39 |         // Start periodic Tailscale pinging service (every 15 seconds)
 40 |         TailscalePingService.start(this)
 41 | 
 42 |         setContent {
 43 |             CameraLinkTheme {
 44 |                 Surface(
 45 |                     modifier = Modifier.fillMaxSize(),
 46 |                     color = MaterialTheme.colorScheme.background
 47 |                 ) {
 48 |                     CameraApp()
 49 |                 }
 50 |             }
 51 |         }
 52 |     }
 53 | }
 54 | 
 55 | @OptIn(ExperimentalPermissionsApi::class)
 56 | @Composable
 57 | fun CameraApp() {
 58 |     val permissions = mutableListOf(
 59 |         Manifest.permission.CAMERA,
 60 |         Manifest.permission.INTERNET
 61 |     )
 62 | 
 63 |     // Add notification permission for Android 13+
 64 |     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
 65 |         permissions.add(Manifest.permission.POST_NOTIFICATIONS)
 66 |     }
 67 | 
 68 |     val permissionsState = rememberMultiplePermissionsState(permissions)
 69 | 
 70 |     LaunchedEffect(Unit) {
 71 |         permissionsState.launchMultiplePermissionRequest()
 72 |     }
 73 | 
 74 |     when {
 75 |         permissionsState.allPermissionsGranted -> {
 76 |             ServiceControlScreen()
 77 |         }
 78 |         permissionsState.shouldShowRationale -> {
 79 |             PermissionRationale(
 80 |                 onRequestPermission = {
 81 |                     permissionsState.launchMultiplePermissionRequest()
 82 |                 }
 83 |             )
 84 |         }
 85 |         else -> {
 86 |             PermissionRequest(
 87 |                 onRequestPermission = {
 88 |                     permissionsState.launchMultiplePermissionRequest()
 89 |                 }
 90 |             )
 91 |         }
 92 |     }
 93 | }
 94 | 
 95 | @Composable
 96 | fun ServiceControlScreen() {
 97 |     val context = LocalContext.current
 98 |     val coroutineScope = rememberCoroutineScope()
 99 |     var isStreaming by remember { mutableStateOf(false) }
100 |     var ipAddress by remember { mutableStateOf(getIpAddress()) }
101 |     val port = 8080
102 | 
103 |     // Auto-start the streaming service when the screen loads
104 |     LaunchedEffect(Unit) {
105 |         if (!isStreaming) {
106 |             CameraStreamingService.startService(context, port)
107 |             ipAddress = getIpAddress()
108 |             isStreaming = true
109 |         }
110 |     }
111 | 
112 |     // Tailscale ping state
113 |     var isPinging by remember { mutableStateOf(false) }
114 |     var lastPingResults by remember { mutableStateOf<Map<String, Boolean>>(emptyMap()) }
115 |     var lastPingTime by remember { mutableStateOf("") }
116 | 
117 |     // Tailscale peer management
118 |     var showAddIpDialog by remember { mutableStateOf(false) }
119 |     var newIpText by remember { mutableStateOf("") }
120 |     var configuredIps by remember { mutableStateOf(TailscalePinger.getConfiguredIps().toList()) }
121 | 
122 |     Column(
123 |         modifier = Modifier
124 |             .fillMaxSize()
125 |             .background(Color(0xFF1a1a1a))
126 |             .verticalScroll(rememberScrollState())
127 |             .padding(32.dp),
128 |         horizontalAlignment = Alignment.CenterHorizontally,
129 |         verticalArrangement = Arrangement.Top
130 |     ) {
131 |         Spacer(modifier = Modifier.height(16.dp))
132 | 
133 |         Text(
134 |             text = "📹",
135 |             style = MaterialTheme.typography.displayLarge,
136 |             color = Color(0xFF4CAF50)
137 |         )
138 |         Spacer(modifier = Modifier.height(24.dp))
139 |         Text(
140 |             text = "CameraLink Background Streaming",
141 |             style = MaterialTheme.typography.headlineSmall,
142 |             fontWeight = FontWeight.Bold,
143 |             color = Color.White,
144 |             textAlign = TextAlign.Center
145 |         )
146 |         Spacer(modifier = Modifier.height(16.dp))
147 | 
148 |         // Tailscale Ping Status Card
149 |         Card(
150 |             modifier = Modifier.fillMaxWidth(),
151 |             colors = CardDefaults.cardColors(containerColor = Color(0xFF2a2a2a))
152 |         ) {
153 |             Column(
154 |                 modifier = Modifier.padding(16.dp),
155 |                 horizontalAlignment = Alignment.CenterHorizontally
156 |             ) {
157 |                 Text(
158 |                     text = "🔗 Tailscale Connections",
159 |                     style = MaterialTheme.typography.titleMedium,
160 |                     fontWeight = FontWeight.Bold,
161 |                     color = Color(0xFF4CAF50)
162 |                 )
163 |                 Spacer(modifier = Modifier.height(12.dp))
164 | 
165 |                 if (lastPingResults.isEmpty()) {
166 |                     Text(
167 |                         text = "Auto-pinging every 15 seconds\nTap button below to ping manually",
168 |                         style = MaterialTheme.typography.bodyMedium,
169 |                         color = Color.Gray,
170 |                         textAlign = TextAlign.Center
171 |                     )
172 |                 } else {
173 |                     val successCount = lastPingResults.values.count { it }
174 |                     val totalCount = lastPingResults.size
175 | 
176 |                     Text(
177 |                         text = "Status: $successCount/$totalCount connections active",
178 |                         style = MaterialTheme.typography.bodyLarge,
179 |                         fontWeight = FontWeight.Bold,
180 |                         color = if (successCount == totalCount) Color(0xFF4CAF50) else Color.Yellow
181 |                     )
182 |                     Spacer(modifier = Modifier.height(8.dp))
183 | 
184 |                     lastPingResults.forEach { (ip, success) ->
185 |                         Row(
186 |                             modifier = Modifier.fillMaxWidth(),
187 |                             horizontalArrangement = Arrangement.SpaceBetween
188 |                         ) {
189 |                             Text(
190 |                                 text = ip,
191 |                                 style = MaterialTheme.typography.bodyMedium,
192 |                                 color = Color.LightGray
193 |                             )
194 |                             Text(
195 |                                 text = if (success) "✅" else "❌",
196 |                                 style = MaterialTheme.typography.bodyMedium
197 |                             )
198 |                         }
199 |                     }
200 | 
201 |                     if (lastPingTime.isNotEmpty()) {
202 |                         Spacer(modifier = Modifier.height(8.dp))
203 |                         Text(
204 |                             text = "Last ping: $lastPingTime",
205 |                             style = MaterialTheme.typography.bodySmall,
206 |                             color = Color.Gray
207 |                         )
208 |                     }
209 |                 }
210 | 
211 |                 Spacer(modifier = Modifier.height(12.dp))
212 | 
213 |                 Button(
214 |                     onClick = {
215 |                         Log.d("MainActivity", "Ping Now button clicked")
216 |                         coroutineScope.launch {
217 |                             isPinging = true
218 |                             Log.d("MainActivity", "Starting ping operation, isPinging=$isPinging")
219 |                             try {
220 |                                 // Run ping on IO dispatcher
221 |                                 val results = withContext(Dispatchers.IO) {
222 |                                     TailscalePinger.pingAllTailscaleConnections()
223 |                                 }
224 |                                 Log.d("MainActivity", "Ping results received: ${results.size} connections")
225 | 
226 |                                 // Update UI on main thread
227 |                                 withContext(Dispatchers.Main) {
228 |                                     lastPingResults = results
229 |                                     lastPingTime = SimpleDateFormat("HH:mm:ss", Locale.getDefault())
230 |                                         .format(Date())
231 |                                     Log.d("MainActivity", "UI updated with results")
232 |                                 }
233 |                             } catch (e: Exception) {
234 |                                 Log.e("MainActivity", "Error during ping", e)
235 |                                 withContext(Dispatchers.Main) {
236 |                                     lastPingResults = emptyMap()
237 |                                     lastPingTime = "Error: ${e.message}"
238 |                                 }
239 |                             } finally {
240 |                                 isPinging = false
241 |                                 Log.d("MainActivity", "Ping operation complete, isPinging=$isPinging")
242 |                             }
243 |                         }
244 |                     },
245 |                     enabled = !isPinging,
246 |                     modifier = Modifier.fillMaxWidth(),
247 |                     colors = ButtonDefaults.buttonColors(
248 |                         containerColor = Color(0xFF4CAF50)
249 |                     )
250 |                 ) {
251 |                     Text(
252 |                         text = if (isPinging) "Pinging..." else "🔄 Ping Now",
253 |                         style = MaterialTheme.typography.bodyLarge,
254 |                         fontWeight = FontWeight.Bold
255 |                     )
256 |                 }
257 |             }
258 |         }
259 | 
260 |         Spacer(modifier = Modifier.height(16.dp))
261 | 
262 |         // Tailscale Peer Management Card
263 |         Card(
264 |             modifier = Modifier.fillMaxWidth(),
265 |             colors = CardDefaults.cardColors(containerColor = Color(0xFF2a2a2a))
266 |         ) {
267 |             Column(
268 |                 modifier = Modifier.padding(16.dp),
269 |                 horizontalAlignment = Alignment.CenterHorizontally
270 |             ) {
271 |                 Text(
272 |                     text = "⚙️ Manage Tailscale Peers",
273 |                     style = MaterialTheme.typography.titleMedium,
274 |                     fontWeight = FontWeight.Bold,
275 |                     color = Color(0xFF4CAF50)
276 |                 )
277 |                 Spacer(modifier = Modifier.height(12.dp))
278 | 
279 |                 if (configuredIps.isEmpty()) {
280 |                     Text(
281 |                         text = "No Tailscale peers configured.\nAdd peer IPs below to ping them.",
282 |                         style = MaterialTheme.typography.bodyMedium,
283 |                         color = Color.Gray,
284 |                         textAlign = TextAlign.Center
285 |                     )
286 |                 } else {
287 |                     Text(
288 |                         text = "Configured Peers (${configuredIps.size}):",
289 |                         style = MaterialTheme.typography.bodyMedium,
290 |                         color = Color.LightGray
291 |                     )
292 |                     Spacer(modifier = Modifier.height(8.dp))
293 | 
294 |                     configuredIps.forEach { ip ->
295 |                         Row(
296 |                             modifier = Modifier.fillMaxWidth(),
297 |                             horizontalArrangement = Arrangement.SpaceBetween,
298 |                             verticalAlignment = Alignment.CenterVertically
299 |                         ) {
300 |                             Text(
301 |                                 text = ip,
302 |                                 style = MaterialTheme.typography.bodyMedium,
303 |                                 color = Color.LightGray
304 |                             )
305 |                             Button(
306 |                                 onClick = {
307 |                                     TailscalePinger.removeTailscaleIp(ip)
308 |                                     configuredIps = TailscalePinger.getConfiguredIps().toList()
309 |                                 },
310 |                                 colors = ButtonDefaults.buttonColors(
311 |                                     containerColor = Color.Red
312 |                                 ),
313 |                                 modifier = Modifier.height(32.dp)
314 |                             ) {
315 |                                 Text("Remove", style = MaterialTheme.typography.bodySmall)
316 |                             }
317 |                         }
318 |                         Spacer(modifier = Modifier.height(4.dp))
319 |                     }
320 |                 }
321 | 
322 |                 Spacer(modifier = Modifier.height(12.dp))
323 | 
324 |                 Button(
325 |                     onClick = { showAddIpDialog = true },
326 |                     modifier = Modifier.fillMaxWidth(),
327 |                     colors = ButtonDefaults.buttonColors(
328 |                         containerColor = Color(0xFF4CAF50)
329 |                     )
330 |                 ) {
331 |                     Text(
332 |                         text = "➕ Add Peer",
333 |                         style = MaterialTheme.typography.bodyLarge,
334 |                         fontWeight = FontWeight.Bold
335 |                     )
336 |                 }
337 |             }
338 |         }
339 | 
340 |         // Add IP Dialog
341 |         if (showAddIpDialog) {
342 |             AlertDialog(
343 |                 onDismissRequest = {
344 |                     showAddIpDialog = false
345 |                     newIpText = ""
346 |                 },
347 |                 title = { Text("Add Tailscale Peer") },
348 |                 text = {
349 |                     Column {
350 |                         Text(
351 |                             text = "Enter a Tailscale IP or MagicDNS hostname:",
352 |                             style = MaterialTheme.typography.bodyMedium
353 |                         )
354 |                         Spacer(modifier = Modifier.height(4.dp))
355 |                         Text(
356 |                             text = "Examples:\n• IP: 100.64.1.5\n• Hostname: laptop-abc123",
357 |                             style = MaterialTheme.typography.bodySmall,
358 |                             color = Color.Gray
359 |                         )
360 |                         Spacer(modifier = Modifier.height(8.dp))
361 |                         TextField(
362 |                             value = newIpText,
363 |                             onValueChange = { newIpText = it },
364 |                             label = { Text("IP or Hostname") },
365 |                             placeholder = { Text("e.g., 100.64.1.5 or my-laptop") },
366 |                             singleLine = true
367 |                         )
368 |                     }
369 |                 },
370 |                 confirmButton = {
371 |                     Button(
372 |                         onClick = {
373 |                             if (newIpText.isNotBlank()) {
374 |                                 TailscalePinger.addTailscaleIp(newIpText.trim())
375 |                                 configuredIps = TailscalePinger.getConfiguredIps().toList()
376 |                             }
377 |                             showAddIpDialog = false
378 |                             newIpText = ""
379 |                         }
380 |                     ) {
381 |                         Text("Add")
382 |                     }
383 |                 },
384 |                 dismissButton = {
385 |                     Button(
386 |                         onClick = {
387 |                             showAddIpDialog = false
388 |                             newIpText = ""
389 |                         }
390 |                     ) {
391 |                         Text("Cancel")
392 |                     }
393 |                 }
394 |             )
395 |         }
396 | 
397 |         Spacer(modifier = Modifier.height(16.dp))
398 | 
399 |         if (isStreaming) {
400 |             Card(
401 |                 modifier = Modifier.fillMaxWidth(),
402 |                 colors = CardDefaults.cardColors(containerColor = Color(0xFF2a2a2a))
403 |             ) {
404 |                 Column(
405 |                     modifier = Modifier.padding(24.dp),
406 |                     horizontalAlignment = Alignment.CenterHorizontally
407 |                 ) {
408 |                     Text(
409 |                         text = "🔴 STREAMING",
410 |                         style = MaterialTheme.typography.titleLarge,
411 |                         fontWeight = FontWeight.Bold,
412 |                         color = Color.Red
413 |                     )
414 |                     Spacer(modifier = Modifier.height(16.dp))
415 |                     Text(
416 |                         text = "Stream URL:",
417 |                         style = MaterialTheme.typography.bodyMedium,
418 |                         color = Color.Gray
419 |                     )
420 |                     Spacer(modifier = Modifier.height(8.dp))
421 |                     Text(
422 |                         text = "http://$ipAddress:$port",
423 |                         style = MaterialTheme.typography.titleMedium,
424 |                         fontWeight = FontWeight.Bold,
425 |                         color = Color(0xFF4CAF50),
426 |                         textAlign = TextAlign.Center
427 |                     )
428 |                     Spacer(modifier = Modifier.height(16.dp))
429 |                     Text(
430 |                         text = "✅ Camera is streaming in the background\n" +
431 |                                "✅ Works even when screen is off\n" +
432 |                                "✅ Access from anywhere on your network",
433 |                         style = MaterialTheme.typography.bodyMedium,
434 |                         color = Color.LightGray,
435 |                         textAlign = TextAlign.Center
436 |                     )
437 |                 }
438 |             }
439 |             Spacer(modifier = Modifier.height(24.dp))
440 |             Text(
441 |                 text = "You can close this app or turn off the screen.\n" +
442 |                        "The camera will continue streaming.\n" +
443 |                        "Check the notification for the stream URL.",
444 |                 style = MaterialTheme.typography.bodyMedium,
445 |                 color = Color.Gray,
446 |                 textAlign = TextAlign.Center
447 |             )
448 |         } else {
449 |             Text(
450 |                 text = "Start the background streaming service to access your camera remotely. " +
451 |                        "The stream will continue even when your screen is off.",
452 |                 style = MaterialTheme.typography.bodyLarge,
453 |                 color = Color.LightGray,
454 |                 textAlign = TextAlign.Center
455 |             )
456 |         }
457 | 
458 |         Spacer(modifier = Modifier.height(32.dp))
459 | 
460 |         Button(
461 |             onClick = {
462 |                 if (isStreaming) {
463 |                     CameraStreamingService.stopService(context)
464 |                     isStreaming = false
465 |                 } else {
466 |                     CameraStreamingService.startService(context, port)
467 |                     ipAddress = getIpAddress()
468 |                     isStreaming = true
469 |                 }
470 |             },
471 |             modifier = Modifier
472 |                 .fillMaxWidth()
473 |                 .height(56.dp),
474 |             colors = ButtonDefaults.buttonColors(
475 |                 containerColor = if (isStreaming) Color.Red else Color(0xFF4CAF50)
476 |             )
477 |         ) {
478 |             Text(
479 |                 text = if (isStreaming) "⏹ Stop Streaming" else "▶ Start Streaming",
480 |                 style = MaterialTheme.typography.titleMedium,
481 |                 fontWeight = FontWeight.Bold
482 |             )
483 |         }
484 | 
485 |         if (isStreaming) {
486 |             Spacer(modifier = Modifier.height(16.dp))
487 |             Button(
488 |                 onClick = {
489 |                     ipAddress = getIpAddress()
490 |                 },
491 |                 modifier = Modifier.fillMaxWidth(),
492 |                 colors = ButtonDefaults.buttonColors(
493 |                     containerColor = Color(0xFF2a2a2a)
494 |                 )
495 |             ) {
496 |                 Text(
497 |                     text = "🔄 Refresh IP Address",
498 |                     style = MaterialTheme.typography.bodyLarge
499 |                 )
500 |             }
501 |         }
502 |     }
503 | }
504 | 
505 | private fun getIpAddress(): String {
506 |     try {
507 |         val interfaces = NetworkInterface.getNetworkInterfaces()
508 |         for (intf in interfaces) {
509 |             val addrs = intf.inetAddresses
510 |             for (addr in addrs) {
511 |                 if (!addr.isLoopbackAddress) {
512 |                     val hostAddress = addr.hostAddress
513 |                     if (hostAddress != null && hostAddress.indexOf(':') < 0) {
514 |                         return hostAddress
515 |                     }
516 |                 }
517 |             }
518 |         }
519 |     } catch (e: Exception) {
520 |         e.printStackTrace()
521 |     }
522 |     return "Unable to get IP"
523 | }
524 | 
525 | @Composable
526 | fun PermissionRequest(onRequestPermission: () -> Unit) {
527 |     Column(
528 |         modifier = Modifier
529 |             .fillMaxSize()
530 |             .background(Color(0xFF1a1a1a))
531 |             .padding(32.dp),
532 |         horizontalAlignment = Alignment.CenterHorizontally,
533 |         verticalArrangement = Arrangement.Center
534 |     ) {
535 |         Text(
536 |             text = "📹",
537 |             style = MaterialTheme.typography.displayLarge,
538 |             color = Color(0xFF4CAF50)
539 |         )
540 |         Spacer(modifier = Modifier.height(24.dp))
541 |         Text(
542 |             text = "Camera Permission Required",
543 |             style = MaterialTheme.typography.headlineSmall,
544 |             fontWeight = FontWeight.Bold,
545 |             color = Color.White,
546 |             textAlign = TextAlign.Center
547 |         )
548 |         Spacer(modifier = Modifier.height(16.dp))
549 |         Text(
550 |             text = "CameraLink needs camera permission to stream video to other devices on your network.",
551 |             style = MaterialTheme.typography.bodyLarge,
552 |             color = Color.LightGray,
553 |             textAlign = TextAlign.Center
554 |         )
555 |         Spacer(modifier = Modifier.height(32.dp))
556 |         Button(
557 |             onClick = onRequestPermission,
558 |             modifier = Modifier
559 |                 .fillMaxWidth()
560 |                 .height(56.dp),
561 |             colors = ButtonDefaults.buttonColors(
562 |                 containerColor = Color(0xFF4CAF50)
563 |             )
564 |         ) {
565 |             Text(
566 |                 text = "Grant Permission",
567 |                 style = MaterialTheme.typography.titleMedium,
568 |                 fontWeight = FontWeight.Bold
569 |             )
570 |         }
571 |     }
572 | }
573 | 
574 | @Composable
575 | fun PermissionRationale(onRequestPermission: () -> Unit) {
576 |     Column(
577 |         modifier = Modifier
578 |             .fillMaxSize()
579 |             .background(Color(0xFF1a1a1a))
580 |             .padding(32.dp),
581 |         horizontalAlignment = Alignment.CenterHorizontally,
582 |         verticalArrangement = Arrangement.Center
583 |     ) {
584 |         Text(
585 |             text = "⚠️",
586 |             style = MaterialTheme.typography.displayLarge,
587 |             color = Color(0xFFFFA726)
588 |         )
589 |         Spacer(modifier = Modifier.height(24.dp))
590 |         Text(
591 |             text = "Permission Denied",
592 |             style = MaterialTheme.typography.headlineSmall,
593 |             fontWeight = FontWeight.Bold,
594 |             color = Color.White,
595 |             textAlign = TextAlign.Center
596 |         )
597 |         Spacer(modifier = Modifier.height(16.dp))
598 |         Text(
599 |             text = "Camera permission is essential for this app to function. Please grant the permission to continue.",
600 |             style = MaterialTheme.typography.bodyLarge,
601 |             color = Color.LightGray,
602 |             textAlign = TextAlign.Center
603 |         )
604 |         Spacer(modifier = Modifier.height(32.dp))
605 |         Button(
606 |             onClick = onRequestPermission,
607 |             modifier = Modifier
608 |                 .fillMaxWidth()
609 |                 .height(56.dp),
610 |             colors = ButtonDefaults.buttonColors(
611 |                 containerColor = Color(0xFF4CAF50)
612 |             )
613 |         ) {
614 |             Text(
615 |                 text = "Try Again",
616 |                 style = MaterialTheme.typography.titleMedium,
617 |                 fontWeight = FontWeight.Bold
618 |             )
619 |         }
620 |     }
621 | }


--------------------------------------------------------------------------------
/app/src/main/java/com/example/cameralink/StreamingServer.kt:
--------------------------------------------------------------------------------
  1 | package com.example.cameralink
  2 | 
  3 | import android.graphics.ImageFormat
  4 | import android.graphics.Rect
  5 | import android.graphics.YuvImage
  6 | import androidx.camera.core.ImageProxy
  7 | import fi.iki.elonen.NanoHTTPD
  8 | import kotlinx.coroutines.runBlocking
  9 | import org.json.JSONArray
 10 | import org.json.JSONObject
 11 | import java.io.ByteArrayInputStream
 12 | import java.io.ByteArrayOutputStream
 13 | import java.util.concurrent.atomic.AtomicReference
 14 | 
 15 | class StreamingServer(port: Int) : NanoHTTPD(port) {
 16 | 
 17 |     private val currentFrame = AtomicReference<ByteArray>()
 18 | 
 19 |     @androidx.camera.core.ExperimentalGetImage
 20 |     fun updateFrame(imageProxy: ImageProxy) {
 21 |         try {
 22 |             val jpegBytes = imageProxyToJpeg(imageProxy)
 23 |             if (jpegBytes.isNotEmpty()) {
 24 |                 currentFrame.set(jpegBytes)
 25 |                 println("StreamingServer: Frame updated, size: ${jpegBytes.size} bytes")
 26 |             } else {
 27 |                 println("StreamingServer: WARNING - Empty frame generated!")
 28 |             }
 29 |         } catch (e: Exception) {
 30 |             println("StreamingServer: ERROR in updateFrame: ${e.message}")
 31 |             e.printStackTrace()
 32 |         }
 33 |     }
 34 | 
 35 |     @androidx.camera.core.ExperimentalGetImage
 36 |     private fun imageProxyToJpeg(imageProxy: ImageProxy): ByteArray {
 37 |         try {
 38 |             val image = imageProxy.image
 39 |             if (image == null) {
 40 |                 println("StreamingServer: ERROR - image is null")
 41 |                 return ByteArray(0)
 42 |             }
 43 | 
 44 |             val width = imageProxy.width
 45 |             val height = imageProxy.height
 46 | 
 47 |             // Get the YUV planes
 48 |             val yPlane = image.planes[0]
 49 |             val uPlane = image.planes[1]
 50 |             val vPlane = image.planes[2]
 51 | 
 52 |             val ySize = width * height
 53 |             val uvSize = width * height / 2
 54 | 
 55 |             val nv21 = ByteArray(ySize + uvSize)
 56 | 
 57 |             // Copy Y plane - handle row stride
 58 |             val yBuffer = yPlane.buffer
 59 |             val yRowStride = yPlane.rowStride
 60 |             val yPixelStride = yPlane.pixelStride
 61 | 
 62 |             yBuffer.rewind()
 63 | 
 64 |             if (yPixelStride == 1 && yRowStride == width) {
 65 |                 // Optimized path: no padding
 66 |                 yBuffer.get(nv21, 0, ySize)
 67 |             } else {
 68 |                 // Handle padding: copy row by row
 69 |                 var pos = 0
 70 |                 for (row in 0 until height) {
 71 |                     yBuffer.position(row * yRowStride)
 72 |                     yBuffer.get(nv21, pos, width)
 73 |                     pos += width
 74 |                 }
 75 |             }
 76 | 
 77 |             // Convert U and V planes to NV21 format (interleaved VUVUVU...)
 78 |             val vBuffer = vPlane.buffer
 79 |             val uBuffer = uPlane.buffer
 80 |             val uvRowStride = uPlane.rowStride
 81 |             val uvPixelStride = uPlane.pixelStride
 82 | 
 83 |             vBuffer.rewind()
 84 |             uBuffer.rewind()
 85 | 
 86 |             var pos = ySize
 87 | 
 88 |             if (uvPixelStride == 1) {
 89 |                 // U and V are already packed, just interleave them
 90 |                 for (row in 0 until height / 2) {
 91 |                     vBuffer.position(row * uvRowStride)
 92 |                     uBuffer.position(row * uvRowStride)
 93 |                     @Suppress("UNUSED_VARIABLE")
 94 |                     for (col in 0 until width / 2) {
 95 |                         nv21[pos++] = vBuffer.get()
 96 |                         nv21[pos++] = uBuffer.get()
 97 |                     }
 98 |                 }
 99 |             } else {
100 |                 // U and V have pixel stride > 1, need to sample
101 |                 for (row in 0 until height / 2) {
102 |                     for (col in 0 until width / 2) {
103 |                         val offset = row * uvRowStride + col * uvPixelStride
104 |                         vBuffer.position(offset)
105 |                         uBuffer.position(offset)
106 |                         nv21[pos++] = vBuffer.get()
107 |                         nv21[pos++] = uBuffer.get()
108 |                     }
109 |                 }
110 |             }
111 | 
112 |             // Convert to JPEG
113 |             val yuvImage = YuvImage(nv21, ImageFormat.NV21, width, height, null)
114 |             val out = ByteArrayOutputStream()
115 |             yuvImage.compressToJpeg(Rect(0, 0, width, height), 80, out)
116 |             val result = out.toByteArray()
117 | 
118 |             return result
119 |         } catch (e: Exception) {
120 |             println("StreamingServer: ERROR in imageProxyToJpeg: ${e.message}")
121 |             e.printStackTrace()
122 |             return ByteArray(0)
123 |         }
124 |     }
125 | 
126 |     override fun serve(session: IHTTPSession): Response {
127 |         val uri = session.uri
128 |         println("StreamingServer: Request received for: $uri")
129 | 
130 |         return when {
131 |             uri == "/" || uri == "/index.html" -> {
132 |                 println("StreamingServer: Serving homepage")
133 |                 serveHomePage()
134 |             }
135 |             uri == "/stream" -> {
136 |                 println("StreamingServer: Serving MJPEG stream")
137 |                 serveMjpegStream()
138 |             }
139 |             uri == "/snapshot" -> {
140 |                 println("StreamingServer: Serving snapshot")
141 |                 serveSnapshot()
142 |             }
143 |             uri == "/test" -> {
144 |                 println("StreamingServer: Test endpoint called")
145 |                 newFixedLengthResponse(Response.Status.OK, "text/plain", "Server is working! Frame available: ${currentFrame.get() != null}")
146 |             }
147 |             uri == "/api/tailscale/ping" -> {
148 |                 println("StreamingServer: Tailscale ping endpoint called")
149 |                 handleTailscalePing()
150 |             }
151 |             uri == "/api/tailscale/peers" && session.method == Method.GET -> {
152 |                 println("StreamingServer: Get peers endpoint called")
153 |                 handleGetPeers()
154 |             }
155 |             uri == "/api/tailscale/peers" && session.method == Method.POST -> {
156 |                 println("StreamingServer: Add peer endpoint called")
157 |                 handleAddPeer(session)
158 |             }
159 |             uri == "/api/tailscale/peers" && session.method == Method.DELETE -> {
160 |                 println("StreamingServer: Remove peer endpoint called")
161 |                 handleRemovePeer(session)
162 |             }
163 |             else -> {
164 |                 println("StreamingServer: 404 - Not found: $uri")
165 |                 newFixedLengthResponse(Response.Status.NOT_FOUND, MIME_PLAINTEXT, "Not Found")
166 |             }
167 |         }
168 |     }
169 | 
170 |     private fun handleTailscalePing(): Response {
171 |         return try {
172 |             val results = runBlocking {
173 |                 TailscalePinger.pingAllTailscaleConnections()
174 |             }
175 | 
176 |             val jsonResponse = JSONObject()
177 |             val peersArray = JSONArray()
178 | 
179 |             results.forEach { (target, success) ->
180 |                 val peerObj = JSONObject()
181 |                 peerObj.put("target", target)
182 |                 peerObj.put("online", success)
183 |                 peersArray.put(peerObj)
184 |             }
185 | 
186 |             jsonResponse.put("success", true)
187 |             jsonResponse.put("peers", peersArray)
188 |             jsonResponse.put("timestamp", System.currentTimeMillis())
189 | 
190 |             newFixedLengthResponse(
191 |                 Response.Status.OK,
192 |                 "application/json",
193 |                 jsonResponse.toString()
194 |             )
195 |         } catch (e: Exception) {
196 |             println("StreamingServer: Error in ping: ${e.message}")
197 |             val errorResponse = JSONObject()
198 |             errorResponse.put("success", false)
199 |             errorResponse.put("error", e.message)
200 |             newFixedLengthResponse(
201 |                 Response.Status.INTERNAL_ERROR,
202 |                 "application/json",
203 |                 errorResponse.toString()
204 |             )
205 |         }
206 |     }
207 | 
208 |     private fun handleGetPeers(): Response {
209 |         return try {
210 |             val peers = TailscalePinger.getConfiguredIps()
211 |             val jsonResponse = JSONObject()
212 |             val peersArray = JSONArray()
213 | 
214 |             peers.forEach { peer ->
215 |                 peersArray.put(peer)
216 |             }
217 | 
218 |             jsonResponse.put("success", true)
219 |             jsonResponse.put("peers", peersArray)
220 | 
221 |             newFixedLengthResponse(
222 |                 Response.Status.OK,
223 |                 "application/json",
224 |                 jsonResponse.toString()
225 |             )
226 |         } catch (e: Exception) {
227 |             val errorResponse = JSONObject()
228 |             errorResponse.put("success", false)
229 |             errorResponse.put("error", e.message)
230 |             newFixedLengthResponse(
231 |                 Response.Status.INTERNAL_ERROR,
232 |                 "application/json",
233 |                 errorResponse.toString()
234 |             )
235 |         }
236 |     }
237 | 
238 |     private fun handleAddPeer(session: IHTTPSession): Response {
239 |         return try {
240 |             // Read the body content
241 |             val contentLength = session.headers["content-length"]?.toIntOrNull() ?: 0
242 |             val bodyBytes = ByteArray(contentLength)
243 | 
244 |             if (contentLength > 0) {
245 |                 session.inputStream.read(bodyBytes, 0, contentLength)
246 |             }
247 | 
248 |             val postData = String(bodyBytes)
249 |             val json = JSONObject(postData)
250 |             val target = json.getString("target")
251 | 
252 |             TailscalePinger.addTailscaleIp(target)
253 | 
254 |             val jsonResponse = JSONObject()
255 |             jsonResponse.put("success", true)
256 |             jsonResponse.put("message", "Peer added successfully")
257 |             jsonResponse.put("target", target)
258 | 
259 |             newFixedLengthResponse(
260 |                 Response.Status.OK,
261 |                 "application/json",
262 |                 jsonResponse.toString()
263 |             )
264 |         } catch (e: Exception) {
265 |             println("StreamingServer: Error adding peer: ${e.message}")
266 |             e.printStackTrace()
267 |             val errorResponse = JSONObject()
268 |             errorResponse.put("success", false)
269 |             errorResponse.put("error", e.message ?: "Unknown error")
270 |             newFixedLengthResponse(
271 |                 Response.Status.BAD_REQUEST,
272 |                 "application/json",
273 |                 errorResponse.toString()
274 |             )
275 |         }
276 |     }
277 | 
278 |     private fun handleRemovePeer(session: IHTTPSession): Response {
279 |         return try {
280 |             // Read the body content for DELETE requests
281 |             val contentLength = session.headers["content-length"]?.toIntOrNull() ?: 0
282 |             val bodyBytes = ByteArray(contentLength)
283 | 
284 |             if (contentLength > 0) {
285 |                 session.inputStream.read(bodyBytes, 0, contentLength)
286 |             }
287 | 
288 |             val postData = String(bodyBytes)
289 |             val json = JSONObject(postData)
290 |             val target = json.getString("target")
291 | 
292 |             TailscalePinger.removeTailscaleIp(target)
293 | 
294 |             val jsonResponse = JSONObject()
295 |             jsonResponse.put("success", true)
296 |             jsonResponse.put("message", "Peer removed successfully")
297 |             jsonResponse.put("target", target)
298 | 
299 |             newFixedLengthResponse(
300 |                 Response.Status.OK,
301 |                 "application/json",
302 |                 jsonResponse.toString()
303 |             )
304 |         } catch (e: Exception) {
305 |             println("StreamingServer: Error removing peer: ${e.message}")
306 |             e.printStackTrace()
307 |             val errorResponse = JSONObject()
308 |             errorResponse.put("success", false)
309 |             errorResponse.put("error", e.message ?: "Unknown error")
310 |             newFixedLengthResponse(
311 |                 Response.Status.BAD_REQUEST,
312 |                 "application/json",
313 |                 errorResponse.toString()
314 |             )
315 |         }
316 |     }
317 | 
318 |     private fun serveHomePage(): Response {
319 |         val html = """
320 |             <!DOCTYPE html>
321 |             <html>
322 |             <head>
323 |                 <title>IP Camera Stream</title>
324 |                 <meta name="viewport" content="width=device-width, initial-scale=1.0">
325 |                 <style>
326 |                     body {
327 |                         margin: 0;
328 |                         padding: 20px;
329 |                         font-family: Arial, sans-serif;
330 |                         background-color: #1a1a1a;
331 |                         color: #ffffff;
332 |                     }
333 |                     .container {
334 |                         max-width: 1200px;
335 |                         margin: 0 auto;
336 |                     }
337 |                     h1 {
338 |                         text-align: center;
339 |                         color: #4CAF50;
340 |                     }
341 |                     h2 {
342 |                         color: #4CAF50;
343 |                         margin-top: 30px;
344 |                     }
345 |                     .video-container {
346 |                         position: relative;
347 |                         width: 100%;
348 |                         max-width: 800px;
349 |                         margin: 20px auto;
350 |                         border: 2px solid #4CAF50;
351 |                         border-radius: 8px;
352 |                         overflow: hidden;
353 |                         background-color: #000;
354 |                         min-height: 400px;
355 |                     }
356 |                     img {
357 |                         width: 100%;
358 |                         height: auto;
359 |                         display: block;
360 |                     }
361 |                     .info {
362 |                         text-align: center;
363 |                         margin-top: 20px;
364 |                         padding: 15px;
365 |                         background-color: #2a2a2a;
366 |                         border-radius: 8px;
367 |                     }
368 |                     .button {
369 |                         display: inline-block;
370 |                         padding: 10px 20px;
371 |                         margin: 10px;
372 |                         background-color: #4CAF50;
373 |                         color: white;
374 |                         text-decoration: none;
375 |                         border-radius: 4px;
376 |                         cursor: pointer;
377 |                         border: none;
378 |                         font-size: 14px;
379 |                     }
380 |                     .button:hover {
381 |                         background-color: #45a049;
382 |                     }
383 |                     .button:disabled {
384 |                         background-color: #666;
385 |                         cursor: not-allowed;
386 |                     }
387 |                     .debug-info {
388 |                         margin-top: 20px;
389 |                         padding: 15px;
390 |                         background-color: #2a2a2a;
391 |                         border-radius: 8px;
392 |                         font-family: monospace;
393 |                         font-size: 12px;
394 |                         color: #aaa;
395 |                     }
396 |                     .error {
397 |                         color: #ff5555;
398 |                         padding: 10px;
399 |                         text-align: center;
400 |                     }
401 |                     .tailscale-section {
402 |                         margin-top: 30px;
403 |                         padding: 20px;
404 |                         background-color: #2a2a2a;
405 |                         border-radius: 8px;
406 |                     }
407 |                     .peer-list {
408 |                         margin-top: 15px;
409 |                     }
410 |                     .peer-item {
411 |                         display: flex;
412 |                         justify-content: space-between;
413 |                         align-items: center;
414 |                         padding: 10px;
415 |                         margin: 5px 0;
416 |                         background-color: #1a1a1a;
417 |                         border-radius: 4px;
418 |                         border-left: 3px solid #666;
419 |                     }
420 |                     .peer-item.online {
421 |                         border-left-color: #4CAF50;
422 |                     }
423 |                     .peer-item.offline {
424 |                         border-left-color: #ff5555;
425 |                     }
426 |                     .peer-name {
427 |                         flex: 1;
428 |                         font-family: monospace;
429 |                     }
430 |                     .peer-status {
431 |                         margin: 0 10px;
432 |                         font-weight: bold;
433 |                     }
434 |                     .status-online {
435 |                         color: #4CAF50;
436 |                     }
437 |                     .status-offline {
438 |                         color: #ff5555;
439 |                     }
440 |                     .remove-btn {
441 |                         padding: 5px 10px;
442 |                         background-color: #ff5555;
443 |                         color: white;
444 |                         border: none;
445 |                         border-radius: 3px;
446 |                         cursor: pointer;
447 |                         font-size: 12px;
448 |                     }
449 |                     .remove-btn:hover {
450 |                         background-color: #ff3333;
451 |                     }
452 |                     .add-peer-form {
453 |                         display: flex;
454 |                         gap: 10px;
455 |                         margin-top: 15px;
456 |                     }
457 |                     .add-peer-form input {
458 |                         flex: 1;
459 |                         padding: 10px;
460 |                         background-color: #1a1a1a;
461 |                         border: 1px solid #4CAF50;
462 |                         border-radius: 4px;
463 |                         color: white;
464 |                         font-family: monospace;
465 |                     }
466 |                     .add-peer-form input::placeholder {
467 |                         color: #666;
468 |                     }
469 |                     .ping-status {
470 |                         margin-top: 15px;
471 |                         padding: 10px;
472 |                         background-color: #1a1a1a;
473 |                         border-radius: 4px;
474 |                         text-align: center;
475 |                     }
476 |                     .loading {
477 |                         color: #ffa500;
478 |                     }
479 |                     .section-divider {
480 |                         margin: 30px 0;
481 |                         border-top: 1px solid #444;
482 |                     }
483 |                 </style>
484 |                 <script>
485 |                     let pingInProgress = false;
486 | 
487 |                     window.onload = function() {
488 |                         var img = document.getElementById('stream');
489 |                         var status = document.getElementById('status');
490 |                         
491 |                         img.onerror = function() {
492 |                             status.innerHTML = '<div class="error">❌ Stream failed to load. Check console for details.</div>';
493 |                             console.error('Stream image failed to load from /stream endpoint');
494 |                         };
495 |                         
496 |                         img.onload = function() {
497 |                             status.innerHTML = '<div style="color: #4CAF50;">✅ Stream loaded successfully!</div>';
498 |                             console.log('Stream image loaded successfully');
499 |                         };
500 |                         
501 |                         // Test server connectivity
502 |                         fetch('/test')
503 |                             .then(response => response.text())
504 |                             .then(data => {
505 |                                 console.log('Server test:', data);
506 |                                 document.getElementById('server-test').innerText = 'Server: ' + data;
507 |                             })
508 |                             .catch(err => {
509 |                                 console.error('Server test failed:', err);
510 |                                 document.getElementById('server-test').innerText = 'Server: ERROR - ' + err.message;
511 |                             });
512 | 
513 |                         // Load Tailscale peers
514 |                         loadPeers();
515 |                     };
516 | 
517 |                     async function loadPeers() {
518 |                         try {
519 |                             const response = await fetch('/api/tailscale/peers');
520 |                             const data = await response.json();
521 |                             
522 |                             if (data.success) {
523 |                                 displayPeers(data.peers);
524 |                             } else {
525 |                                 console.error('Failed to load peers:', data.error);
526 |                             }
527 |                         } catch (error) {
528 |                             console.error('Error loading peers:', error);
529 |                         }
530 |                     }
531 | 
532 |                     function displayPeers(peers, pingResults = null) {
533 |                         const peerList = document.getElementById('peer-list');
534 |                         
535 |                         if (peers.length === 0) {
536 |                             peerList.innerHTML = '<div style="color: #666; text-align: center; padding: 20px;">No peers configured. Add one below!</div>';
537 |                             return;
538 |                         }
539 | 
540 |                         peerList.innerHTML = peers.map(peer => {
541 |                             let statusClass = '';
542 |                             let statusText = '';
543 |                             let statusEmoji = '';
544 |                             
545 |                             if (pingResults && pingResults[peer] !== undefined) {
546 |                                 if (pingResults[peer]) {
547 |                                     statusClass = 'online';
548 |                                     statusText = 'status-online';
549 |                                     statusEmoji = '✅ Online';
550 |                                 } else {
551 |                                     statusClass = 'offline';
552 |                                     statusText = 'status-offline';
553 |                                     statusEmoji = '❌ Offline';
554 |                                 }
555 |                             }
556 | 
557 |                             return `
558 |                                 <div class="peer-item ${'$'}{statusClass}">
559 |                                     <span class="peer-name">${'$'}{peer}</span>
560 |                                     <span class="peer-status ${'$'}{statusText}">${'$'}{statusEmoji}</span>
561 |                                     <button class="remove-btn" onclick="removePeer('${'$'}{peer}')">Remove</button>
562 |                                 </div>
563 |                             `;
564 |                         }).join('');
565 |                     }
566 | 
567 |                     async function pingNow() {
568 |                         if (pingInProgress) return;
569 | 
570 |                         pingInProgress = true;
571 |                         const pingBtn = document.getElementById('ping-btn');
572 |                         const pingStatus = document.getElementById('ping-status');
573 |                         
574 |                         pingBtn.disabled = true;
575 |                         pingStatus.innerHTML = '<span class="loading">🔄 Pinging all devices...</span>';
576 | 
577 |                         try {
578 |                             const response = await fetch('/api/tailscale/ping');
579 |                             const data = await response.json();
580 |                             
581 |                             if (data.success) {
582 |                                 const results = {};
583 |                                 data.peers.forEach(peer => {
584 |                                     results[peer.target] = peer.online;
585 |                                 });
586 | 
587 |                                 const onlineCount = data.peers.filter(p => p.online).length;
588 |                                 const totalCount = data.peers.length;
589 |                                 const timestamp = new Date(data.timestamp).toLocaleTimeString();
590 | 
591 |                                 pingStatus.innerHTML = `✅ Ping complete: ${'$'}{onlineCount}/${'$'}{totalCount} devices online (${'$'}{timestamp})`;
592 |                                 
593 |                                 // Update peer list with results
594 |                                 const peersResponse = await fetch('/api/tailscale/peers');
595 |                                 const peersData = await peersResponse.json();
596 |                                 if (peersData.success) {
597 |                                     displayPeers(peersData.peers, results);
598 |                                 }
599 |                             } else {
600 |                                 pingStatus.innerHTML = `<span class="error">❌ Ping failed: ${'$'}{data.error}</span>`;
601 |                             }
602 |                         } catch (error) {
603 |                             console.error('Ping error:', error);
604 |                             pingStatus.innerHTML = `<span class="error">❌ Error: ${'$'}{error.message}</span>`;
605 |                         } finally {
606 |                             pingInProgress = false;
607 |                             pingBtn.disabled = false;
608 |                         }
609 |                     }
610 | 
611 |                     async function addPeer() {
612 |                         const input = document.getElementById('peer-input');
613 |                         const target = input.value.trim();
614 | 
615 |                         if (!target) {
616 |                             alert('Please enter a Tailscale IP or hostname');
617 |                             return;
618 |                         }
619 | 
620 |                         try {
621 |                             const response = await fetch('/api/tailscale/peers', {
622 |                                 method: 'POST',
623 |                                 headers: {
624 |                                     'Content-Type': 'application/json'
625 |                                 },
626 |                                 body: JSON.stringify({ target: target })
627 |                             });
628 | 
629 |                             const data = await response.json();
630 |                             
631 |                             if (data.success) {
632 |                                 input.value = '';
633 |                                 await loadPeers();
634 |                                 alert('Peer added successfully!');
635 |                             } else {
636 |                                 alert('Failed to add peer: ' + data.error);
637 |                             }
638 |                         } catch (error) {
639 |                             console.error('Error adding peer:', error);
640 |                             alert('Error: ' + error.message);
641 |                         }
642 |                     }
643 | 
644 |                     async function removePeer(target) {
645 |                         if (!confirm(`Remove peer "${'$'}{target}"?`)) {
646 |                             return;
647 |                         }
648 | 
649 |                         try {
650 |                             const response = await fetch('/api/tailscale/peers', {
651 |                                 method: 'DELETE',
652 |                                 headers: {
653 |                                     'Content-Type': 'application/json'
654 |                                 },
655 |                                 body: JSON.stringify({ target: target })
656 |                             });
657 | 
658 |                             const data = await response.json();
659 |                             
660 |                             if (data.success) {
661 |                                 await loadPeers();
662 |                             } else {
663 |                                 alert('Failed to remove peer: ' + data.error);
664 |                             }
665 |                         } catch (error) {
666 |                             console.error('Error removing peer:', error);
667 |                             alert('Error: ' + error.message);
668 |                         }
669 |                     }
670 | 
671 |                     // Auto-ping every 30 seconds
672 |                     setInterval(() => {
673 |                         if (!pingInProgress) {
674 |                             pingNow();
675 |                         }
676 |                     }, 30000);
677 |                 </script>
678 |             </head>
679 |             <body>
680 |                 <div class="container">
681 |                     <h1>📹 CameraLink IP Camera</h1>
682 |                     <div id="status"></div>
683 |                     <div class="video-container">
684 |                         <img id="stream" src="/stream" alt="Camera Stream">
685 |                     </div>
686 |                     <div class="info">
687 |                         <p><strong>Stream Active</strong></p>
688 |                         <a href="/snapshot" class="button" target="_blank">📸 Take Snapshot</a>
689 |                         <a href="/test" class="button" target="_blank">🔧 Test Server</a>
690 |                     </div>
691 | 
692 |                     <div class="section-divider"></div>
693 | 
694 |                     <div class="tailscale-section">
695 |                         <h2>🔗 Tailscale Keep-Alive</h2>
696 |                         <p style="color: #aaa;">Monitor and manage Tailscale peer connections</p>
697 |                         
698 |                         <div style="text-align: center; margin: 20px 0;">
699 |                             <button id="ping-btn" class="button" onclick="pingNow()">🔄 Ping All Devices</button>
700 |                         </div>
701 |                         
702 |                         <div id="ping-status" class="ping-status">
703 |                             Click "Ping All Devices" to check connection status
704 |                         </div>
705 | 
706 |                         <h3 style="color: #4CAF50; margin-top: 25px;">📋 Configured Peers</h3>
707 |                         <div id="peer-list" class="peer-list">
708 |                             Loading peers...
709 |                         </div>
710 | 
711 |                         <h3 style="color: #4CAF50; margin-top: 25px;">➕ Add Peer</h3>
712 |                         <div class="add-peer-form">
713 |                             <input 
714 |                                 type="text" 
715 |                                 id="peer-input" 
716 |                                 placeholder="Enter Tailscale IP (e.g., 100.64.1.5) or hostname (e.g., my-laptop)"
717 |                                 onkeypress="if(event.key === 'Enter') addPeer()"
718 |                             />
719 |                             <button class="button" onclick="addPeer()">Add Peer</button>
720 |                         </div>
721 |                         <p style="color: #666; font-size: 12px; margin-top: 10px;">
722 |                             💡 Tip: Use Tailscale MagicDNS hostnames (e.g., "laptop-name") or IP addresses (100.64-127.x.x range)
723 |                         </p>
724 |                     </div>
725 | 
726 |                     <div class="debug-info">
727 |                         <strong>Debug Info:</strong><br>
728 |                         <div id="server-test">Testing server connection...</div>
729 |                         Stream URL: /stream<br>
730 |                         Snapshot URL: /snapshot<br>
731 |                         Tailscale API: /api/tailscale/*<br>
732 |                         Open browser console (F12) for more details
733 |                     </div>
734 |                 </div>
735 |             </body>
736 |             </html>
737 |         """.trimIndent()
738 | 
739 |         return newFixedLengthResponse(Response.Status.OK, "text/html", html)
740 |     }
741 | 
742 |     private fun serveMjpegStream(): Response {
743 |         println("StreamingServer: MJPEG stream requested")
744 | 
745 |         return newChunkedResponse(
746 |             Response.Status.OK,
747 |             "multipart/x-mixed-replace; boundary=frame",
748 |             object : java.io.InputStream() {
749 |                 private var frameIterator = 0
750 |                 private var currentData: ByteArrayInputStream? = null
751 | 
752 |                 override fun read(): Int {
753 |                     while (true) {
754 |                         if (currentData != null) {
755 |                             val b = currentData?.read() ?: -1
756 |                             if (b != -1) return b
757 |                             currentData = null
758 |                         }
759 | 
760 |                         val frame = currentFrame.get()
761 |                         if (frame != null && frame.isNotEmpty()) {
762 |                             val header = "--frame\r\nContent-Type: image/jpeg\r\nContent-Length: ${frame.size}\r\n\r\n"
763 |                             val footer = "\r\n"
764 | 
765 |                             val combined = header.toByteArray() + frame + footer.toByteArray()
766 |                             currentData = ByteArrayInputStream(combined)
767 | 
768 |                             frameIterator++
769 |                             if (frameIterator % 30 == 0) {
770 |                                 println("StreamingServer: Sent $frameIterator frames")
771 |                             }
772 |                         } else {
773 |                             if (frameIterator == 0) {
774 |                                 println("StreamingServer: WARNING - No frames available yet")
775 |                             }
776 |                             Thread.sleep(33)
777 |                         }
778 |                     }
779 |                 }
780 | 
781 |                 override fun available(): Int = 1
782 |             }
783 |         )
784 |     }
785 | 
786 |     private fun serveSnapshot(): Response {
787 |         val frame = currentFrame.get()
788 |         println("StreamingServer: Snapshot requested, frame available: ${frame != null}, size: ${frame?.size ?: 0}")
789 |         return if (frame != null && frame.isNotEmpty()) {
790 |             newFixedLengthResponse(Response.Status.OK, "image/jpeg", ByteArrayInputStream(frame), frame.size.toLong())
791 |         } else {
792 |             newFixedLengthResponse(Response.Status.SERVICE_UNAVAILABLE, MIME_PLAINTEXT, "No frame available")
793 |         }
794 |     }
795 | }
796 | 
797 | 


--------------------------------------------------------------------------------