From ed0a6cb1859e0777d80a52c90bd7279f2d1ecb4a Mon Sep 17 00:00:00 2001 From: Robin Schanbacher Date: Wed, 8 Jul 2026 16:48:29 +0200 Subject: [PATCH] Initial commit (files only) --- .gitignore | 15 + .idea/.gitignore | 3 + .idea/AndroidProjectSystem.xml | 6 + .idea/compiler.xml | 6 + .idea/deploymentTargetSelector.xml | 10 + .idea/gradle.xml | 19 ++ .idea/inspectionProfiles/Project_Default.xml | 61 ++++ .idea/migrations.xml | 10 + .idea/misc.xml | 9 + .idea/runConfigurations.xml | 17 ++ .idea/vcs.xml | 6 + .kotlin/errors/errors-1776355108600.log | 4 + README.md | 26 ++ android_build.yml | 37 +++ app/.gitignore | 1 + app/build.gradle.kts | 96 ++++++ app/proguard-rules.pro | 21 ++ .../screenity/ExampleInstrumentedTest.kt | 24 ++ app/src/main/AndroidManifest.xml | 48 +++ .../screenity/CommunikationToServer.kt | 50 +++ .../schanbro/screenity/DeviceDetailScreen.kt | 164 ++++++++++ .../de/schanbro/screenity/DevicesScreen.kt | 148 +++++++++ .../java/de/schanbro/screenity/LocalScreen.kt | 288 ++++++++++++++++++ .../de/schanbro/screenity/MainActivity.kt | 268 ++++++++++++++++ .../de/schanbro/screenity/ScreentimeWidget.kt | 87 ++++++ .../de/schanbro/screenity/SettingsScreen.kt | 150 +++++++++ .../java/de/schanbro/screenity/ThemeUtils.kt | 42 +++ .../java/de/schanbro/screenity/TodayScreen.kt | 112 +++++++ .../de/schanbro/screenity/UploadWorker.kt | 46 +++ .../java/de/schanbro/screenity/UsageUtils.kt | 46 +++ .../screenity/WidgetConfigActivity.kt | 103 +++++++ .../de/schanbro/screenity/ui/theme/Color.kt | 12 + .../de/schanbro/screenity/ui/theme/Theme.kt | 58 ++++ .../de/schanbro/screenity/ui/theme/Type.kt | 81 +++++ .../res/drawable-nodpi/screenity_edited.xml | 14 + .../res/drawable/ic_launcher_background.xml | 10 + .../res/drawable/ic_launcher_foreground.xml | 30 ++ .../drawable/screenity_edited_background.xml | 74 +++++ .../drawable/screenity_edited_foreground.xml | 19 ++ app/src/main/res/font/outfit_variable.ttf | Bin 0 -> 110884 bytes .../mipmap-anydpi-v26/screenity_edited.xml | 5 + .../screenity_edited_round.xml | 5 + .../main/res/mipmap-anydpi/ic_launcher.xml | 6 + .../res/mipmap-anydpi/ic_launcher_round.xml | 6 + app/src/main/res/mipmap-hdpi/ic_launcher.webp | Bin 0 -> 1404 bytes .../res/mipmap-hdpi/ic_launcher_round.webp | Bin 0 -> 2898 bytes .../res/mipmap-hdpi/screenity_edited.webp | Bin 0 -> 2268 bytes .../mipmap-hdpi/screenity_edited_round.webp | Bin 0 -> 4094 bytes app/src/main/res/mipmap-mdpi/ic_launcher.webp | Bin 0 -> 982 bytes .../res/mipmap-mdpi/ic_launcher_round.webp | Bin 0 -> 1772 bytes .../res/mipmap-mdpi/screenity_edited.webp | Bin 0 -> 1632 bytes .../mipmap-mdpi/screenity_edited_round.webp | Bin 0 -> 2684 bytes .../main/res/mipmap-xhdpi/ic_launcher.webp | Bin 0 -> 1900 bytes .../res/mipmap-xhdpi/ic_launcher_round.webp | Bin 0 -> 3918 bytes .../res/mipmap-xhdpi/screenity_edited.webp | Bin 0 -> 3006 bytes .../mipmap-xhdpi/screenity_edited_round.webp | Bin 0 -> 5646 bytes .../main/res/mipmap-xxhdpi/ic_launcher.webp | Bin 0 -> 2884 bytes .../res/mipmap-xxhdpi/ic_launcher_round.webp | Bin 0 -> 5914 bytes .../res/mipmap-xxhdpi/screenity_edited.webp | Bin 0 -> 4254 bytes .../mipmap-xxhdpi/screenity_edited_round.webp | Bin 0 -> 8446 bytes .../main/res/mipmap-xxxhdpi/ic_launcher.webp | Bin 0 -> 3844 bytes .../res/mipmap-xxxhdpi/ic_launcher_round.webp | Bin 0 -> 7778 bytes .../res/mipmap-xxxhdpi/screenity_edited.webp | Bin 0 -> 5660 bytes .../screenity_edited_round.webp | Bin 0 -> 11728 bytes app/src/main/res/values-en/strings.xml | 28 ++ app/src/main/res/values-fr-rFR/strings.xml | 28 ++ app/src/main/res/values-ru/strings.xml | 28 ++ app/src/main/res/values/colors.xml | 10 + .../values/screenity_edited_background.xml | 4 + app/src/main/res/values/strings.xml | 28 ++ app/src/main/res/values/themes.xml | 5 + app/src/main/res/xml/backup_rules.xml | 13 + .../main/res/xml/data_extraction_rules.xml | 19 ++ .../main/res/xml/screentime_widget_info.xml | 9 + app/src/main/screenity_edited-playstore.png | Bin 0 -> 30571 bytes .../de/schanbro/screenity/ExampleUnitTest.kt | 17 ++ build.gradle.kts | 6 + gradle.properties | 23 ++ gradle/libs.versions.toml | 42 +++ gradle/wrapper/gradle-wrapper.jar | Bin 0 -> 59203 bytes gradle/wrapper/gradle-wrapper.properties | 6 + gradlew | 185 +++++++++++ gradlew.bat | 89 ++++++ images/icon.png | Bin 0 -> 8284 bytes images/screenity.png | Bin 0 -> 12407 bytes keystore2_base64.txt | 1 + keystore_base64.txt | 1 + settings.gradle.kts | 24 ++ 88 files changed, 2809 insertions(+) create mode 100644 .gitignore create mode 100644 .idea/.gitignore create mode 100644 .idea/AndroidProjectSystem.xml create mode 100644 .idea/compiler.xml create mode 100644 .idea/deploymentTargetSelector.xml create mode 100644 .idea/gradle.xml create mode 100644 .idea/inspectionProfiles/Project_Default.xml create mode 100644 .idea/migrations.xml create mode 100644 .idea/misc.xml create mode 100644 .idea/runConfigurations.xml create mode 100644 .idea/vcs.xml create mode 100644 .kotlin/errors/errors-1776355108600.log create mode 100644 README.md create mode 100644 android_build.yml create mode 100644 app/.gitignore create mode 100644 app/build.gradle.kts create mode 100644 app/proguard-rules.pro create mode 100644 app/src/androidTest/java/de/schanbro/screenity/ExampleInstrumentedTest.kt create mode 100644 app/src/main/AndroidManifest.xml create mode 100644 app/src/main/java/de/schanbro/screenity/CommunikationToServer.kt create mode 100644 app/src/main/java/de/schanbro/screenity/DeviceDetailScreen.kt create mode 100644 app/src/main/java/de/schanbro/screenity/DevicesScreen.kt create mode 100644 app/src/main/java/de/schanbro/screenity/LocalScreen.kt create mode 100644 app/src/main/java/de/schanbro/screenity/MainActivity.kt create mode 100644 app/src/main/java/de/schanbro/screenity/ScreentimeWidget.kt create mode 100644 app/src/main/java/de/schanbro/screenity/SettingsScreen.kt create mode 100644 app/src/main/java/de/schanbro/screenity/ThemeUtils.kt create mode 100644 app/src/main/java/de/schanbro/screenity/TodayScreen.kt create mode 100644 app/src/main/java/de/schanbro/screenity/UploadWorker.kt create mode 100644 app/src/main/java/de/schanbro/screenity/UsageUtils.kt create mode 100644 app/src/main/java/de/schanbro/screenity/WidgetConfigActivity.kt create mode 100644 app/src/main/java/de/schanbro/screenity/ui/theme/Color.kt create mode 100644 app/src/main/java/de/schanbro/screenity/ui/theme/Theme.kt create mode 100644 app/src/main/java/de/schanbro/screenity/ui/theme/Type.kt create mode 100644 app/src/main/res/drawable-nodpi/screenity_edited.xml create mode 100644 app/src/main/res/drawable/ic_launcher_background.xml create mode 100644 app/src/main/res/drawable/ic_launcher_foreground.xml create mode 100644 app/src/main/res/drawable/screenity_edited_background.xml create mode 100644 app/src/main/res/drawable/screenity_edited_foreground.xml create mode 100644 app/src/main/res/font/outfit_variable.ttf create mode 100644 app/src/main/res/mipmap-anydpi-v26/screenity_edited.xml create mode 100644 app/src/main/res/mipmap-anydpi-v26/screenity_edited_round.xml create mode 100644 app/src/main/res/mipmap-anydpi/ic_launcher.xml create mode 100644 app/src/main/res/mipmap-anydpi/ic_launcher_round.xml create mode 100644 app/src/main/res/mipmap-hdpi/ic_launcher.webp create mode 100644 app/src/main/res/mipmap-hdpi/ic_launcher_round.webp create mode 100644 app/src/main/res/mipmap-hdpi/screenity_edited.webp create mode 100644 app/src/main/res/mipmap-hdpi/screenity_edited_round.webp create mode 100644 app/src/main/res/mipmap-mdpi/ic_launcher.webp create mode 100644 app/src/main/res/mipmap-mdpi/ic_launcher_round.webp create mode 100644 app/src/main/res/mipmap-mdpi/screenity_edited.webp create mode 100644 app/src/main/res/mipmap-mdpi/screenity_edited_round.webp create mode 100644 app/src/main/res/mipmap-xhdpi/ic_launcher.webp create mode 100644 app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp create mode 100644 app/src/main/res/mipmap-xhdpi/screenity_edited.webp create mode 100644 app/src/main/res/mipmap-xhdpi/screenity_edited_round.webp create mode 100644 app/src/main/res/mipmap-xxhdpi/ic_launcher.webp create mode 100644 app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp create mode 100644 app/src/main/res/mipmap-xxhdpi/screenity_edited.webp create mode 100644 app/src/main/res/mipmap-xxhdpi/screenity_edited_round.webp create mode 100644 app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp create mode 100644 app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp create mode 100644 app/src/main/res/mipmap-xxxhdpi/screenity_edited.webp create mode 100644 app/src/main/res/mipmap-xxxhdpi/screenity_edited_round.webp create mode 100644 app/src/main/res/values-en/strings.xml create mode 100644 app/src/main/res/values-fr-rFR/strings.xml create mode 100644 app/src/main/res/values-ru/strings.xml create mode 100644 app/src/main/res/values/colors.xml create mode 100644 app/src/main/res/values/screenity_edited_background.xml create mode 100644 app/src/main/res/values/strings.xml create mode 100644 app/src/main/res/values/themes.xml create mode 100644 app/src/main/res/xml/backup_rules.xml create mode 100644 app/src/main/res/xml/data_extraction_rules.xml create mode 100644 app/src/main/res/xml/screentime_widget_info.xml create mode 100644 app/src/main/screenity_edited-playstore.png create mode 100644 app/src/test/java/de/schanbro/screenity/ExampleUnitTest.kt create mode 100644 build.gradle.kts create mode 100644 gradle.properties create mode 100644 gradle/libs.versions.toml create mode 100644 gradle/wrapper/gradle-wrapper.jar create mode 100644 gradle/wrapper/gradle-wrapper.properties create mode 100755 gradlew create mode 100644 gradlew.bat create mode 100644 images/icon.png create mode 100644 images/screenity.png create mode 100644 keystore2_base64.txt create mode 100644 keystore_base64.txt create mode 100644 settings.gradle.kts diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..aa724b7 --- /dev/null +++ b/.gitignore @@ -0,0 +1,15 @@ +*.iml +.gradle +/local.properties +/.idea/caches +/.idea/libraries +/.idea/modules.xml +/.idea/workspace.xml +/.idea/navEditor.xml +/.idea/assetWizardSettings.xml +.DS_Store +/build +/captures +.externalNativeBuild +.cxx +local.properties diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..26d3352 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,3 @@ +# Default ignored files +/shelf/ +/workspace.xml diff --git a/.idea/AndroidProjectSystem.xml b/.idea/AndroidProjectSystem.xml new file mode 100644 index 0000000..4a53bee --- /dev/null +++ b/.idea/AndroidProjectSystem.xml @@ -0,0 +1,6 @@ + + + + + \ No newline at end of file diff --git a/.idea/compiler.xml b/.idea/compiler.xml new file mode 100644 index 0000000..b86273d --- /dev/null +++ b/.idea/compiler.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.idea/deploymentTargetSelector.xml b/.idea/deploymentTargetSelector.xml new file mode 100644 index 0000000..b268ef3 --- /dev/null +++ b/.idea/deploymentTargetSelector.xml @@ -0,0 +1,10 @@ + + + + + + + + + \ No newline at end of file diff --git a/.idea/gradle.xml b/.idea/gradle.xml new file mode 100644 index 0000000..639c779 --- /dev/null +++ b/.idea/gradle.xml @@ -0,0 +1,19 @@ + + + + + + + \ No newline at end of file diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml new file mode 100644 index 0000000..7061a0d --- /dev/null +++ b/.idea/inspectionProfiles/Project_Default.xml @@ -0,0 +1,61 @@ + + + + \ No newline at end of file diff --git a/.idea/migrations.xml b/.idea/migrations.xml new file mode 100644 index 0000000..f8051a6 --- /dev/null +++ b/.idea/migrations.xml @@ -0,0 +1,10 @@ + + + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..b2c751a --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,9 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/runConfigurations.xml b/.idea/runConfigurations.xml new file mode 100644 index 0000000..16660f1 --- /dev/null +++ b/.idea/runConfigurations.xml @@ -0,0 +1,17 @@ + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..94a25f7 --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.kotlin/errors/errors-1776355108600.log b/.kotlin/errors/errors-1776355108600.log new file mode 100644 index 0000000..1219b50 --- /dev/null +++ b/.kotlin/errors/errors-1776355108600.log @@ -0,0 +1,4 @@ +kotlin version: 2.0.21 +error message: The daemon has terminated unexpectedly on startup attempt #1 with error code: 0. The daemon process output: + 1. Kotlin compile daemon is ready + diff --git a/README.md b/README.md new file mode 100644 index 0000000..ee2757a --- /dev/null +++ b/README.md @@ -0,0 +1,26 @@ +# Screenity +by Robin Schanbacher (robin@schanbros.de) +![App-Icon](images/screenity.png) + +# What does it do? +If you install Screenity on all your devices (currently just android possible), it shows you all your screentime – from all devices. + +# What is it able to do? +- collect your screentime and send it to a self-hosted server +- show your today's, local's and each device's screentime +- multiple accounts + +# What is planned to implement? +- Widgets +- filters +- admin-page (web) +- internal und extetnal connection to server +- optimize and publish server files + +# Else +As you hopefully noticed, the project is very new. It is also my first bigger project, so i'm sorry for the mistakes i'll make :) +Since i'm currently lerning Kotlin with Jetpack Compose, this is a project for my personal education. If i've enough experience, i'll try to start more projects. + +Since i'm still a student i'd be glad for any help. Thank you! + +[![Get it on Obtainium](https://raw.githubusercontent.com/ImranR98/Obtainium/main/assets/graphics/badge_obtainium.png)](https://apps.obtainium.imranr.dev/redirect?r=obtainium://add/https://github.com/RobinS-T470s/Screenity) diff --git a/android_build.yml b/android_build.yml new file mode 100644 index 0000000..8c06f04 --- /dev/null +++ b/android_build.yml @@ -0,0 +1,37 @@ +name: Android Build & Release + +# Der Bot startet nur, wenn du ein "Tag" pushst (z.B. v1.0) +on: + push: + tags: + - 'v*' + +jobs: + build: + runs-on: ubuntu-latest + steps: + - name: Checkout Code + uses: actions/checkout@v4 + + - name: Java einrichten + uses: actions/setup-java@v4 + with: + java-version: '17' + distribution: 'temurin' + cache: gradle + + - name: Berechtigung für Gradle setzen + run: chmod +x gradlew + + - name: APK bauen (Debug Version) + run: ./gradlew assembleDebug + + - name: Release erstellen und APK hochladen + uses: softprops/action-gh-release@v2 + with: + files: app/build/outputs/apk/debug/*.apk + name: Release ${{ github.ref_name }} + draft: false + prerelease: false + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/app/.gitignore b/app/.gitignore new file mode 100644 index 0000000..42afabf --- /dev/null +++ b/app/.gitignore @@ -0,0 +1 @@ +/build \ No newline at end of file diff --git a/app/build.gradle.kts b/app/build.gradle.kts new file mode 100644 index 0000000..57dca72 --- /dev/null +++ b/app/build.gradle.kts @@ -0,0 +1,96 @@ +import org.gradle.kotlin.dsl.create +import org.gradle.kotlin.dsl.getByName +import org.gradle.kotlin.dsl.release + +plugins { + alias(libs.plugins.android.application) + alias(libs.plugins.kotlin.android) + alias(libs.plugins.kotlin.compose) +} + +android { + namespace = "de.schanbro.screenity" + compileSdk = 36 + + defaultConfig { + applicationId = "de.schanbro.screenity" + minSdk = 29 + targetSdk = 36 + + val gitVersion = System.getenv("APP_VERSION") ?: "0.0.1-local" + versionName = gitVersion.removePrefix("v") + versionCode = (System.currentTimeMillis() / 600000).toInt() + + testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" + } + + signingConfigs { + create("release") { + storeFile = file("keystore.jks") + storePassword = System.getenv("KEY_STORE_PASSWORD") + keyAlias = System.getenv("ALIAS") + keyPassword = System.getenv("KEY_PASSWORD") + } + } + + buildTypes { + release { + isMinifyEnabled = false + // Hier kommt alles in EINEN Block: + signingConfig = signingConfigs.getByName("release") + proguardFiles( + getDefaultProguardFile("proguard-android-optimize.txt"), + "proguard-rules.pro" + ) + } + } + + compileOptions { + sourceCompatibility = JavaVersion.VERSION_11 + targetCompatibility = JavaVersion.VERSION_11 + } + kotlinOptions { + jvmTarget = "11" + } + buildFeatures { + compose = true + } + + // Optional: Damit die Datei auf GitHub auch den richtigen Namen hat + applicationVariants.all { + outputs.all { + val output = this as com.android.build.gradle.internal.api.ApkVariantOutputImpl + output.outputFileName = "Screenity-${versionName}.apk" + } + } +} + +dependencies { + implementation(libs.androidx.compose.animation) + val workVersion = "2.9.0" // Prüfe hier gern auf die aktuellste Version + implementation("androidx.work:work-runtime-ktx:$workVersion") + implementation(libs.androidx.core.ktx) + implementation(libs.androidx.lifecycle.runtime.ktx) + implementation(libs.androidx.activity.compose) + implementation(platform(libs.androidx.compose.bom)) + implementation(libs.androidx.compose.ui) + implementation(libs.androidx.compose.ui.graphics) + implementation(libs.androidx.compose.ui.tooling.preview) + implementation(libs.androidx.compose.material3) + implementation(libs.androidx.navigation.compose) + implementation(libs.androidx.ui) + implementation(libs.androidx.material3) + implementation(libs.androidx.ui.graphics) + testImplementation(libs.junit) + androidTestImplementation(libs.androidx.junit) + androidTestImplementation(libs.androidx.espresso.core) + androidTestImplementation(platform(libs.androidx.compose.bom)) + androidTestImplementation(libs.androidx.compose.ui.test.junit4) + debugImplementation(libs.androidx.compose.ui.tooling) + debugImplementation(libs.androidx.compose.ui.test.manifest) + implementation("androidx.compose.material:material-icons-extended") + implementation("com.squareup.okhttp3:okhttp:4.12.0") + implementation("com.google.code.gson:gson:2.10.1") + implementation("androidx.glance:glance-appwidget:1.1.0") // Oder aktuellste Version + implementation("androidx.glance:glance-material3:1.1.0") +} \ No newline at end of file diff --git a/app/proguard-rules.pro b/app/proguard-rules.pro new file mode 100644 index 0000000..481bb43 --- /dev/null +++ b/app/proguard-rules.pro @@ -0,0 +1,21 @@ +# Add project specific ProGuard rules here. +# You can control the set of applied configuration files using the +# proguardFiles setting in build.gradle. +# +# For more details, see +# http://developer.android.com/guide/developing/tools/proguard.html + +# If your project uses WebView with JS, uncomment the following +# and specify the fully qualified class name to the JavaScript interface +# class: +#-keepclassmembers class fqcn.of.javascript.interface.for.webview { +# public *; +#} + +# Uncomment this to preserve the line number information for +# debugging stack traces. +#-keepattributes SourceFile,LineNumberTable + +# If you keep the line number information, uncomment this to +# hide the original source file name. +#-renamesourcefileattribute SourceFile \ No newline at end of file diff --git a/app/src/androidTest/java/de/schanbro/screenity/ExampleInstrumentedTest.kt b/app/src/androidTest/java/de/schanbro/screenity/ExampleInstrumentedTest.kt new file mode 100644 index 0000000..c00b789 --- /dev/null +++ b/app/src/androidTest/java/de/schanbro/screenity/ExampleInstrumentedTest.kt @@ -0,0 +1,24 @@ +package de.schanbro.screenity + +import androidx.test.platform.app.InstrumentationRegistry +import androidx.test.ext.junit.runners.AndroidJUnit4 + +import org.junit.Test +import org.junit.runner.RunWith + +import org.junit.Assert.* + +/** + * Instrumented test, which will execute on an Android device. + * + * See [testing documentation](http://d.android.com/tools/testing). + */ +@RunWith(AndroidJUnit4::class) +class ExampleInstrumentedTest { + @Test + fun useAppContext() { + // Context of the app under test. + val appContext = InstrumentationRegistry.getInstrumentation().targetContext + assertEquals("de.schanbro.screenity", appContext.packageName) + } +} \ No newline at end of file diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml new file mode 100644 index 0000000..7f38e09 --- /dev/null +++ b/app/src/main/AndroidManifest.xml @@ -0,0 +1,48 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/java/de/schanbro/screenity/CommunikationToServer.kt b/app/src/main/java/de/schanbro/screenity/CommunikationToServer.kt new file mode 100644 index 0000000..f35a0ce --- /dev/null +++ b/app/src/main/java/de/schanbro/screenity/CommunikationToServer.kt @@ -0,0 +1,50 @@ +package de.schanbro.screenity + +import android.content.Context +import android.provider.Settings +import com.google.gson.Gson +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext +import okhttp3.* +import okhttp3.MediaType.Companion.toMediaType +import okhttp3.RequestBody.Companion.toRequestBody +import java.text.SimpleDateFormat +import java.util.* + +data class DeviceFullData( + val device_id: String, + val device_name: String, + val reports: Map +) + +// --- NETZWERK LOGIK --- +suspend fun sendDataToServer( + context: Context, + url: String, + totalMs: Long, + usageList: List, + detailedEvents: List +): Boolean = withContext(Dispatchers.IO) { + if (url.isBlank()) return@withContext false + val client = OkHttpClient() + val reportData = mapOf( + "device_id" to Settings.Secure.getString(context.contentResolver, Settings.Secure.ANDROID_ID), + "device_name" to android.os.Build.MODEL, + "report_date" to SimpleDateFormat("yyyy-MM-dd", Locale.US).format(Date()), + "total_screen_time_ms" to totalMs, + "apps" to usageList.map { mapOf("app_name" to it.appName, "usage_ms" to it.usageMs) } + ) + try { + val body = Gson().toJson(reportData).toRequestBody("application/json".toMediaType()) + val request = Request.Builder().url("${url.trim().removeSuffix("/")}/report").post(body).build() + client.newCall(request).execute().isSuccessful + } catch (e: Exception) { false } +} + +suspend fun getSummaryFromServer(url: String): ServerSummary = withContext(Dispatchers.IO) { + val client = OkHttpClient() + val request = Request.Builder().url("${url.trim().removeSuffix("/")}/summary").build() + val response = client.newCall(request).execute() + if (!response.isSuccessful) throw Exception("Code: ${response.code}") + Gson().fromJson(response.body?.string(), ServerSummary::class.java) +} \ No newline at end of file diff --git a/app/src/main/java/de/schanbro/screenity/DeviceDetailScreen.kt b/app/src/main/java/de/schanbro/screenity/DeviceDetailScreen.kt new file mode 100644 index 0000000..1815bdb --- /dev/null +++ b/app/src/main/java/de/schanbro/screenity/DeviceDetailScreen.kt @@ -0,0 +1,164 @@ +package de.schanbro.screenity + +import android.content.Context +import androidx.compose.foundation.layout.* +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.Refresh +import androidx.compose.material3.* +import androidx.compose.runtime.* +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp +import com.google.gson.Gson +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext +import okhttp3.OkHttpClient +import okhttp3.Request +import java.text.SimpleDateFormat +import java.util.* + +@OptIn(ExperimentalMaterial3Api::class) +@Composable +fun DeviceDetailScreen(deviceId: String, onBack: () -> Unit) { + val context = LocalContext.current + val scope = rememberCoroutineScope() + val prefs = remember { context.getSharedPreferences("ScreenityPrefs", Context.MODE_PRIVATE) } + val serverUrl = prefs.getString("server_url", "") ?: "" + + var isLoading by remember { mutableStateOf(true) } + var appsFromToday by remember { mutableStateOf>(emptyList()) } + var deviceName by remember { mutableStateOf("Gerät") } + + val todayStr = SimpleDateFormat("yyyy-MM-dd", Locale.US).format(Date()) + + fun fetch() { + android.util.Log.d("SCREENITY_CHECK", "1. fetch() gestartet für ID: $deviceId") + if (serverUrl.isBlank()) return + + scope.launch { + isLoading = true + try { + val client = OkHttpClient() + val fullUrl = "${serverUrl.trim().removeSuffix("/")}/summary" + val request = Request.Builder().url(fullUrl).build() + + val response = withContext(Dispatchers.IO) { client.newCall(request).execute() } + + if (response.isSuccessful) { + // WICHTIG: Body nur einmal auslesen und in Variable speichern + val responseBodyString = withContext(Dispatchers.IO) { response.body?.string() } ?: "" + android.util.Log.d("SCREENITY_CHECK", "2. JSON geladen, Länge: ${responseBodyString.length}") + + if (responseBodyString.isNotBlank()) { + try { + val fullSummary = Gson().fromJson(responseBodyString, ServerSummary::class.java) + + // Gerät in der Liste suchen + val device = fullSummary.devices.find { it.device_id.trim() == deviceId.trim() } + + if (device != null) { + deviceName = device.device_name + android.util.Log.d("SCREENITY_CHECK", "3. Gerät gefunden: ${device.device_name}") + + // Report für heute heraussuchen + val report = device.reports?.get(todayStr) + if (report != null) { + appsFromToday = report.apps ?: emptyList() + android.util.Log.d("SCREENITY_CHECK", "4. Apps für heute gefunden: ${appsFromToday.size}") + } else { + android.util.Log.w("SCREENITY_CHECK", "Hinweis: Kein Report für $todayStr vorhanden.") + // Debug: Zeige welche Tage da sind + android.util.Log.d("SCREENITY_CHECK", "Verfügbare Tage: ${device.reports?.keys}") + } + } else { + android.util.Log.e("SCREENITY_CHECK", "Fehler: Gerät mit ID $deviceId nicht in Liste.") + } + } catch (e: Exception) { + android.util.Log.e("SCREENITY_CHECK", "Parsing-Fehler: ${e.message}") + android.util.Log.d("SCREENITY_CHECK", "Fehlerhaftes JSON: $responseBodyString") + } + } + } else { + android.util.Log.e("SCREENITY_CHECK", "Server Fehler-Code: ${response.code}") + } + } catch (e: Exception) { + android.util.Log.e("SCREENITY_CHECK", "Netzwerk-Fehler: ${e.message}") + } + isLoading = false + } + } + + LaunchedEffect(Unit) { fetch() } + + ScreenWrapper( + title = "Details: $deviceName", + headerAction = { + IconButton(onClick = { fetch() }) { + Icon(Icons.Default.Refresh, contentDescription = "Aktualisieren") + } + } + ) { + if (isLoading) { + Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) { + CircularProgressIndicator() + } + } else { + Column(Modifier.fillMaxSize()) { + Text( + text = "App-Nutzung heute ($todayStr):", + style = MaterialTheme.typography.titleMedium, + color = MaterialTheme.colorScheme.primary, + modifier = Modifier.padding(bottom = 16.dp) + ) + + if (appsFromToday.isEmpty()) { + Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) { + Text("Keine detaillierten Daten für heute gefunden.", style = MaterialTheme.typography.bodyMedium) + } + } else { + LazyColumn( + modifier = Modifier.fillMaxSize(), + contentPadding = PaddingValues(bottom = 24.dp) + ) { + items(appsFromToday.sortedByDescending { it.usage_ms }) { app -> + AppUsageRow(app) + HorizontalDivider(modifier = Modifier.padding(vertical = 4.dp), thickness = 0.5.dp) + } + } + } + } + } + } +} + +@Composable +fun AppUsageRow(app: AppUsageDetail) { + val h = app.usage_ms / 3600000 + val m = (app.usage_ms % 3600000) / 60000 + val s = (app.usage_ms % 60000) / 1000 + + Row( + modifier = Modifier + .fillMaxWidth() + .padding(vertical = 12.dp), + horizontalArrangement = Arrangement.SpaceBetween, + verticalAlignment = Alignment.CenterVertically + ) { + Text( + text = app.app_name, + modifier = Modifier.weight(1f), + style = MaterialTheme.typography.bodyLarge + ) + Text( + text = if (h > 0) String.format("%dh %02dm", h, m) else String.format("%dm %02ds", m, s), + style = MaterialTheme.typography.bodyMedium, + fontWeight = FontWeight.Bold, + fontFamily = androidx.compose.ui.text.font.FontFamily.Monospace + ) + } +} \ No newline at end of file diff --git a/app/src/main/java/de/schanbro/screenity/DevicesScreen.kt b/app/src/main/java/de/schanbro/screenity/DevicesScreen.kt new file mode 100644 index 0000000..af87153 --- /dev/null +++ b/app/src/main/java/de/schanbro/screenity/DevicesScreen.kt @@ -0,0 +1,148 @@ +package de.schanbro.screenity + +import android.app.usage.UsageEvents +import android.app.usage.UsageStatsManager +import android.content.Context +import android.content.Intent +import android.provider.Settings +import android.widget.Toast +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.* +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.CloudUpload +import androidx.compose.material.icons.filled.Refresh +import androidx.compose.material3.* +import androidx.compose.runtime.* +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.unit.dp +import com.google.gson.Gson +import com.google.gson.annotations.SerializedName +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext +import okhttp3.MediaType.Companion.toMediaType +import okhttp3.OkHttpClient +import okhttp3.Request +import okhttp3.RequestBody.Companion.toRequestBody +import java.text.SimpleDateFormat +import java.util.* + +data class DeviceSummary( + val device_id: String, + val device_name: String, + val total_screen_time_hours: Double, + val today_ms: Long, + val reports: Map? // Wichtig: Hier müssen die Reports drin sein! +) + +data class DayReport( + @SerializedName("total_screen_time_ms") val totalMs: Long, + val apps: List? = null +) + +data class AppUsageDetail( + @SerializedName("app_name") val app_name: String, + @SerializedName("usage_ms") val usage_ms: Long +) + +@Composable +fun DevicesScreen(onNavigateToDetail: (String) -> Unit) { + val context = LocalContext.current + val scope = rememberCoroutineScope() + val prefs = remember { context.getSharedPreferences("ScreenityPrefs", Context.MODE_PRIVATE) } + val serverUrl = prefs.getString("server_url", "") ?: "" + + var devicesList by remember { mutableStateOf(emptyList()) } + var isLoading by remember { mutableStateOf(false) } + + fun fetch() { + if (serverUrl.isBlank()) return + scope.launch { + isLoading = true + try { + val result = getSummaryFromServer(serverUrl) + // Hier greifen wir auf die Liste der Geräte zu: + val fetchedDevices = result.devices + devicesList = fetchedDevices + + // --- AB HIER NEU: Echte Geräte für das Widget sichern --- + // Wir ziehen uns alle Gerätenamen aus der Liste heraus + val deviceNames = fetchedDevices.map { it.device_name }.toSet() + + // Wir speichern das Set in den SharedPreferences ab + prefs.edit().putStringSet("known_device_ids", deviceNames).apply() + // --- ENDE NEU --- + + } catch (e: Exception) { + // Fehlerbehandlung (z.B. Loggen oder Toast) + } + isLoading = false + } + } + + LaunchedEffect(Unit) { fetch() } + + ScreenWrapper( + title = stringResource(R.string.devices_overview), + headerAction = { + IconButton(onClick = { fetch() }) { + Icon(Icons.Default.Refresh, contentDescription = null) + } + } + ) { + if (isLoading) { + Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) { + CircularProgressIndicator() + } + } else { + LazyColumn(modifier = Modifier.fillMaxSize()) { + items( + items = devicesList, + key = { it.device_id } + ) { device -> + DeviceUsageRow( + device = device, + onClick = { onNavigateToDetail(device.device_id) } + ) + } + } + } + } +} + +@Composable +fun DeviceUsageRow(device: DeviceSummary, onClick: () -> Unit) { + val h = device.today_ms / 3600000 + val m = (device.today_ms % 3600000) / 60000 + + Card( + modifier = Modifier + .fillMaxWidth() + .padding(vertical = 6.dp) + .clickable { onClick() }, + elevation = CardDefaults.cardElevation(2.dp) + ) { + Row( + modifier = Modifier.padding(16.dp), + horizontalArrangement = Arrangement.SpaceBetween, + verticalAlignment = Alignment.CenterVertically + ) { + Column(modifier = Modifier.weight(1f)) { + Text(device.device_name, style = MaterialTheme.typography.titleMedium) + Text("ID: ${device.device_id.take(8)}...", style = MaterialTheme.typography.labelSmall, color = MaterialTheme.colorScheme.onSurfaceVariant) + } + Text( + text = String.format("%dh %02dm", h, m), + fontFamily = androidx.compose.ui.text.font.FontFamily.Monospace, + style = MaterialTheme.typography.titleLarge, + color = MaterialTheme.colorScheme.primary + ) + } + } +} \ No newline at end of file diff --git a/app/src/main/java/de/schanbro/screenity/LocalScreen.kt b/app/src/main/java/de/schanbro/screenity/LocalScreen.kt new file mode 100644 index 0000000..c0c5de9 --- /dev/null +++ b/app/src/main/java/de/schanbro/screenity/LocalScreen.kt @@ -0,0 +1,288 @@ +package de.schanbro.screenity + +import android.app.usage.UsageEvents +import android.app.usage.UsageStatsManager +import android.content.Context +import android.content.Intent +import android.provider.Settings +import android.widget.Toast +import androidx.compose.foundation.layout.* +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.CloudUpload +import androidx.compose.material.icons.filled.Refresh +import androidx.compose.material3.* +import androidx.compose.runtime.* +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.tooling.preview.Preview +import androidx.compose.ui.unit.dp +import com.google.gson.Gson +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext +import okhttp3.MediaType.Companion.toMediaType +import okhttp3.OkHttpClient +import okhttp3.Request +import okhttp3.RequestBody.Companion.toRequestBody +import java.text.SimpleDateFormat +import java.util.* + +// --- DATENMODELL --- +data class AppUsageInfo( + val appName: String, + val usageMs: Long +) + +@Composable +@Preview +fun LocalScreen() { + val context = LocalContext.current + val scope = rememberCoroutineScope() + val snackbarHostState = remember { SnackbarHostState() } + val prefs = remember { context.getSharedPreferences("ScreenityPrefs", Context.MODE_PRIVATE) } + val serverUrl = prefs.getString("server_url", "") ?: "" + + var usageList by remember { mutableStateOf>(emptyList()) } + var totalMs by remember { mutableLongStateOf(0L) } + val detailedEvents = getDetailedEvents(context) + var isSending by remember { mutableStateOf(false) } + + fun load() { + scope.launch { + // getTodayUsageEvents solltest du am besten auch auf suspend umstellen! + usageList = getTodayUsageEvents(context) + + // Hier rufen wir unsere neue asynchrone Funktion auf + totalMs = getTotalScreenTime(context) + } + } + + // Beim ersten Start des Screens laden + LaunchedEffect(Unit) { + load() + } + + Scaffold(snackbarHost = { SnackbarHost(snackbarHostState) }) { padding -> + ScreenWrapper( + title = stringResource(R.string.this_device), + headerAction = { + IconButton(onClick = { load() }) { Icon(Icons.Default.Refresh, null) } + } + ) { + TotalTimeCard(totalMs) + Spacer(Modifier.height(12.dp)) + + val successMessage = stringResource(R.string.sent) + val errorMessage = stringResource(R.string.error) + + Button( + onClick = { + scope.launch { + isSending = true + val ok = sendDataToServer(context, serverUrl, totalMs, usageList, detailedEvents) + snackbarHostState.showSnackbar(if(ok) successMessage else errorMessage) + isSending = false + } + }, + modifier = Modifier.fillMaxWidth(), + enabled = !isSending && serverUrl.isNotBlank() + ) { + if (isSending) CircularProgressIndicator(Modifier.size(20.dp)) + else Text(stringResource(R.string.upload_data)) + } + + Spacer(Modifier.height(12.dp)) // Kleiner Abstand zur Liste + + LazyColumn(Modifier.weight(1f)) { + items(usageList) { app -> AppUsageRow(app) } + } + } + } +} + +// --- UI KOMPONENTEN --- + +@Composable +fun TotalTimeCard(totalMs: Long) { + val h = totalMs / 3600000 + val m = (totalMs % 3600000) / 60000 + val s = (totalMs % 60000) / 1000 + + Card( + modifier = Modifier.fillMaxWidth(), + colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.primaryContainer) + ) { + Column(Modifier.padding(16.dp)) { + Text(text = stringResource(R.string.all_time), style = MaterialTheme.typography.titleSmall, color = MaterialTheme.colorScheme.primary) + Text( + text = String.format("%02dh %02dm %02ds", h, m, s), + style = MaterialTheme.typography.displayMedium, + fontFamily = androidx.compose.ui.text.font.FontFamily.Monospace + ) + } + } +} + +@Composable +fun AppUsageRow(app: AppUsageInfo) { + val hours = app.usageMs / 3600000 + val minutes = (app.usageMs % 3600000) / 60000 + val seconds = (app.usageMs % 60000) / 1000 + + Card(modifier = Modifier.fillMaxWidth().padding(vertical = 4.dp)) { + Row( + modifier = Modifier.padding(16.dp), + horizontalArrangement = Arrangement.SpaceBetween, + verticalAlignment = Alignment.CenterVertically + ) { + Text(app.appName, modifier = Modifier.weight(1f), style = MaterialTheme.typography.titleSmall) + Text( + text = String.format("%02dh %02dm %02ds", hours, minutes, seconds), + fontFamily = androidx.compose.ui.text.font.FontFamily.Monospace, + color = MaterialTheme.colorScheme.primary, + style = MaterialTheme.typography.bodyMedium + ) + } + } +} + +// --- SYSTEM LOGIK (PROFI-METHODEN) --- + +suspend fun getTodayUsageEvents(context: Context): List = withContext(Dispatchers.IO) { + val usm = context.getSystemService(Context.USAGE_STATS_SERVICE) as UsageStatsManager + val calendar = Calendar.getInstance().apply { + set(Calendar.HOUR_OF_DAY, 0); set(Calendar.MINUTE, 0); set(Calendar.SECOND, 0); set(Calendar.MILLISECOND, 0) + } + + val events = usm.queryEvents(calendar.timeInMillis, System.currentTimeMillis()) + val event = UsageEvents.Event() + + val appUsageMap = mutableMapOf() + val openApps = mutableMapOf() + + var lastActivePackageName: String? = null + var screenOnTime: Long? = null + + while (events.hasNextEvent()) { + events.getNextEvent(event) + val packageName = event.packageName + + when (event.eventType) { + UsageEvents.Event.MOVE_TO_FOREGROUND -> { + // Wenn der Bildschirm gerade erst angegangen ist UND direkt eine NEUE App startet, + // löschen wir den Verdacht, dass die alte App weiterlief! + if (screenOnTime != null && packageName != lastActivePackageName) { + screenOnTime = null + } + + // Falls der Verdacht stimmte und die ALTE App weiterlief: + if (screenOnTime != null && lastActivePackageName != null) { + openApps[lastActivePackageName] = screenOnTime!! + screenOnTime = null + } + + openApps[packageName] = event.timeStamp + lastActivePackageName = packageName + } + + UsageEvents.Event.MOVE_TO_BACKGROUND -> { + val start = openApps.remove(packageName) + if (start != null) { + val duration = event.timeStamp - start + appUsageMap[packageName] = appUsageMap.getOrDefault(packageName, 0L) + duration + } + } + + UsageEvents.Event.SCREEN_NON_INTERACTIVE -> { + val now = event.timeStamp + openApps.forEach { (pkg, start) -> + appUsageMap[pkg] = appUsageMap.getOrDefault(pkg, 0L) + (now - start) + } + openApps.clear() + screenOnTime = null + } + + UsageEvents.Event.SCREEN_INTERACTIVE -> { + // Wir merken uns NUR den Zeitpunkt. Wir tragen die App noch nicht als "laufend" ein! + // Wir warten ab, was das nächste Event sagt. + screenOnTime = event.timeStamp + } + } + } + + // Am Ende der Schleife: Falls der Bildschirm an ging und DANACH kein Event mehr kam, + // lief die letzte App tatsächlich weiter. + if (screenOnTime != null && lastActivePackageName != null) { + openApps[lastActivePackageName] = screenOnTime!! + } + + // Abrechnung bis JETZT + val now = System.currentTimeMillis() + openApps.forEach { (pkg, start) -> + appUsageMap[pkg] = appUsageMap.getOrDefault(pkg, 0L) + (now - start) + } + + val pm = context.packageManager + appUsageMap.map { (pkg, ms) -> + val name = try { pm.getApplicationLabel(pm.getApplicationInfo(pkg, 0)).toString() } catch (e: Exception) { pkg } + AppUsageInfo(name, ms) + }.sortedByDescending { it.usageMs } +} + +suspend fun getTotalScreenTime(context: Context): Long = withContext(Dispatchers.IO) { + val usm = context.getSystemService(Context.USAGE_STATS_SERVICE) as UsageStatsManager + val calendar = Calendar.getInstance().apply { + set(Calendar.HOUR_OF_DAY, 0) + set(Calendar.MINUTE, 0) + set(Calendar.SECOND, 0) + set(Calendar.MILLISECOND, 0) + } + + val events = usm.queryEvents(calendar.timeInMillis, System.currentTimeMillis()) + val event = UsageEvents.Event() + + var totalTime = 0L + var sessionStartTime = 0L + val openApps = mutableSetOf() + + while (events.hasNextEvent()) { + events.getNextEvent(event) + val packageName = event.packageName + + when (event.eventType) { + UsageEvents.Event.MOVE_TO_FOREGROUND -> { + if (openApps.isEmpty()) { + sessionStartTime = event.timeStamp + } + openApps.add(packageName) + } + + UsageEvents.Event.MOVE_TO_BACKGROUND -> { + openApps.remove(packageName) + if (openApps.isEmpty() && sessionStartTime != 0L) { + totalTime += (event.timeStamp - sessionStartTime) + sessionStartTime = 0L + } + } + + UsageEvents.Event.SCREEN_NON_INTERACTIVE -> { + if (sessionStartTime != 0L) { + totalTime += (event.timeStamp - sessionStartTime) + sessionStartTime = 0L + } + openApps.clear() + } + } + } + + if (sessionStartTime != 0L) { + totalTime += (System.currentTimeMillis() - sessionStartTime) + } + + // Das Ergebnis wird automatisch zurückgegeben + return@withContext totalTime +} \ No newline at end of file diff --git a/app/src/main/java/de/schanbro/screenity/MainActivity.kt b/app/src/main/java/de/schanbro/screenity/MainActivity.kt new file mode 100644 index 0000000..3c0e675 --- /dev/null +++ b/app/src/main/java/de/schanbro/screenity/MainActivity.kt @@ -0,0 +1,268 @@ +package de.schanbro.screenity + +import android.content.Context +import android.os.Bundle +import androidx.activity.ComponentActivity +import androidx.activity.compose.setContent +import androidx.activity.enableEdgeToEdge +import androidx.compose.animation.core.tween +import androidx.compose.animation.fadeIn +import androidx.compose.animation.fadeOut +import androidx.compose.animation.scaleIn +import androidx.compose.animation.scaleOut +import androidx.compose.animation.slideInHorizontally +import androidx.compose.animation.slideOutHorizontally +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.List +import androidx.compose.material.icons.filled.Edit +import androidx.compose.material.icons.filled.Info +import androidx.compose.material.icons.filled.Today +import androidx.compose.material.icons.filled.Devices +import androidx.compose.material.icons.filled.Settings +import androidx.compose.material3.Button +import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.Icon +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.NavigationBar +import androidx.compose.material3.NavigationBarItem +import androidx.compose.material3.OutlinedTextField +import androidx.compose.material3.Scaffold +import androidx.compose.material3.Text +import androidx.compose.material3.TopAppBar +import androidx.compose.material3.TopAppBarDefaults +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateListOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.tooling.preview.Preview +import androidx.compose.ui.unit.dp +import androidx.navigation.compose.NavHost +import androidx.navigation.compose.composable +import androidx.navigation.compose.currentBackStackEntryAsState +import androidx.navigation.compose.rememberNavController +import androidx.compose.foundation.layout.height +import androidx.compose.material.icons.filled.PinDrop +import de.schanbro.screenity.ui.theme.ScreenityTheme +import androidx.compose.runtime.LaunchedEffect +import androidx.work.Constraints +import androidx.work.ExistingPeriodicWorkPolicy +import androidx.work.NetworkType +import androidx.work.PeriodicWorkRequestBuilder +import androidx.work.WorkManager +import java.util.concurrent.TimeUnit + +sealed class Screen(val route: String) { + object Today : Screen("today_screen") + + object Local : Screen("local_screen") + object Devices : Screen("devices_screen") + object Settings : Screen("settings_screen") + object DeviceDetail : Screen("device_detail/{deviceId}") +} + +class MainActivity : ComponentActivity() { + @OptIn(ExperimentalMaterial3Api::class) + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + enableEdgeToEdge() + setContent { + ScreenityTheme { + val context = androidx.compose.ui.platform.LocalContext.current + val prefs = remember { context.getSharedPreferences("ScreenityPrefs", android.content.Context.MODE_PRIVATE) } + var serverUrl by remember { + mutableStateOf(prefs.getString("server_url", "") ?: "") + } + + val savedInterval = prefs.getInt("upload_interval_mins", 15) + + if (serverUrl.isBlank()) { + // Zeige Setup, wenn keine URL da ist + SetupScreen(onUrlSaved = { neueUrl -> + prefs.edit().putString("server_url", neueUrl).apply() + serverUrl = neueUrl // State-Update triggert Re-Composition + }) + } else { + LaunchedEffect(serverUrl) { + if (serverUrl.isNotBlank()) { + // 1. SOFORTIGER UPLOAD BEIM APP-START + val totalMs = getTotalScreenTime(context) + val usageList = getTodayUsageEvents(context) + val detailedEvents = getDetailedEvents(applicationContext) + sendDataToServer(context, serverUrl, totalMs, usageList, detailedEvents) + + // 2. 15-MINUTEN-AUTOMATISIERUNG EINRICHTEN + val constraints = Constraints.Builder() + .setRequiredNetworkType(NetworkType.CONNECTED) // Nur wenn Internet da ist + .build() + + val uploadWorkRequest = PeriodicWorkRequestBuilder( + 15, TimeUnit.MINUTES // Alle 15 Minuten (Minimum bei Android!) + ) + .setConstraints(constraints) + .build() + + // Dem System übergeben + WorkManager.getInstance(context).enqueueUniquePeriodicWork( + "ScreentimeUploadWork", + ExistingPeriodicWorkPolicy.KEEP, // Behält den alten Timer, falls die App neu startet + uploadWorkRequest + ) + } + } + + val navController = rememberNavController() + val currentBackStack by navController.currentBackStackEntryAsState() + val currentRoute = currentBackStack?.destination?.route + Scaffold( + modifier = Modifier.fillMaxSize(), + topBar = { + TopAppBar( + title = { Text(stringResource(R.string.app_name)) }, + colors = TopAppBarDefaults.topAppBarColors( + containerColor = MaterialTheme.colorScheme.primaryContainer, + titleContentColor = MaterialTheme.colorScheme.primary + ) + ) + }, + bottomBar = { + NavigationBar { + NavigationBarItem( + selected = currentRoute == Screen.Today.route, + onClick = { navController.navigate(Screen.Today.route) }, + icon = { Icon(Icons.Default.Today, contentDescription = null) }, + label = { Text(stringResource(R.string.Today)) } + ) + NavigationBarItem( + selected = currentRoute == Screen.Local.route, + onClick = { navController.navigate(Screen.Local.route) }, + icon = { Icon(Icons.Default.PinDrop, contentDescription = null) }, + label = { Text(stringResource(R.string.Local)) } + ) + NavigationBarItem( + selected = currentRoute == Screen.Devices.route, + onClick = { navController.navigate(Screen.Devices.route) }, + icon = { + Icon( + Icons.Default.Devices, + contentDescription = null + ) + }, + label = { Text(stringResource(R.string.Devices)) } + ) + NavigationBarItem( + selected = currentRoute == Screen.Settings.route, + onClick = { navController.navigate(Screen.Settings.route) }, + icon = { + Icon( + Icons.Default.Settings, + contentDescription = null + ) + }, + label = { Text(stringResource(R.string.Settings)) } + ) + } + } + ) { innerPadding -> + NavHost( + navController = navController, + startDestination = de.schanbro.screenity.Screen.Today.route, + modifier = Modifier.padding(innerPadding), + enterTransition = { fadeIn(animationSpec = tween(220)) + scaleIn(initialScale = 0.92f) }, + exitTransition = { fadeOut(animationSpec = tween(90)) }, + popEnterTransition = { fadeIn(animationSpec = tween(220)) }, + popExitTransition = { fadeOut(animationSpec = tween(90)) + scaleOut(targetScale = 0.92f) } + ) { + composable(de.schanbro.screenity.Screen.Today.route) { + TodayScreen() + } + composable(de.schanbro.screenity.Screen.Local.route) { + LocalScreen() + } + composable(de.schanbro.screenity.Screen.Devices.route) { + DevicesScreen(onNavigateToDetail = { id -> + navController.navigate("device_detail/$id") + }) + } + composable(de.schanbro.screenity.Screen.Settings.route) { + SettingsScreen() + } + composable(Screen.DeviceDetail.route) { backStackEntry -> + val deviceId = backStackEntry.arguments?.getString("deviceId") ?: "" + DeviceDetailScreen( + deviceId = deviceId, + onBack = { navController.popBackStack() } // Geht zurück zum TodayScreen + ) + } + } + } + } + } + } + } +} + +@Composable +fun SetupScreen(onUrlSaved: (String) -> Unit) { + var urlInput by remember { mutableStateOf("") } + + Column( + modifier = Modifier.fillMaxSize().padding(24.dp), + verticalArrangement = Arrangement.Center, + horizontalAlignment = Alignment.CenterHorizontally + ) { + Text(stringResource(R.string.welcome)+"!", style = MaterialTheme.typography.headlineSmall) + Text(stringResource(R.string.pls_enter_url)) + + Spacer(Modifier.height(16.dp)) + + OutlinedTextField( + value = urlInput, + onValueChange = { urlInput = it }, + label = { Text(stringResource(R.string.ex_server_url)) }, + modifier = Modifier.fillMaxWidth(), + placeholder = { Text("http://...") } + ) + + Spacer(Modifier.height(16.dp)) + + Button( + onClick = { if (urlInput.isNotBlank()) onUrlSaved(urlInput) }, + modifier = Modifier.fillMaxWidth(), + enabled = urlInput.startsWith("http") // Kleine Sicherheitssperre + ) { + Text(stringResource(R.string.connect_and_start)) + } + } +} + +fun updateUploadWork(context: Context, intervalMinutes: Long) { + val constraints = Constraints.Builder() + .setRequiredNetworkType(NetworkType.CONNECTED) + .build() + + val uploadWorkRequest = PeriodicWorkRequestBuilder( + intervalMinutes, TimeUnit.MINUTES + ) + .setConstraints(constraints) + .build() + + // UPDATE steht hier für "REPLACE" + // Wenn sich das Intervall ändert, bricht Android den alten Timer ab + // und fängt mit der neuen Zeit von vorne an zu zählen! + WorkManager.getInstance(context).enqueueUniquePeriodicWork( + "ScreentimeUploadWork", + ExistingPeriodicWorkPolicy.REPLACE, + uploadWorkRequest + ) +} \ No newline at end of file diff --git a/app/src/main/java/de/schanbro/screenity/ScreentimeWidget.kt b/app/src/main/java/de/schanbro/screenity/ScreentimeWidget.kt new file mode 100644 index 0000000..d7cf437 --- /dev/null +++ b/app/src/main/java/de/schanbro/screenity/ScreentimeWidget.kt @@ -0,0 +1,87 @@ +package de.schanbro.screenity + +import android.content.Context +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.unit.dp +import androidx.glance.GlanceId +import androidx.glance.GlanceModifier +import androidx.glance.appwidget.GlanceAppWidget +import androidx.glance.appwidget.GlanceAppWidgetReceiver +import androidx.glance.appwidget.GlanceAppWidgetManager +import androidx.glance.appwidget.provideContent +import androidx.glance.background +import androidx.glance.layout.* +import androidx.glance.text.FontWeight +import androidx.glance.text.Text +import androidx.glance.text.TextStyle +import androidx.glance.unit.ColorProvider +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext + +class ScreentimeWidget : GlanceAppWidget() { + + override suspend fun provideGlance(context: Context, id: GlanceId) { + val appWidgetId = GlanceAppWidgetManager(context).getAppWidgetId(id) + val prefs = context.getSharedPreferences("ScreenityPrefs", Context.MODE_PRIVATE) + + // 1. Welche Geräte hat der Nutzer in der Config gewählt? + val selectedDevices = prefs.getStringSet("widget_${appWidgetId}_devices", emptySet()) ?: emptySet() + val serverUrl = prefs.getString("server_url", "") ?: "" + + var totalMs = 0L + + // 2. ECHTE DATEN VOM SERVER HOLEN + if (serverUrl.isNotBlank()) { + try { + val result = withContext(Dispatchers.IO) { + getSummaryFromServer(serverUrl) + } + + // HIER IST DIE KORREKTUR: Wir greifen erst auf .devices zu! + val allDevices = result.devices + + // Jetzt können wir filtern + val filteredDevices = allDevices.filter { it.device_id in selectedDevices || it.device_name in selectedDevices } + totalMs = filteredDevices.sumOf { it.today_ms } + + } catch (e: Exception) { + // Bei Netzwerkfehlern bleibt totalMs einfach auf 0 oder du nimmst einen Cache + } + } + + // Zeit in Stunden und Minuten umrechnen + val hours = totalMs / 3600000 + val minutes = (totalMs % 3600000) / 60000 + val totalTimeText = String.format("%02dh %02dm", hours, minutes) + + provideContent { + Column( + modifier = GlanceModifier + .fillMaxSize() + .background(Color.White) + .padding(12.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalAlignment = Alignment.CenterHorizontally + ) { + Text( + text = "Gesamtzeit", + style = TextStyle(fontWeight = FontWeight.Bold, color = ColorProvider(Color.Black)) + ) + Spacer(GlanceModifier.height(4.dp)) + Text( + text = totalTimeText, + style = TextStyle(fontWeight = FontWeight.Bold, color = ColorProvider(Color.Blue)) + ) + Spacer(GlanceModifier.height(4.dp)) + Text( + text = "${selectedDevices.size} Geräte", + style = TextStyle(color = ColorProvider(Color.Gray)) + ) + } + } + } +} + +class ScreentimeWidgetReceiver : GlanceAppWidgetReceiver() { + override val glanceAppWidget: GlanceAppWidget = ScreentimeWidget() +} \ No newline at end of file diff --git a/app/src/main/java/de/schanbro/screenity/SettingsScreen.kt b/app/src/main/java/de/schanbro/screenity/SettingsScreen.kt new file mode 100644 index 0000000..d7a246f --- /dev/null +++ b/app/src/main/java/de/schanbro/screenity/SettingsScreen.kt @@ -0,0 +1,150 @@ +package de.schanbro.screenity + +import android.content.Context +import androidx.compose.foundation.layout.* +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.CheckCircle +import androidx.compose.material.icons.filled.Error +import androidx.compose.material3.* +import androidx.compose.runtime.* +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.unit.dp +import de.schanbro.screenity.ui.theme.SuccessGreen +import kotlinx.coroutines.launch +import kotlin.math.roundToInt + +// 1. ConnectionState erweitert, um Fehlermeldungen direkt mitzuführen +sealed class ConnectionState { + object Idle : ConnectionState() + object Loading : ConnectionState() + object Success : ConnectionState() + data class Error(val message: String) : ConnectionState() // Fehler trägt seine Nachricht selbst! +} + +@Composable +fun SettingsScreen() { + val context = LocalContext.current + val scope = rememberCoroutineScope() + val prefs = remember { context.getSharedPreferences("ScreenityPrefs", Context.MODE_PRIVATE) } + + var urlInput by remember { mutableStateOf(prefs.getString("server_url", "") ?: "") } + var status by remember { mutableStateOf(ConnectionState.Idle) } + + // Intervall auslesen (Standard: 15 Minuten) + var selectedInterval by remember { mutableIntStateOf(prefs.getInt("upload_interval_mins", 15)) } + + ScreenWrapper(title = stringResource(R.string.Settings)) { + + OutlinedTextField( + value = urlInput, + onValueChange = { urlInput = it; status = ConnectionState.Idle }, + label = { Text(stringResource(R.string.server_url)) }, + modifier = Modifier.fillMaxWidth() + ) + + Spacer(Modifier.height(24.dp)) + + // --- MATERIAL 3 SLIDER --- + Text( + text = "Upload-Intervall: $selectedInterval Minuten", + style = MaterialTheme.typography.titleSmall + ) + + Slider( + value = selectedInterval.toFloat(), + onValueChange = { + selectedInterval = it.roundToInt() + }, + valueRange = 15f..120f, + steps = 6 + ) + + // Kleine Beschriftung unter dem Slider + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceBetween + ) { + Text("15 min", style = MaterialTheme.typography.bodySmall) + Text("120 min", style = MaterialTheme.typography.bodySmall) + } + + Spacer(Modifier.height(32.dp)) + + val errorMessage = stringResource(R.string.error) + + Button( + onClick = { + // 1. Einstellungen speichern + prefs.edit() + .putString("server_url", urlInput) + .putInt("upload_interval_mins", selectedInterval) + .apply() + + // 2. WorkManager mit neuem Intervall updaten! + updateUploadWork(context, selectedInterval.toLong()) + + scope.launch { + status = ConnectionState.Loading + try { + getSummaryFromServer(urlInput) + status = ConnectionState.Success + } catch (e: Exception) { + val detail = e.localizedMessage ?: errorMessage + status = ConnectionState.Error(detail) + } + } + }, + modifier = Modifier.fillMaxWidth() + ) { + Text(stringResource(R.string.save_and_try)) + } + + Spacer(Modifier.height(24.dp)) + + ConnectionStatusWidget(state = status) + } +} + +@Composable +fun ConnectionStatusWidget(state: ConnectionState) { + when (state) { + is ConnectionState.Loading -> { + Box(Modifier.fillMaxWidth(), contentAlignment = Alignment.Center) { + CircularProgressIndicator() + } + } + is ConnectionState.Success -> { + Row(verticalAlignment = Alignment.CenterVertically) { + Icon(Icons.Default.CheckCircle, "OK", tint = SuccessGreen) + Spacer(Modifier.width(8.dp)) + Text( + text = stringResource(R.string.connection_successful), + color = SuccessGreen, + style = MaterialTheme.typography.titleSmall + ) + } + } + is ConnectionState.Error -> { + Row(verticalAlignment = Alignment.CenterVertically) { + Icon(Icons.Default.Error, stringResource(R.string.error), tint = MaterialTheme.colorScheme.error) + Spacer(Modifier.width(8.dp)) + Column { + Text( + text = stringResource(R.string.server_not_reachable), + color = MaterialTheme.colorScheme.error, + style = MaterialTheme.typography.titleSmall + ) + Text( + text = state.message, + color = MaterialTheme.colorScheme.error, + style = MaterialTheme.typography.bodySmall + ) + } + } + } + else -> {} + } +} \ No newline at end of file diff --git a/app/src/main/java/de/schanbro/screenity/ThemeUtils.kt b/app/src/main/java/de/schanbro/screenity/ThemeUtils.kt new file mode 100644 index 0000000..fb3cf2e --- /dev/null +++ b/app/src/main/java/de/schanbro/screenity/ThemeUtils.kt @@ -0,0 +1,42 @@ +package de.schanbro.screenity + +import androidx.compose.foundation.layout.* +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.unit.dp + +// Das ist wie eine CSS-Klasse für die Screen-Struktur! +@Composable +fun ScreenWrapper( + title: String, + headerAction: @Composable (() -> Unit)? = null, + content: @Composable ColumnScope.() -> Unit +) { + Column( + modifier = Modifier + .fillMaxSize() + .padding(16.dp) // Zentrales Padding für die gesamte App + ) { + // Einheitlicher Header für alle Screens + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceBetween, + verticalAlignment = Alignment.Top + ) { + Text( + text = title, + style = MaterialTheme.typography.headlineMedium, + color = MaterialTheme.colorScheme.onSurface + ) + headerAction?.invoke() + } + + Spacer(Modifier.height(16.dp)) + + // Hier wird der eigentliche Inhalt des Screens eingesetzt + content() + } +} \ No newline at end of file diff --git a/app/src/main/java/de/schanbro/screenity/TodayScreen.kt b/app/src/main/java/de/schanbro/screenity/TodayScreen.kt new file mode 100644 index 0000000..caa274c --- /dev/null +++ b/app/src/main/java/de/schanbro/screenity/TodayScreen.kt @@ -0,0 +1,112 @@ +package de.schanbro.screenity + +import android.app.usage.UsageEvents +import android.app.usage.UsageStatsManager +import android.content.Context +import android.content.Intent +import android.provider.Settings +import android.widget.Toast +import androidx.compose.foundation.layout.* +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.CloudUpload +import androidx.compose.material.icons.filled.Refresh +import androidx.compose.material3.* +import androidx.compose.runtime.* +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.unit.dp +import com.google.gson.Gson +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext +import okhttp3.MediaType.Companion.toMediaType +import okhttp3.OkHttpClient +import okhttp3.Request +import okhttp3.RequestBody.Companion.toRequestBody +import java.text.SimpleDateFormat +import java.util.* + +data class ServerSummary( + val devices: List, + val total_all_devices_hours: Double, + val today_total_all_devices_ms: Long +) + +@Composable +fun TodayScreen() { + val context = LocalContext.current + val scope = rememberCoroutineScope() + val prefs = remember { context.getSharedPreferences("ScreenityPrefs", Context.MODE_PRIVATE) } + val serverUrl = prefs.getString("server_url", "") ?: "" + + var summary by remember { mutableStateOf(null) } + var isLoading by remember { mutableStateOf(false) } + + fun fetch() { + if (serverUrl.isBlank()) return + scope.launch { + isLoading = true + try { + summary = getSummaryFromServer(serverUrl) + } catch (e: Exception) { + } + isLoading = false + } + } + + LaunchedEffect(Unit) { fetch() } + + ScreenWrapper( + title = stringResource(R.string.all_time), + headerAction = { + IconButton(onClick = { fetch() }) { + Icon(Icons.Default.Refresh, contentDescription = null) + } + } + ) { + if (isLoading) { + Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) { + CircularProgressIndicator() + } + } else { + summary?.let { + // Nutzt die bereits definierte Card für die große Anzeige + TotalAllDevicesCard(it.today_total_all_devices_ms) + } + } + } +} + +@Composable +fun TotalAllDevicesCard(totalMs: Long) { + val h = totalMs / 3600000 + val m = (totalMs % 3600000) / 60000 + val s = (totalMs % 60000) / 1000 + + Card( + modifier = Modifier + .fillMaxWidth() + .padding(bottom = 16.dp), + colors = CardDefaults.cardColors( + containerColor = MaterialTheme.colorScheme.tertiaryContainer + ) + ) { + Column(Modifier.padding(16.dp)) { + Text( + text = stringResource(R.string.all_time), + style = MaterialTheme.typography.titleSmall, + color = MaterialTheme.colorScheme.onTertiary + ) + Text( + text = String.format("%02dh %02dm %02ds", h, m, s), + style = MaterialTheme.typography.displayMedium, + fontFamily = androidx.compose.ui.text.font.FontFamily.Monospace + ) + } + } +} \ No newline at end of file diff --git a/app/src/main/java/de/schanbro/screenity/UploadWorker.kt b/app/src/main/java/de/schanbro/screenity/UploadWorker.kt new file mode 100644 index 0000000..77de280 --- /dev/null +++ b/app/src/main/java/de/schanbro/screenity/UploadWorker.kt @@ -0,0 +1,46 @@ +package de.schanbro.screenity + +import android.content.Context +import androidx.work.CoroutineWorker +import androidx.work.WorkerParameters +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext + +class UploadWorker( + appContext: Context, + workerParams: WorkerParameters +) : CoroutineWorker(appContext, workerParams) { + + override suspend fun doWork(): Result = withContext(Dispatchers.IO) { + val prefs = applicationContext.getSharedPreferences("ScreenityPrefs", Context.MODE_PRIVATE) + val serverUrl = prefs.getString("server_url", "") ?: "" + + if (serverUrl.isBlank()) { + return@withContext Result.failure() + } + + try { + // 1. Daten sammeln (Nutzt deine optimierten Funktionen!) + val totalMs = getTotalScreenTime(applicationContext) + val usageList = getTodayUsageEvents(applicationContext) + val detailedEvents = getDetailedEvents(applicationContext) + + // 2. An den Server senden (deine bestehende Funktion) + val success = sendDataToServer( + applicationContext, + serverUrl, + totalMs, + usageList, + detailedEvents + ) + + if (success) { + Result.success() + } else { + Result.retry() // Android versucht es später nochmal, falls der Server offline war + } + } catch (e: Exception) { + Result.failure() + } + } +} \ No newline at end of file diff --git a/app/src/main/java/de/schanbro/screenity/UsageUtils.kt b/app/src/main/java/de/schanbro/screenity/UsageUtils.kt new file mode 100644 index 0000000..a629f8d --- /dev/null +++ b/app/src/main/java/de/schanbro/screenity/UsageUtils.kt @@ -0,0 +1,46 @@ +package de.schanbro.screenity + +import android.annotation.SuppressLint +import android.app.usage.UsageEvents +import android.app.usage.UsageStatsManager +import android.content.Context +import java.util.Calendar + +data class ScreenEvent( + val timestamp: Long, + val type: String, // "SCREEN_ON", "SCREEN_OFF", "APP_OPEN", "APP_CLOSE" + val packageName: String? = null +) + +@SuppressLint("ServiceCast") +fun getDetailedEvents(context: Context): List { + val usageStatsManager = context.getSystemService(Context.USAGE_STATS_SERVICE) as UsageStatsManager + val calendar = Calendar.getInstance() + calendar.set(Calendar.HOUR_OF_DAY, 0) + calendar.set(Calendar.MINUTE, 0) + calendar.set(Calendar.SECOND, 0) + + val events = usageStatsManager.queryEvents(calendar.timeInMillis, System.currentTimeMillis()) + val eventList = mutableListOf() + val event = UsageEvents.Event() + + while (events.hasNextEvent()) { + events.getNextEvent(event) + val type = when (event.eventType) { + UsageEvents.Event.SCREEN_INTERACTIVE -> "SCREEN_ON" + UsageEvents.Event.SCREEN_NON_INTERACTIVE -> "SCREEN_OFF" + UsageEvents.Event.ACTIVITY_RESUMED -> "APP_OPEN" + UsageEvents.Event.ACTIVITY_PAUSED -> "APP_CLOSE" + else -> null + } + + if (type != null) { + eventList.add(ScreenEvent( + timestamp = event.timeStamp, + type = type, + packageName = if (type.startsWith("APP")) event.packageName else null + )) + } + } + return eventList +} \ No newline at end of file diff --git a/app/src/main/java/de/schanbro/screenity/WidgetConfigActivity.kt b/app/src/main/java/de/schanbro/screenity/WidgetConfigActivity.kt new file mode 100644 index 0000000..32c2a44 --- /dev/null +++ b/app/src/main/java/de/schanbro/screenity/WidgetConfigActivity.kt @@ -0,0 +1,103 @@ +package de.schanbro.screenity + +import android.app.Activity +import android.appwidget.AppWidgetManager +import android.content.Context +import android.content.Intent +import android.os.Bundle +import androidx.activity.ComponentActivity +import androidx.activity.compose.setContent +import androidx.compose.foundation.layout.* +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.material3.* +import androidx.compose.runtime.* +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.unit.dp + +class WidgetConfigActivity : ComponentActivity() { + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + + val appWidgetId = intent?.extras?.getInt( + AppWidgetManager.EXTRA_APPWIDGET_ID, + AppWidgetManager.INVALID_APPWIDGET_ID + ) ?: AppWidgetManager.INVALID_APPWIDGET_ID + + if (appWidgetId == AppWidgetManager.INVALID_APPWIDGET_ID) { + finish() + return + } + + setContent { + MaterialTheme { + Surface(modifier = Modifier.fillMaxSize()) { + WidgetConfigScreen(appWidgetId = appWidgetId) { + val resultValue = Intent().apply { + putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId) + } + setResult(Activity.RESULT_OK, resultValue) + finish() + } + } + } + } + } +} + +@Composable +fun WidgetConfigScreen(appWidgetId: Int, onFinished: () -> Unit) { + val context = LocalContext.current + val prefs = remember { context.getSharedPreferences("ScreenityPrefs", Context.MODE_PRIVATE) } + + // ECHTE DATEN: Wir lesen die bekannten Geräte-IDs aus den SharedPreferences + // (Diese Liste füllst du am besten immer auf, wenn du Daten vom Server erfolgreich abrufst) + val deviceIds = remember { + prefs.getStringSet("known_device_ids", setOf("Dieses Gerät")) ?: setOf("Dieses Gerät") + }.toList() + + val selectedDevices = remember { mutableStateListOf() } + + Column(modifier = Modifier.padding(16.dp)) { + Text("Widget konfigurieren", style = MaterialTheme.typography.headlineSmall) + Spacer(Modifier.height(8.dp)) + Text("Wähle die Geräte aus, deren Zeit addiert werden soll:", style = MaterialTheme.typography.bodyMedium) + + Spacer(Modifier.height(16.dp)) + + // LazyColumn für den Fall, dass du sehr viele Geräte hast + LazyColumn(modifier = Modifier.weight(1f)) { + items(deviceIds) { deviceId -> + Row( + modifier = Modifier.fillMaxWidth().padding(vertical = 4.dp), + horizontalArrangement = Arrangement.SpaceBetween, + verticalAlignment = Alignment.CenterVertically + ) { + Text(deviceId, style = MaterialTheme.typography.bodyLarge) + Checkbox( + checked = selectedDevices.contains(deviceId), + onCheckedChange = { checked -> + if (checked) selectedDevices.add(deviceId) else selectedDevices.remove(deviceId) + } + ) + } + } + } + + Spacer(Modifier.height(16.dp)) + + Button( + onClick = { + // Konfiguration für dieses spezifische Widget speichern + prefs.edit().putStringSet("widget_${appWidgetId}_devices", selectedDevices.toSet()).apply() + onFinished() + }, + modifier = Modifier.fillMaxWidth(), + enabled = selectedDevices.isNotEmpty() + ) { + Text("Widget erstellen") + } + } +} \ No newline at end of file diff --git a/app/src/main/java/de/schanbro/screenity/ui/theme/Color.kt b/app/src/main/java/de/schanbro/screenity/ui/theme/Color.kt new file mode 100644 index 0000000..fb91137 --- /dev/null +++ b/app/src/main/java/de/schanbro/screenity/ui/theme/Color.kt @@ -0,0 +1,12 @@ +package de.schanbro.screenity.ui.theme + +import androidx.compose.ui.graphics.Color + +val Purple80 = Color(0xFFD0BCFF) +val PurpleGrey80 = Color(0xFFCCC2DC) +val Pink80 = Color(0xFFEFB8C8) + +val Purple40 = Color(0xFF6650a4) +val PurpleGrey40 = Color(0xFF625b71) +val Pink40 = Color(0xFF7D5260) +val SuccessGreen = Color(0xFF4CAF50) \ No newline at end of file diff --git a/app/src/main/java/de/schanbro/screenity/ui/theme/Theme.kt b/app/src/main/java/de/schanbro/screenity/ui/theme/Theme.kt new file mode 100644 index 0000000..5bf5a2b --- /dev/null +++ b/app/src/main/java/de/schanbro/screenity/ui/theme/Theme.kt @@ -0,0 +1,58 @@ +package de.schanbro.screenity.ui.theme + +import android.app.Activity +import android.os.Build +import androidx.compose.foundation.isSystemInDarkTheme +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.darkColorScheme +import androidx.compose.material3.dynamicDarkColorScheme +import androidx.compose.material3.dynamicLightColorScheme +import androidx.compose.material3.lightColorScheme +import androidx.compose.runtime.Composable +import androidx.compose.ui.platform.LocalContext + +private val DarkColorScheme = darkColorScheme( + primary = Purple80, + secondary = PurpleGrey80, + tertiary = Pink80 +) + +private val LightColorScheme = lightColorScheme( + primary = Purple40, + secondary = PurpleGrey40, + tertiary = Pink40 + + /* Other default colors to override + background = Color(0xFFFFFBFE), + surface = Color(0xFFFFFBFE), + onPrimary = Color.White, + onSecondary = Color.White, + onTertiary = Color.White, + onBackground = Color(0xFF1C1B1F), + onSurface = Color(0xFF1C1B1F), + */ +) + +@Composable +fun ScreenityTheme( + darkTheme: Boolean = isSystemInDarkTheme(), + // Dynamic color is available on Android 12+ + dynamicColor: Boolean = true, + content: @Composable () -> Unit +) { + val colorScheme = when { + dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> { + val context = LocalContext.current + if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context) + } + + darkTheme -> DarkColorScheme + else -> LightColorScheme + } + + MaterialTheme( + colorScheme = colorScheme, + typography = Typography, + content = content + ) +} \ No newline at end of file diff --git a/app/src/main/java/de/schanbro/screenity/ui/theme/Type.kt b/app/src/main/java/de/schanbro/screenity/ui/theme/Type.kt new file mode 100644 index 0000000..c3d8bf5 --- /dev/null +++ b/app/src/main/java/de/schanbro/screenity/ui/theme/Type.kt @@ -0,0 +1,81 @@ +package de.schanbro.screenity.ui.theme + +import androidx.compose.material3.Typography +import androidx.compose.ui.text.TextStyle +import androidx.compose.ui.text.font.FontFamily +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.sp + +// Set of Material typography styles to start with +val Typography = Typography( + displayMedium = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.Black, + fontSize = 32.sp, + lineHeight = 40.sp, + letterSpacing = 0.sp + ), + headlineLarge = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.Black, + fontSize = 32.sp, + lineHeight = 40.sp, + letterSpacing = 0.sp + ), + headlineMedium = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.Black, + fontSize = 28.sp, + lineHeight = 36.sp, + letterSpacing = 0.sp + ), + headlineSmall = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.Bold, + fontSize = 24.sp, + lineHeight = 32.sp, + letterSpacing = 0.sp + ), + titleLarge = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.Bold, + fontSize = 20.sp, + lineHeight = 28.sp, + letterSpacing = 0.sp + ), + titleMedium = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.Bold, + fontSize = 18.sp, + lineHeight = 24.sp, + letterSpacing = 0.15.sp + ), + titleSmall = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.Medium, + fontSize = 14.sp, + lineHeight = 20.sp, + letterSpacing = 0.1.sp + ), + bodyLarge = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.Normal, + fontSize = 16.sp, + lineHeight = 24.sp, + letterSpacing = 0.5.sp + ), + bodyMedium = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.Normal, + fontSize = 14.sp, + lineHeight = 20.sp, + letterSpacing = 0.25.sp + ), + labelSmall = TextStyle( + fontFamily = FontFamily.Default, + fontWeight = FontWeight.Medium, + fontSize = 11.sp, + lineHeight = 16.sp, + letterSpacing = 0.5.sp + ) +) \ No newline at end of file diff --git a/app/src/main/res/drawable-nodpi/screenity_edited.xml b/app/src/main/res/drawable-nodpi/screenity_edited.xml new file mode 100644 index 0000000..2c39020 --- /dev/null +++ b/app/src/main/res/drawable-nodpi/screenity_edited.xml @@ -0,0 +1,14 @@ + + + diff --git a/app/src/main/res/drawable/ic_launcher_background.xml b/app/src/main/res/drawable/ic_launcher_background.xml new file mode 100644 index 0000000..845a082 --- /dev/null +++ b/app/src/main/res/drawable/ic_launcher_background.xml @@ -0,0 +1,10 @@ + + + + diff --git a/app/src/main/res/drawable/ic_launcher_foreground.xml b/app/src/main/res/drawable/ic_launcher_foreground.xml new file mode 100644 index 0000000..2b068d1 --- /dev/null +++ b/app/src/main/res/drawable/ic_launcher_foreground.xml @@ -0,0 +1,30 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable/screenity_edited_background.xml b/app/src/main/res/drawable/screenity_edited_background.xml new file mode 100644 index 0000000..ca3826a --- /dev/null +++ b/app/src/main/res/drawable/screenity_edited_background.xml @@ -0,0 +1,74 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/app/src/main/res/drawable/screenity_edited_foreground.xml b/app/src/main/res/drawable/screenity_edited_foreground.xml new file mode 100644 index 0000000..3cdfef2 --- /dev/null +++ b/app/src/main/res/drawable/screenity_edited_foreground.xml @@ -0,0 +1,19 @@ + + + + + diff --git a/app/src/main/res/font/outfit_variable.ttf b/app/src/main/res/font/outfit_variable.ttf new file mode 100644 index 0000000000000000000000000000000000000000..466d6245f9582df39bf73da91a8b3c938fd061cd GIT binary patch literal 110884 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◊bWZ8Wa3|WCcA*%9=)Dftmumx7N`*uiZI4) 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-anydpi-v26/screenity_edited.xml b/app/src/main/res/mipmap-anydpi-v26/screenity_edited.xml new file mode 100644 index 0000000..a3d004a --- /dev/null +++ b/app/src/main/res/mipmap-anydpi-v26/screenity_edited.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/app/src/main/res/mipmap-anydpi-v26/screenity_edited_round.xml b/app/src/main/res/mipmap-anydpi-v26/screenity_edited_round.xml new file mode 100644 index 0000000..a3d004a --- /dev/null +++ b/app/src/main/res/mipmap-anydpi-v26/screenity_edited_round.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/app/src/main/res/mipmap-anydpi/ic_launcher.xml b/app/src/main/res/mipmap-anydpi/ic_launcher.xml new file mode 100644 index 0000000..6f3b755 --- /dev/null +++ b/app/src/main/res/mipmap-anydpi/ic_launcher.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/app/src/main/res/mipmap-anydpi/ic_launcher_round.xml b/app/src/main/res/mipmap-anydpi/ic_launcher_round.xml new file mode 100644 index 0000000..6f3b755 --- /dev/null +++ b/app/src/main/res/mipmap-anydpi/ic_launcher_round.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/app/src/main/res/mipmap-hdpi/ic_launcher.webp b/app/src/main/res/mipmap-hdpi/ic_launcher.webp new file mode 100644 index 0000000000000000000000000000000000000000..c209e78ecd372343283f4157dcfd918ec5165bb3 GIT binary patch literal 1404 zcmV-?1%vuhNk&F=1pok7MM6+kP&il$0000G0000-002h-06|PpNX!5L00Dqw+t%{r zzW2vH!KF=w&cMnnN@{whkTw+#mAh0SV?YL=)3MimFYCWp#fpdtz~8$hD5VPuQgtcN zXl<@<#Cme5f5yr2h%@8TWh?)bSK`O z^Z@d={gn7J{iyxL_y_%J|L>ep{dUxUP8a{byupH&!UNR*OutO~0{*T4q5R6@ApLF! z5{w?Z150gC7#>(VHFJZ-^6O@PYp{t!jH(_Z*nzTK4 zkc{fLE4Q3|mA2`CWQ3{8;gxGizgM!zccbdQoOLZc8hThi-IhN90RFT|zlxh3Ty&VG z?Fe{#9RrRnxzsu|Lg2ddugg7k%>0JeD+{XZ7>Z~{=|M+sh1MF7~ zz>To~`~LVQe1nNoR-gEzkpe{Ak^7{{ZBk2i_<+`Bq<^GB!RYG+z)h;Y3+<{zlMUYd zrd*W4w&jZ0%kBuDZ1EW&KLpyR7r2=}fF2%0VwHM4pUs}ZI2egi#DRMYZPek*^H9YK zay4Iy3WXFG(F14xYsoDA|KXgGc5%2DhmQ1gFCkrgHBm!lXG8I5h*uf{rn48Z!_@ z4Bk6TJAB2CKYqPjiX&mWoW>OPFGd$wqroa($ne7EUK;#3VYkXaew%Kh^3OrMhtjYN?XEoY`tRPQsAkH-DSL^QqyN0>^ zmC>{#F14jz4GeW{pJoRpLFa_*GI{?T93^rX7SPQgT@LbLqpNA}<@2wH;q493)G=1Y z#-sCiRNX~qf3KgiFzB3I>4Z%AfS(3$`-aMIBU+6?gbgDb!)L~A)je+;fR0jWLL-Fu z4)P{c7{B4Hp91&%??2$v9iRSFnuckHUm}or9seH6 z>%NbT+5*@L5(I9j@06@(!{ZI?U0=pKn8uwIg&L{JV14+8s2hnvbRrU|hZCd}IJu7*;;ECgO%8_*W Kmw_-CKmY()leWbG literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp b/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp new file mode 100644 index 0000000000000000000000000000000000000000..b2dfe3d1ba5cf3ee31b3ecc1ced89044a1f3b7a9 GIT binary patch literal 2898 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-hdpi/screenity_edited.webp b/app/src/main/res/mipmap-hdpi/screenity_edited.webp new file mode 100644 index 0000000000000000000000000000000000000000..e4e7a23074dc9cad513b5c1a89579dc5525ebfe4 GIT binary patch literal 2268 zcmV<22qX7WNk&H02mks)c4%z6d_m)mO>X9I4M{LQ=0;k!;r#G5M3PK^VWvI>~YW7WPrp# z4tnFH5x8WaDRdEnp50>52-xZ%w#dLzpvYlU0D@o%K`#y@NiuCo^K58wB{xg>W<95dJex{mz`Q0IQ1 z8UBM~{*j15?(GUQ0}@gVbbdwit7@JfzLZ;TH}a^zz1$Mt$)mQrLht_Rqf4mj{0in* zbNrD?Znb^RrEvC~3Maljm&BhZ`y&-~ep!2~YA%Jp*mEfC#~|%fPpdZxAf)asXC8G% zi7e+*I8Pd6E`|S0H*bvGv{ux4WJv(QX{ODlq2yH9&rA|Ea@{+8THaMtjjJPy(cb$- z{ih@SiM$ylN`Yq%i5aEoTwWzl0*Fl7&yI!2p)j3&KZG%;BmiLznzB-pUTMlq5+lpY zd-$qx^}B*e$N7l}=C07Ua0VTMYD9s60HF=4TJ}388m8opP&coYOft+)1u%C{Vj@{g zh-fl(i+?qBy%5vpf<0@ZGk!lNYxuf(Bb>Qsnh@DyK{%6cKv9%K;W&ERQ_<2Pm_~wR zzSM-nlmQugXK978$T1{2&Ais+_1xb`6DmzHE$Ns>s@t3f&=1dvVzFS6f$}1{=xqLe z4XAn>P=I8gEaQ_#&L=#D>zij;5Yc29Kol^q(@R8^8$Z~)MBm6>Xp#j%HIlKq;g4wj z@|>s^8wz_+=9JS?JXZi|LzRh#nVv|(`Ut60_<0GoTr`^vmfl#3Ne(;tz6+ue+3PzU zie_^lyvfiV{zb7&gB2BpVd;xym?`_{xUK-~h+s0jO|eXaXteWd(MR;W2CW`1fWDgat4Vij+*un;*40g#c}yisDt;b0FoTGYKZ3w!MAJl z%|zp$nPaWM8UbMWhvdeu;3Q%4oq*Fc4I~3p3N0 zHdI3CiNSkdLkjN7ouOAa* z)TV1$9NxtB9CgR(MmB`46m?&<;BXI;tvv1^xK6S=a2tilm(UZz;Z0o6ICaMEhB8JP z5&%c7`yBx~C$5j+I@wPoIZijU3V;U=5aNZzz65+4yPTSC-XO{G`?1F^aTI-zBu|QA zbHTTJ5<}g93Kw=j0$1o_iZEt7uo@1j?{s9^d4sz3oDSG<_kej3NiKZ@+~20|Vhx^8 z9FI%deLbTHB{xJ+ji`b1v32O;1j9rnOQ*vT)n;3Hw6=$ScfhBIRI+lyQ+j(dL!<^51PAOIq!{M zcfGY&mQsWy56G72p`POblb+s87pcHe^FGR~WKj!zJV?^SypG$Ce1b+Ur>LKQGe#PA z$CcB~2rB$)EeXK!OH<*wwoBT3Khw|n{aDsS$8O*0Ju3Vvy3GOK?r{v2o(bE;!;D^L zQs_@n`&+dhb`+t)rSl`A#nd(aL8Wfl6FvM-y?CB`{*^_jaF4rT=@NaR;=Xv+A+}Z@ z_w>Xu+rDY%4J!1HY_Z^#uF(%Fb}NOL4$t@cQffTb9fi8XF;x8Rt(VwZxL>1KpG7p8 z5K^ajoXY)5Aakr$K&(Dkngx#DXbP2k_#*%P6zi{4p#o6B!sa?90regaeSv5;$8r>m ze`SqzfX&-_J(*;fku#k{_@xRI>^OMi$GI-ix100Z z;o>DLK7ZSo-2jz)c@I}Mu9ZwSEKXgCVqOMV%zLP^{v`o)cHUc#ItYA)C4fQ&EBj>ly7e{1xa9N}e)%cKr6J4ucezW` z{Qb7zG@{BcAM^vs71o+5pwLQvm>obXIf# literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-hdpi/screenity_edited_round.webp b/app/src/main/res/mipmap-hdpi/screenity_edited_round.webp new file mode 100644 index 0000000000000000000000000000000000000000..2a03ffce162b0e571b529809c501cd7c09452d26 GIT binary patch literal 4094 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-mdpi/ic_launcher.webp b/app/src/main/res/mipmap-mdpi/ic_launcher.webp new file mode 100644 index 0000000000000000000000000000000000000000..4f0f1d64e58ba64d180ce43ee13bf9a17835fbca GIT binary patch literal 982 zcmV;{11bDcNk&G_0{{S5MM6+kP&il$0000G0000l001ul06|PpNU8t;00Dqo+t#w^ z^1csucXz7-Qrhzl9HuHB%l>&>1tG2^vb*E&k^T3$FG1eQZ51g$uv4V+kI`0<^1Z@N zk?Jjh$olyC%l>)Xq;7!>{iBj&BjJ`P&$fsCfpve_epJOBkTF?nu-B7D!hO=2ZR}

C%4 zc_9eOXvPbC4kzU8YowIA8cW~Uv|eB&yYwAObSwL2vY~UYI7NXPvf3b+c^?wcs~_t{ ze_m66-0)^{JdOMKPwjpQ@Sna!*?$wTZ~su*tNv7o!gXT!GRgivP}ec?5>l1!7<(rT zds|8x(qGc673zrvYIz;J23FG{9nHMnAuP}NpAED^laz3mAN1sy+NXK)!6v1FxQ;lh zOBLA>$~P3r4b*NcqR;y6pwyhZ3_PiDb|%n1gGjl3ZU}ujInlP{eks-#oA6>rh&g+!f`hv#_%JrgYPu z(U^&XLW^QX7F9Z*SRPpQl{B%x)_AMp^}_v~?j7 zapvHMKxSf*Mtyx8I}-<*UGn3)oHd(nn=)BZ`d$lDBwq_GL($_TPaS{UeevT(AJ`p0 z9%+hQb6z)U9qjbuXjg|dExCLjpS8$VKQ55VsIC%@{N5t{NsW)=hNGI`J=x97_kbz@ E0Of=7!TQj4N+cqN`nQhxvX7dAV-`K|Ub$-q+H-5I?Tx0g9jWxd@A|?POE8`3b8fO$T))xP* z(X?&brZw({`)WU&rdAs1iTa0x6F@PIxJ&&L|dpySV!ID|iUhjCcKz(@mE z!x@~W#3H<)4Ae(4eQJRk`Iz3<1)6^m)0b_4_TRZ+cz#eD3f8V;2r-1fE!F}W zEi0MEkTTx}8i1{`l_6vo0(Vuh0HD$I4SjZ=?^?k82R51bC)2D_{y8mi_?X^=U?2|F{Vr7s!k(AZC$O#ZMyavHhlQ7 zUR~QXuH~#o#>(b$u4?s~HLF*3IcF7023AlwAYudn0FV~|odGH^05AYPEfR)8p`i{n zwg3zPVp{+wOsxKc>)(pMupKF!Y2HoUqQ3|Yu|8lwR=?5zZuhG6J?H`bSNk_wPoM{u zSL{c@pY7+c2kck>`^q1^^gR0QB7Y?KUD{vz-uVX~;V-rW)PDcI)$_UjgVV?S?=oLR zf4}zz{#*R_{LkiJ#0RdQLNC^2Vp%JPEUvG9ra2BVZ92(p9h7Ka@!yf9(lj#}>+|u* z;^_?KWdzkM`6gqPo9;;r6&JEa)}R3X{(CWv?NvgLeOTq$cZXqf7|sPImi-7cS8DCN zGf;DVt3Am`>hH3{4-WzH43Ftx)SofNe^-#|0HdCo<+8Qs!}TZP{HH8~z5n`ExcHuT zDL1m&|DVpIy=xsLO>8k92HcmfSKhflQ0H~9=^-{#!I1g(;+44xw~=* zxvNz35vfsQE)@)Zsp*6_GjYD};Squ83<_?^SbALb{a`j<0Gn%6JY!zhp=Fg}Ga2|8 z52e1WU%^L1}15Ex0fF$e@eCT(()_P zvV?CA%#Sy08_U6VPt4EtmVQraWJX` zh=N|WQ>LgrvF~R&qOfB$!%D3cGv?;Xh_z$z7k&s4N)$WYf*k=|*jCEkO19{h_(%W4 zPuOqbCw`SeAX*R}UUsbVsgtuG?xs(#Ikx9`JZoQFz0n*7ZG@Fv@kZk`gzO$HoA9kN z8U5{-yY zvV{`&WKU2$mZeoBmiJrEdzUZAv1sRxpePdg1)F*X^Y)zp^Y*R;;z~vOv-z&)&G)JQ{m!C9cmziu1^nHA z`#`0c>@PnQ9CJKgC5NjJD8HM3|KC(g5nnCq$n0Gsu_DXk36@ql%npEye|?%RmG)

FJ$wK}0tWNB{uH;AM~i literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-mdpi/screenity_edited.webp b/app/src/main/res/mipmap-mdpi/screenity_edited.webp new file mode 100644 index 0000000000000000000000000000000000000000..98d565dd1b0fc3419e6fdd589b1ff027e3a94bb7 GIT binary patch literal 1632 zcmV-m2A}y-Nk&Fk1^@t8MM6+kP&iCX1^@srFTe{BD$4QyEt8aY-QC^Y-QC^Y-QC@N zad&rjcb9Q%S+1m^{k-)&Q?>Ue0Ju+;b_!S&n*l`(vjo6(Qh*fT%2`w3&e1aP6y72Q zuGF6GI5(to!3jWrDUicT4AiEeSDelP$)Gm|BnSv$lh7E5ffT&+gB)g4Kw{XM5Y{rl zZ(OZY=oqjJHi}7$9Of#)w)V7*)%}*t?2y@E=Ex-JS83KT5Ci}$8)dd_+qP|g!(E1EW<|QD@8v;KR$4{{LqW`oVL|$BR1&@Qfq3hmMXS z967i9_tQNA{}#i(zUGX7UCOy5!I7WH@QPA>A1me8lLEU?>pKHEG`h*te_!9QUrzKA-WLjYSORLawQYc!4O3O)3zoYv!8X10hcpC$R#=nBn4{=;eW z&jK#r?0!Ioq&~Z`0E87;Vh3hr(gfc?v&4i$pz@IZSr|hgePq>P-4T$m#B`LgU;BX3 z)fMs-UqG|OOu#^F+SEu=JXdW$_7F-%VPk{1T4lka+*2ShB`WM~&}*{o8xVe1ialDOG6F|1f33Ay@a^Pv{bO z8hf!@sREOffr&c{_vXtwb%x01$l(oe`0y%uU=);cl*^Lb{1Jw1iA(2A&u{TvjeXiX zNaE|I4K4HxtR=3^swog*@%aOIKar<(=1Qj(c1ZZ6URB~(qZ0s#Y)Ku^J-~l4Y`Gj0 zH_$V7TzBZwM>gYt|GpgEdp~A`alm2brbYMvfHf~0M!!by+%B6Q-OJ;E5i_TB+YVff za|a$~)NT`f0ZsKH$M{}oLtt-qi(Zf2(8#2|!7<|pV8qRfTCbYU1$ysB)Nx#u{n~q) z1yZx7=JLs)B~zqcyOAj=1EXX42f&0w=K0a+ZZ`nkw*xoD_cT0#>!n2(A2Gb4WqfvY z^1$d9KvN-0nKDlU^xO>vp&Y00!)^g`McMj!O!5UZTRx6}lK!^;UuQ3N19nK-^>d|akrj+``2s-lqNKl0oh&doa(si+p1bq= z!h(enEHSlzjiK4HW|h;Lmdl0|fzfv(^Gv;Ne`z0fhmN8Deri_Az{CqgbAk9!03f_6 z^5B#y!F8^`ip)bcy6w??@zNgb8WkCmh8!2pd*s`04 zcipkw>(mbbE|L!FpU{vAB33@F3Z`?td+6{2L^~w(+fRHI!%^6;y$5p1Ma<~Kh8Hx} zJ@1D4T`v%?9(0&n9?Mbk1ldO778aR@*&>d{9`BpTk+^w*e4RRmBj*W`|4V0ph880G z?8nZ$WdHU7L>@7`S{~O`TgK?pS@-Y5?m(oOfX$RPyzK&;4^oF_Qma*yUc?<)6DObc z>ozdL-t1Po$m+Kx+dNOqP%-V}D7KWYjQewEg{b`#Eti?DRf2`I{~ zY3o4Mc)sdmYi1|Nx7i-kwc=%hi0z-}vHE#4?ppt{7f1K+p%pvbW0?A4I>PU*4ue%y z+))5f+P{0elp(=;wm0M1-o~9@m$w3dvLja|0LZ5E&3ik%FCLB=KR(Pj{B6piuTe~I z9Ch6I@v-gm>@kgJJh+y?9X}EPtYn+I56h?Vq(mA|9)G+<8cwJ`{`ljDtW)>VV;?zk evST?26a)ZO0YHQKg?Br0(GKgd(>!wrKD-2feLoif literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-mdpi/screenity_edited_round.webp b/app/src/main/res/mipmap-mdpi/screenity_edited_round.webp new file mode 100644 index 0000000000000000000000000000000000000000..96fc8adc58c2f7080f636bb4cdd75d0a8e49aa07 GIT binary patch literal 2684 zcmV-?3WN1hNk&F=3IG6CMM6+kP&iCz3IG5vFTe{BD!mO&euN+?1)VBoppqq`Stu|sZ;P*k1&_Bcvs72qn7ZU z!1U$0-M;hlEgm?Hh-8DmS&7aQ$ebcDT@#po2u!q0#6JA(LtX#Xak(RKF!1UA%fhf>0hD;D`nnXrJiRwZCXc?b=mq?YQ z5~XBwxi6bxm;|OUq>d&0O6{~Mr`M&^<5@Ua!w0xmU|de5N>GUerafjDZIC*C6;fDI zg8^_}e7h+!WMK{YFoHMHJ|b0=fk;bq+H4Ai(i?C<6^05H)vtmsxfK3whyOd3M5 zReB}$jKf$xR?@KE`Cf!V@;D-()K05B!%~f}S2#NbbPk?bcroO3i>_%x3`@YL1f^YytHncNn|u^cD72x=yzK>8Hi+ZciI%Q2~wk|g!1~` zcs+|*+e2jfdKYtY4T|J~BAuL0z~oJact4q0B$Gnq<=HhDr9@Q;rFGgYQ2T6(ht~lb zMgh8#8D2f}S?2ts3b~?4oBKTxM%WqgCIdv1qEd3L)M*%hz$786imPHYD5Tcuq~t~b z_z)WC{ie?Oj1fu)2P+8xT%4-b*`z#z5~Xxnb$ULPq2=ASNRuy{+`RT|@u1HF)lWt_IR&uVpxKA~qY4El)jB_)sct+fzoJK^BEu%$+hs90b+^9EuyKOPHz;K zL~|+}^vGJ%bX*{SkxG}`gJKu-^?Vco?6f!MPXqwv_j?o=R~oMh0zw5Q_Ev1}`goH? zG?@sOXgt0Z6{pUqc{(Ays_~HY0KQguT5E@1@AozXGJUd9*}YDsciZt!&Zi>B7JjFf z+3gVF$Hl7e`g(s>5>2FnHCm$2V(g5lj@dL`)o4g!%>gi$@XN@%x?ac$T-?}d+5d`8 z>)rQR0a2xom(0R@z2AW!H>Z6W>|<#~G)CpF6O%;qDjD?2`n#L}=1Tp3d&dI+W~qBV ziyv?h(BbI_U!7Ms9+6pB-}y^hqG1YWxeu{-`rB!Xi!qa12B#VSaG8kw_7#< z0_&Vl%QGys;-oSL!1kPfIjM|-4reF7@BaQ+L)6Z3H_OB6je2&fbvB8gkw_N+aIms+ z`(1ct!vV7Zfd__^+-Vg>B>?aurr+l?eq6i90};CHwAkFpYCfNc0TP_8`cPLA&8cZR zA-AAd1%n5)X9m?u;*l5-P-*4U>?c>q-YDHzk0r^JdHY&5% zq4oWqkQFpcbZ7`gmB~{K5GPw7k17+3VY4Aq?XxMo^5K9pp?~WWQ*+%}s~!#O<$fn; z|F2iM2gTYs9Ebp5`-PWhMlHRo9=EDA!2PA2w>Q4QG|SgRDjxI+gh)FpYGAP-x1iVo zeLWvFyjrr}dX21>43S&JZ}R3}6@5LQvyj+r@^lrN!Lv#|& z`5o{0bi$hqfR-t2aWwM3PLF3}f`(DSIMOXMK;{Ugd)w#1TEf7O7cm!xq+S`KGgUnv z#;c!<0+1%y-Rp+PY`b2ONw3lb-eMS_c>F4SI?|WTKuZ_^z>mx7b;t!pvW#Dah=>>@ z`%q553$JG}C#mKEX%6{(bm2Rfc1}ef8NwK#YT|G7{O6XH0O0)%!!tIsS@-?}oB0s( zCgkc=iFCmTrPIPQZM64wz)F_S#}&bg3{V~RDT!5s7@%gX%712Si_r$)?YrLOe9Jpq z-S1i_%WpYfv8UTDz-F|#d)=tQca8ySgJcpf2Qfh9P?>F)lav1<*k}U+5;g_B-tRrJ z;_2bx1;iC99`wpSSoUeB0Glxw4p#a*XlB`cMUYHV4dr1bK5bivg9$NI>gCn~lVGEk zFt7nwcG$vhh}`1LQ9f>VRs>rbW3YMa=rZ}Tjs5nwJO8KDRJHoAZxV$Y0Y1F+gF#Np-uv-_NTjm$7^HM*6z-elS}s z7K<7Cd3wgdNMEDK_`Re5`A|?g@^2*_10*p(0RyzGZ@xHafb4bM*usAmMN=v?$YBhS{+BD(FFa}JP|bL-PaVtI qzRx`P)%CCV%jRLSfl{#|k6W<#W5cdzfD{HuyJ(T?!;ZDe3P}bvaw4bz literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-xhdpi/ic_launcher.webp b/app/src/main/res/mipmap-xhdpi/ic_launcher.webp new file mode 100644 index 0000000000000000000000000000000000000000..948a3070fe34c611c42c0d3ad3013a0dce358be0 GIT binary patch literal 1900 zcmV-y2b1_xNk&Fw2LJ$9MM6+kP&il$0000G0001A003VA06|PpNH75a00DqwTbm-~ zullQTcXxO9ki!OCRx^i?oR|n!<8G0=kI^!JSjFi-LL*`V;ET0H2IXfU0*i>o6o6Gy zRq6Ap5(_{XLdXcL-MzlN`ugSdZY_`jXhcENAu)N_0?GhF))9R;E`!bo9p?g?SRgw_ zEXHhFG$0{qYOqhdX<(wE4N@es3VIo$%il%6xP9gjiBri+2pI6aY4 zJbgh-Ud|V%3O!IcHKQx1FQH(_*TK;1>FQWbt^$K1zNn^cczkBs=QHCYZ8b&l!UV{K z{L0$KCf_&KR^}&2Fe|L&?1I7~pBENnCtCuH3sjcx6$c zwqkNkru);ie``q+_QI;IYLD9OV0ZxkuyBz|5<$1BH|vtey$> z5oto4=l-R-Aaq`Dk0}o9N0VrkqW_#;!u{!bJLDq%0092{Ghe=F;(kn} z+sQ@1=UlX30+2nWjkL$B^b!H2^QYO@iFc0{(-~yXj2TWz?VG{v`Jg zg}WyYnwGgn>{HFaG7E~pt=)sOO}*yd(UU-D(E&x{xKEl6OcU?pl)K%#U$dn1mDF19 zSw@l8G!GNFB3c3VVK0?uyqN&utT-D5%NM4g-3@Sii9tSXKtwce~uF zS&Jn746EW^wV~8zdQ1XC28~kXu8+Yo9p!<8h&(Q({J*4DBglPdpe4M_mD8AguZFn~ ztiuO~{6Bx?SfO~_ZV(GIboeR9~hAym{{fV|VM=77MxDrbW6`ujX z<3HF(>Zr;#*uCvC*bpoSr~C$h?_%nXps@A)=l_;({Fo#6Y1+Zv`!T5HB+)#^-Ud_; zBwftPN=d8Vx)*O1Mj+0oO=mZ+NVH*ptNDC-&zZ7Hwho6UQ#l-yNvc0Cm+2$$6YUk2D2t#vdZX-u3>-Be1u9gtTBiMB^xwWQ_rgvGpZ6(C@e23c!^K=>ai-Rqu zhqT`ZQof;9Bu!AD(i^PCbYV%yha9zuoKMp`U^z;3!+&d@Hud&_iy!O-$b9ZLcSRh? z)R|826w}TU!J#X6P%@Zh=La$I6zXa#h!B;{qfug}O%z@K{EZECu6zl)7CiNi%xti0 zB{OKfAj83~iJvmpTU|&q1^?^cIMn2RQ?jeSB95l}{DrEPTW{_gmU_pqTc)h@4T>~& zluq3)GM=xa(#^VU5}@FNqpc$?#SbVsX!~RH*5p0p@w z;~v{QMX0^bFT1!cXGM8K9FP+=9~-d~#TK#ZE{4umGT=;dfvWi?rYj;^l_Zxywze`W z^Cr{55U@*BalS}K%Czii_80e0#0#Zkhlij4-~I@}`-JFJ7$5{>LnoJSs??J8kWVl6|8A}RCGAu9^rAsfCE=2}tHwl93t0C?#+jMpvr7O3`2=tr{Hg$=HlnjVG^ewm|Js0J*kfPa6*GhtB>`fN!m#9J(sU!?(OSfzY*zS(FJ<-Vb zfAIg+`U)YaXv#sY(c--|X zEB+TVyZ%Ie4L$gi#Fc++`h6%vzsS$pjz9aLt+ZL(g;n$Dzy5=m=_TV(3H8^C{r0xd zp#a%}ht55dOq?yhwYPrtp-m1xXp;4X;)NhxxUpgP%XTLmO zcjaFva^}dP3$&sfFTIR_jC=2pHh9kpI@2(6V*GQo7Ws)`j)hd+tr@P~gR*2gO@+1? zG<`_tB+LJuF|SZ9tIec;h%}}6WClT`L>HSW?E{Hp1h^+mlbf_$9zA>!ug>NALJsO{ mU%z=YwVD?}XMya)Bp;vlyE5&E_6!fzx9pwrdz474!~g(M6R?N? literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp b/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp new file mode 100644 index 0000000000000000000000000000000000000000..1b9a6956b3acdc11f40ce2bb3f6efbd845cc243f GIT binary patch literal 3918 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 AM)SDP3vFww%t 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�(p-{x$&=IACIfoAR!za)F-^da-t3#0Dycnp zwO~NVXwXCl;jE<}>%@xz|=8fIJAB?>+E{7)|4l${4ngA3G|=r z2Dyv;VVWSgZx9Wj>qUjleGl3Ei9K4>h!(lPS%8VOG>Xu0%6VDz^O=bjJmuP7>DeUv zrbI}MlHB^^d?{zv6d=@_ZD2lg1&G7UjnVN{1}9WkaM3H~btX0GtSzB+tZ^qRgWo4m z!GmimlG$=wgXCnr6j@m<1gAL46#T~5Bnm=2{^@>|t&`9mkEPddj zAvG~@Tv~TAm2i%VW}R-g(Z0)z-Y|szHr@rk>4MAyG*Ma*7Yh#H7(!-5>DZ@8r;_dx z{prSe<>~099F8vsYd2xff7uAS%7{S)f(|@me3t2$iy&NEc7OUEchp@9A|X;;IA>8!oX+y(BKJ$EzV* znR$z;!L$s7uy@{OT~nG#B!NRraT8(X##Ho!0r_o@gg0CA-9H^;-uE&?$2$nHv_00o z%cbuUc-tCx$Uh&EZ4Nf4Zgqv)Y6>usG3>GeQnxx_Z6+PcbX-+ysbt1hQ`K1LDpOE? zrAhIZhSN9yVIAOa22gn577tbc&i3|3V8NWy&!tw##`}9*x}gtI^h1DzZRA>UuaJG) zaZ7j)dq!O}{?#8Y7~7i6fHh4{`pL?>-18|p!S75Y#^DM>-S3)vuZG+Q7l@ek zQP~#cBpWgg#mApc_sPYjpw8odQuRokmTkzcNl`^CcKB7e&;zViV;{Y{o^Y$%7i0m# z62%#1Lq!RC?}lK>%mp}T!3Xv;L*0v*>USLm``N%>w>@fwC+#T&Tx2bN4w(20JB}oU zuSa6v^kXi0xPs?pbaOHnyiqq6By1EZY9OZ^^QA>{q-Hsd&m`pbQ%8121aWG-F5xf zlZ%;B{;C>X19|`^_?dVyCq>n+41w7|!tUS!{9rHlbhX=SZO5CQ^;!Du_E7*`GiR^Q w)2!4MKjfSAeNQK-QC^Y9a8t1;X0)tNB`yj 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 A#sB~S literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-xxhdpi/screenity_edited_round.webp b/app/src/main/res/mipmap-xxhdpi/screenity_edited_round.webp new file mode 100644 index 0000000000000000000000000000000000000000..2f65b615dc3222001ab74336051b2adfd2a841b4 GIT binary patch literal 8446 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp b/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp new file mode 100644 index 0000000000000000000000000000000000000000..aa7d6427e6fa1074b79ccd52ef67ac15c5637e85 GIT binary patch literal 3844 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

UmY2RIYtNPVDpE$%vda+HD#3m z&VuXJ{BK&Qe+rBa7eq}Q(bq|tn(RrJAk|ztj2(i{d>nmQnM?;HF2k&9sA6up5tmjl z7lySlzMbifH17-m-Lwa_F&e7nOH?ESi3#ckR3tsM+jsck3`oG!uMS}|eAwVXv>}qxwq?QY%QJ0}r@^;fhuUA9W z*BVl>TGo&N004@xSiwDUXUvp51sVmqO3m)=B55aPwf@0=e}cN+$-BdKxY`YrT_4)0 z_d10#i44Q*rFr8MC>*)v$EJvz``(pb{e&*6k+b zsMz%($|1+8hn8c2?P(l@;Rb&CsZeYoCI3?2!LqjbwPXW3z4G$Qfj=cT5Yb%vY0(AX oeb?AaKtwrnc|$|zzw9vfvn^aJJ!zd)XFXqqy0000001=f@-~a#s literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-xxxhdpi/screenity_edited.webp b/app/src/main/res/mipmap-xxxhdpi/screenity_edited.webp new file mode 100644 index 0000000000000000000000000000000000000000..e4935f3d436816a511a318e757d60980f11bb93e GIT binary patch literal 5660 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±ODLpAc$xa!Q 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 Cwc0ZP literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-xxxhdpi/screenity_edited_round.webp b/app/src/main/res/mipmap-xxxhdpi/screenity_edited_round.webp new file mode 100644 index 0000000000000000000000000000000000000000..fb0fbf436550488aef612aa7dd4973d782f652d6 GIT binary patch literal 11728 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/values-en/strings.xml b/app/src/main/res/values-en/strings.xml new file mode 100644 index 0000000..f82d1ae --- /dev/null +++ b/app/src/main/res/values-en/strings.xml @@ -0,0 +1,28 @@ + + + Today + Devices + Settings + Welcome + Please enter the server-URL to start. + Local time of usage + Refresh + Couldn\'t find any data. Did you gave the permission? + Open settings! + Local + All time + Server-URL (e. g. http://192.168.178.50:5000) + Connect and start + Overview of devices + All devices combined + This divice + Sent + Error + Upload data + Server-URL + Save and try + Connection successful! + Server not reachable + Server responses with code: + Unknown network error + \ No newline at end of file diff --git a/app/src/main/res/values-fr-rFR/strings.xml b/app/src/main/res/values-fr-rFR/strings.xml new file mode 100644 index 0000000..f995a99 --- /dev/null +++ b/app/src/main/res/values-fr-rFR/strings.xml @@ -0,0 +1,28 @@ + + + Aujourd’hui + Appareils + Paramètres + Bienvenue + Veuillez saisir l’URL du serveur pour démarrer + Temps locale de utiliser + Acutaliser + Grrrr les francais!!! + Ouvrir les parametrès! + Locale + Tout les temps + L\'URL du serveur (p. e. http://192.168.178.50:5000) + Connecter et parir + \? + \? + Ce appareil + \? + \? + \? + L\'URL du serveur + Saver et essayer + \? + \? + Codé: + \? + \ No newline at end of file diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml new file mode 100644 index 0000000..c191960 --- /dev/null +++ b/app/src/main/res/values-ru/strings.xml @@ -0,0 +1,28 @@ + + + \? + \? + \? + \? + \? + \? + \? + \? + \? + \? + \? + \? + \? + \? + \? + \? + \? + \? + \? + \? + \? + \? + \? + \? + \? + \ No newline at end of file diff --git a/app/src/main/res/values/colors.xml b/app/src/main/res/values/colors.xml new file mode 100644 index 0000000..f8c6127 --- /dev/null +++ b/app/src/main/res/values/colors.xml @@ -0,0 +1,10 @@ + + + #FFBB86FC + #FF6200EE + #FF3700B3 + #FF03DAC5 + #FF018786 + #FF000000 + #FFFFFFFF + \ No newline at end of file diff --git a/app/src/main/res/values/screenity_edited_background.xml b/app/src/main/res/values/screenity_edited_background.xml new file mode 100644 index 0000000..7df4872 --- /dev/null +++ b/app/src/main/res/values/screenity_edited_background.xml @@ -0,0 +1,4 @@ + + + #3DDC84 + \ No newline at end of file diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml new file mode 100644 index 0000000..3648901 --- /dev/null +++ b/app/src/main/res/values/strings.xml @@ -0,0 +1,28 @@ + + Screenity + Heute + Geräte + Einstellungen + Willkommen + Bitte gib die Server-URL ein, um zu starten. + Lokale Nutzungszeit + Aktualisieren + Keine Daten gefunden. Hast du die Berechtigung erteilt? + Einstellungen öffnen! + Lokal + Gesamte Bildschirmzeit + Server URL (z.B. http://192.168.178.50:5000) + Verbinden und Starten + Geräteübersicht + Alle Geräte kombiniert + Dieses Gerät + Gesendet + Fehler + Daten hochladen + Server URL + Speichern und testen + Verbindung erfolgreich! + Server nicht erreichbar + Server antwortet mit Code: + Unbekannter Netzwerkfehler + \ No newline at end of file diff --git a/app/src/main/res/values/themes.xml b/app/src/main/res/values/themes.xml new file mode 100644 index 0000000..279d33a --- /dev/null +++ b/app/src/main/res/values/themes.xml @@ -0,0 +1,5 @@ + + + +