Source Code added

mobile/android/.gitignore

@@ -0,0 +1,16 @@
+gradle-wrapper.jar
+/.gradle
+/captures/
+/gradlew
+/gradlew.bat
+/local.properties
+GeneratedPluginRegistrant.java
+
+# Remember to never publicly share your keystore.
+# See https://flutter.dev/docs/deployment/android#reference-the-keystore-from-the-app
+key.properties
+**/*.keystore
+**/*.jks
+
+# Fastlane
+fastlane/report.xml

mobile/android/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gem "fastlane"

mobile/android/Gemfile.lock

@@ -0,0 +1,218 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    CFPropertyList (3.0.7)
+      base64
+      nkf
+      rexml
+    addressable (2.8.6)
+      public_suffix (>= 2.0.2, < 6.0)
+    artifactory (3.0.17)
+    atomos (0.1.3)
+    aws-eventstream (1.3.0)
+    aws-partitions (1.932.0)
+    aws-sdk-core (3.196.1)
+      aws-eventstream (~> 1, >= 1.3.0)
+      aws-partitions (~> 1, >= 1.651.0)
+      aws-sigv4 (~> 1.8)
+      jmespath (~> 1, >= 1.6.1)
+    aws-sdk-kms (1.81.0)
+      aws-sdk-core (~> 3, >= 3.193.0)
+      aws-sigv4 (~> 1.1)
+    aws-sdk-s3 (1.151.0)
+      aws-sdk-core (~> 3, >= 3.194.0)
+      aws-sdk-kms (~> 1)
+      aws-sigv4 (~> 1.8)
+    aws-sigv4 (1.8.0)
+      aws-eventstream (~> 1, >= 1.0.2)
+    babosa (1.0.4)
+    base64 (0.2.0)
+    claide (1.1.0)
+    colored (1.2)
+    colored2 (3.1.2)
+    commander (4.6.0)
+      highline (~> 2.0.0)
+    declarative (0.0.20)
+    digest-crc (0.6.5)
+      rake (>= 12.0.0, < 14.0.0)
+    domain_name (0.6.20240107)
+    dotenv (2.8.1)
+    emoji_regex (3.2.3)
+    excon (0.110.0)
+    faraday (1.10.3)
+      faraday-em_http (~> 1.0)
+      faraday-em_synchrony (~> 1.0)
+      faraday-excon (~> 1.1)
+      faraday-httpclient (~> 1.0)
+      faraday-multipart (~> 1.0)
+      faraday-net_http (~> 1.0)
+      faraday-net_http_persistent (~> 1.0)
+      faraday-patron (~> 1.0)
+      faraday-rack (~> 1.0)
+      faraday-retry (~> 1.0)
+      ruby2_keywords (>= 0.0.4)
+    faraday-cookie_jar (0.0.7)
+      faraday (>= 0.8.0)
+      http-cookie (~> 1.0.0)
+    faraday-em_http (1.0.0)
+    faraday-em_synchrony (1.0.0)
+    faraday-excon (1.1.0)
+    faraday-httpclient (1.0.1)
+    faraday-multipart (1.0.4)
+      multipart-post (~> 2)
+    faraday-net_http (1.0.1)
+    faraday-net_http_persistent (1.2.0)
+    faraday-patron (1.0.0)
+    faraday-rack (1.0.0)
+    faraday-retry (1.0.3)
+    faraday_middleware (1.2.0)
+      faraday (~> 1.0)
+    fastimage (2.3.1)
+    fastlane (2.214.0)
+      CFPropertyList (>= 2.3, < 4.0.0)
+      addressable (>= 2.8, < 3.0.0)
+      artifactory (~> 3.0)
+      aws-sdk-s3 (~> 1.0)
+      babosa (>= 1.0.3, < 2.0.0)
+      bundler (>= 1.12.0, < 3.0.0)
+      colored
+      commander (~> 4.6)
+      dotenv (>= 2.1.1, < 3.0.0)
+      emoji_regex (>= 0.1, < 4.0)
+      excon (>= 0.71.0, < 1.0.0)
+      faraday (~> 1.0)
+      faraday-cookie_jar (~> 0.0.6)
+      faraday_middleware (~> 1.0)
+      fastimage (>= 2.1.0, < 3.0.0)
+      gh_inspector (>= 1.1.2, < 2.0.0)
+      google-apis-androidpublisher_v3 (~> 0.3)
+      google-apis-playcustomapp_v1 (~> 0.1)
+      google-cloud-storage (~> 1.31)
+      highline (~> 2.0)
+      json (< 3.0.0)
+      jwt (>= 2.1.0, < 3)
+      mini_magick (>= 4.9.4, < 5.0.0)
+      multipart-post (>= 2.0.0, < 3.0.0)
+      naturally (~> 2.2)
+      optparse (~> 0.1.1)
+      plist (>= 3.1.0, < 4.0.0)
+      rubyzip (>= 2.0.0, < 3.0.0)
+      security (= 0.1.3)
+      simctl (~> 1.6.3)
+      terminal-notifier (>= 2.0.0, < 3.0.0)
+      terminal-table (>= 1.4.5, < 2.0.0)
+      tty-screen (>= 0.6.3, < 1.0.0)
+      tty-spinner (>= 0.8.0, < 1.0.0)
+      word_wrap (~> 1.0.0)
+      xcodeproj (>= 1.13.0, < 2.0.0)
+      xcpretty (~> 0.3.0)
+      xcpretty-travis-formatter (>= 0.0.3)
+    gh_inspector (1.1.3)
+    google-apis-androidpublisher_v3 (0.54.0)
+      google-apis-core (>= 0.11.0, < 2.a)
+    google-apis-core (0.11.3)
+      addressable (~> 2.5, >= 2.5.1)
+      googleauth (>= 0.16.2, < 2.a)
+      httpclient (>= 2.8.1, < 3.a)
+      mini_mime (~> 1.0)
+      representable (~> 3.0)
+      retriable (>= 2.0, < 4.a)
+      rexml
+    google-apis-iamcredentials_v1 (0.17.0)
+      google-apis-core (>= 0.11.0, < 2.a)
+    google-apis-playcustomapp_v1 (0.13.0)
+      google-apis-core (>= 0.11.0, < 2.a)
+    google-apis-storage_v1 (0.31.0)
+      google-apis-core (>= 0.11.0, < 2.a)
+    google-cloud-core (1.7.0)
+      google-cloud-env (>= 1.0, < 3.a)
+      google-cloud-errors (~> 1.0)
+    google-cloud-env (1.6.0)
+      faraday (>= 0.17.3, < 3.0)
+    google-cloud-errors (1.4.0)
+    google-cloud-storage (1.47.0)
+      addressable (~> 2.8)
+      digest-crc (~> 0.4)
+      google-apis-iamcredentials_v1 (~> 0.1)
+      google-apis-storage_v1 (~> 0.31.0)
+      google-cloud-core (~> 1.6)
+      googleauth (>= 0.16.2, < 2.a)
+      mini_mime (~> 1.0)
+    googleauth (1.8.1)
+      faraday (>= 0.17.3, < 3.a)
+      jwt (>= 1.4, < 3.0)
+      multi_json (~> 1.11)
+      os (>= 0.9, < 2.0)
+      signet (>= 0.16, < 2.a)
+    highline (2.0.3)
+    http-cookie (1.0.5)
+      domain_name (~> 0.5)
+    httpclient (2.8.3)
+    jmespath (1.6.2)
+    json (2.7.2)
+    jwt (2.8.1)
+      base64
+    mini_magick (4.12.0)
+    mini_mime (1.1.5)
+    multi_json (1.15.0)
+    multipart-post (2.4.1)
+    nanaimo (0.3.0)
+    naturally (2.2.1)
+    nkf (0.2.0)
+    optparse (0.1.1)
+    os (1.1.4)
+    plist (3.7.1)
+    public_suffix (4.0.7)
+    rake (13.2.1)
+    representable (3.2.0)
+      declarative (< 0.1.0)
+      trailblazer-option (>= 0.1.1, < 0.2.0)
+      uber (< 0.2.0)
+    retriable (3.1.2)
+    rexml (3.2.8)
+      strscan (>= 3.0.9)
+    rouge (2.0.7)
+    ruby2_keywords (0.0.5)
+    rubyzip (2.3.2)
+    security (0.1.3)
+    signet (0.19.0)
+      addressable (~> 2.8)
+      faraday (>= 0.17.5, < 3.a)
+      jwt (>= 1.5, < 3.0)
+      multi_json (~> 1.10)
+    simctl (1.6.10)
+      CFPropertyList
+      naturally
+    strscan (3.1.0)
+    terminal-notifier (2.0.0)
+    terminal-table (1.8.0)
+      unicode-display_width (~> 1.1, >= 1.1.1)
+    trailblazer-option (0.1.2)
+    tty-cursor (0.7.1)
+    tty-screen (0.8.2)
+    tty-spinner (0.9.3)
+      tty-cursor (~> 0.7)
+    uber (0.1.0)
+    unicode-display_width (1.8.0)
+    word_wrap (1.0.0)
+    xcodeproj (1.24.0)
+      CFPropertyList (>= 2.3.3, < 4.0)
+      atomos (~> 0.1.3)
+      claide (>= 1.0.2, < 2.0)
+      colored2 (~> 3.1)
+      nanaimo (~> 0.3.0)
+      rexml (~> 3.2.4)
+    xcpretty (0.3.0)
+      rouge (~> 2.0.7)
+    xcpretty-travis-formatter (1.0.1)
+      xcpretty (~> 0.2, >= 0.0.7)
+
+PLATFORMS
+  x86_64-darwin-21
+  x86_64-linux
+
+DEPENDENCIES
+  fastlane
+
+BUNDLED WITH
+   2.3.7

mobile/android/app/CMakeLists.txt

@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 3.12)
+
+set(CMAKE_C_STANDARD 17)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+
+project(native_buffer LANGUAGES C)
+
+add_library(native_buffer SHARED
+    src/main/cpp/native_buffer.c
+)
+
+target_link_libraries(native_buffer jnigraphics)

mobile/android/app/build.gradle

@@ -0,0 +1,139 @@
+plugins {
+  id "com.android.application"
+  id "kotlin-android"
+  id "dev.flutter.flutter-gradle-plugin"
+  id 'com.google.devtools.ksp'
+  id 'org.jetbrains.kotlin.plugin.compose' version '2.0.20' // this version matches your Kotlin version
+
+}
+
+def localProperties = new Properties()
+def localPropertiesFile = rootProject.file('local.properties')
+if (localPropertiesFile.exists()) {
+  localPropertiesFile.withInputStream { localProperties.load(it) }
+}
+
+def flutterVersionCode = localProperties.getProperty('flutter.versionCode')
+if (flutterVersionCode == null) {
+  flutterVersionCode = '1'
+}
+
+def flutterVersionName = localProperties.getProperty('flutter.versionName')
+if (flutterVersionName == null) {
+  flutterVersionName = '1.0'
+}
+
+def keystoreProperties = new Properties()
+def keystorePropertiesFile = rootProject.file('key.properties')
+if (keystorePropertiesFile.exists()) {
+  keystorePropertiesFile.withInputStream { keystoreProperties.load(it) }
+}
+
+android {
+  compileSdkVersion 35
+  ndkVersion = "28.2.13676358"
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+    coreLibraryDesugaringEnabled true
+  }
+
+  kotlinOptions {
+    jvmTarget = '17'
+  }
+
+  sourceSets {
+    main.java.srcDirs += 'src/main/kotlin'
+  }
+
+  buildFeatures {
+    buildConfig true
+    compose true
+  }
+
+  defaultConfig {
+    applicationId "app.alextran.immich"
+    minSdkVersion 26
+    targetSdkVersion 35
+    versionCode flutterVersionCode.toInteger()
+    versionName flutterVersionName
+  }
+
+  signingConfigs {
+    release {
+      def keyAliasVal = System.getenv("ALIAS")
+      def keyPasswordVal = System.getenv("ANDROID_KEY_PASSWORD")
+      def storePasswordVal = System.getenv("ANDROID_STORE_PASSWORD")
+
+      keyAlias keyAliasVal ? keyAliasVal : keystoreProperties['keyAlias']
+      keyPassword keyPasswordVal ? keyPasswordVal : keystoreProperties['keyPassword']
+      storeFile file("../key.jks") ? file("../key.jks") : file(keystoreProperties['storeFile'])
+      storePassword storePasswordVal ? storePasswordVal : keystoreProperties['storePassword']
+    }
+  }
+
+  buildTypes {
+    debug {
+      applicationIdSuffix '.debug'
+      versionNameSuffix '-DEBUG'
+    }
+
+    release {
+      signingConfig signingConfigs.release
+    }
+  }
+  namespace 'app.alextran.immich'
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+}
+
+flutter {
+  source '../..'
+}
+
+dependencies {
+  def kotlin_version = '2.0.20'
+  def kotlin_coroutines_version = '1.9.0'
+  def work_version = '2.9.1'
+  def concurrent_version = '1.2.0'
+  def guava_version = '33.3.1-android'
+  def glide_version = '4.16.0'
+  def serialization_version = '1.8.1'
+  def compose_version = '1.1.1'
+  def gson_version = '2.10.1'
+  def okhttp_version = '4.12.0'
+
+  implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
+  implementation "com.squareup.okhttp3:okhttp:$okhttp_version"
+  implementation 'org.chromium.net:cronet-embedded:143.7445.0'
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:$kotlin_coroutines_version"
+  implementation "androidx.work:work-runtime-ktx:$work_version"
+  implementation "androidx.concurrent:concurrent-futures:$concurrent_version"
+  implementation "com.google.guava:guava:$guava_version"
+  implementation "com.github.bumptech.glide:glide:$glide_version"
+  implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:$serialization_version"
+
+  ksp "com.github.bumptech.glide:ksp:$glide_version"
+  coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:2.1.2'
+
+  //Glance Widget
+  implementation "androidx.glance:glance-appwidget:$compose_version"
+  implementation "com.google.code.gson:gson:$gson_version"
+
+  // Glance Configure
+  implementation "androidx.activity:activity-compose:1.8.2"
+  implementation "androidx.compose.ui:ui:$compose_version"
+  implementation "androidx.compose.ui:ui-tooling:$compose_version"
+  implementation "androidx.compose.material3:material3:1.2.1"
+  implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.6.2"
+}
+
+// This is uncommented in F-Droid build script
+//f configurations.all {
+//f     exclude group: 'com.google.android.gms'
+//f }

mobile/android/app/proguard-rules.pro

@@ -0,0 +1,39 @@
+##---------------Begin: proguard configuration for Gson  ----------
+# Gson uses generic type information stored in a class file when working with fields. Proguard
+# removes such information by default, so configure it to keep all of it.
+-keepattributes Signature
+
+# For using GSON @Expose annotation
+-keepattributes *Annotation*
+
+# Gson specific classes
+-dontwarn sun.misc.**
+#-keep class com.google.gson.stream.** { *; }
+
+# Application classes that will be serialized/deserialized over Gson
+-keep class com.google.gson.examples.android.model.** { <fields>; }
+
+# Prevent proguard from stripping interface information from TypeAdapter, TypeAdapterFactory,
+# JsonSerializer, JsonDeserializer instances (so they can be used in @JsonAdapter)
+-keep class * extends com.google.gson.TypeAdapter
+-keep class * implements com.google.gson.TypeAdapterFactory
+-keep class * implements com.google.gson.JsonSerializer
+-keep class * implements com.google.gson.JsonDeserializer
+
+# Prevent R8 from leaving Data object members always null
+-keepclassmembers,allowobfuscation class * {
+  @com.google.gson.annotations.SerializedName <fields>;
+}
+
+# TypeToken preventions
+-keep class com.google.gson.reflect.TypeToken { *; }
+-keep class * extends com.google.gson.reflect.TypeToken
+
+# Retain generic signatures of TypeToken and its subclasses with R8 version 3.0 and higher.
+-keep,allowobfuscation,allowshrinking class com.google.gson.reflect.TypeToken
+-keep,allowobfuscation,allowshrinking class * extends com.google.gson.reflect.TypeToken
+
+##---------------End: proguard configuration for Gson  ----------
+
+# Keep all widget model classes and their fields for Gson
+-keep class app.alextran.immich.widget.model.** { *; }

mobile/android/app/src/debug/AndroidManifest.xml

@@ -0,0 +1,10 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          xmlns:tools="http://schemas.android.com/tools">
+  <!-- Flutter needs it to communicate with the running application
+         to allow setting breakpoints, to provide hot reload, etc.
+    -->
+  <uses-permission android:name="android.permission.INTERNET" />
+
+  <application android:label="Immich-Debug" tools:replace="android:label">
+  </application>
+</manifest>

mobile/android/app/src/main/AndroidManifest.xml

@@ -0,0 +1,197 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:tools="http://schemas.android.com/tools">
+
+  <uses-permission android:name="android.permission.INTERNET" />
+  <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"
+    android:maxSdkVersion="32" />
+  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"
+    android:maxSdkVersion="32" />
+  <uses-permission android:name="android.permission.ACCESS_MEDIA_LOCATION" />
+  <uses-permission android:name="android.permission.MANAGE_MEDIA" />
+  <uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />
+  <uses-permission android:name="android.permission.READ_MEDIA_VIDEO" />
+  <uses-permission android:name="android.permission.READ_MEDIA_AUDIO" />
+  <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+  <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+  <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+  <uses-permission android:name="android.permission.READ_MEDIA_VISUAL_USER_SELECTED" />
+  <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+  <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
+  <uses-permission android:name="android.permission.USE_BIOMETRIC" />
+
+  <!-- Foreground service permission -->
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION" />
+
+  <application android:label="Immich" android:name=".ImmichApp" android:usesCleartextTraffic="true"
+    android:icon="@mipmap/ic_launcher" android:requestLegacyExternalStorage="true"
+    android:largeHeap="true" android:enableOnBackInvokedCallback="false" android:allowBackup="false">
+
+    <profileable android:shell="true" />
+
+    <service
+      android:name="androidx.work.impl.foreground.SystemForegroundService"
+      android:directBootAware="false"
+      android:enabled="@bool/enable_system_foreground_service_default"
+      android:exported="false"
+      android:foregroundServiceType="dataSync|shortService" />
+
+    <meta-data
+      android:name="io.flutter.embedding.android.EnableImpeller"
+      android:value="false" />
+
+    <meta-data
+      android:name="com.google.firebase.messaging.default_notification_icon"
+      android:resource="@drawable/notification_icon" />
+
+    <activity android:name=".MainActivity" android:exported="true" android:launchMode="singleTask"
+      android:theme="@style/LaunchTheme"
+      android:configChanges="orientation|keyboardHidden|keyboard|screenSize|smallestScreenSize|locale|layoutDirection|fontScale|screenLayout|density|uiMode"
+      android:hardwareAccelerated="true" android:windowSoftInputMode="adjustResize">
+      <!-- Specifies an Android theme to apply to this Activity as soon as
+                 the
+      Android process has started. This theme is visible to the user
+                 while the
+      Flutter UI initializes. After that, this theme continues
+                 to determine the
+      Window background behind the Flutter UI. -->
+      <meta-data android:name="io.flutter.embedding.android.NormalTheme"
+        android:resource="@style/NormalTheme" />
+      <intent-filter>
+        <action android:name="android.intent.action.MAIN" />
+        <category android:name="android.intent.category.LAUNCHER" />
+      </intent-filter>
+
+
+      <!--TODO:
+      Add this filter if you want to handle shared images-->
+      <intent-filter android:label="Upload to Immich">
+        <action android:name="android.intent.action.SEND" />
+        <category android:name="android.intent.category.DEFAULT" />
+        <data android:mimeType="image/*" />
+      </intent-filter>
+
+      <intent-filter android:label="Upload to Immich">
+        <action android:name="android.intent.action.SEND_MULTIPLE" />
+        <category android:name="android.intent.category.DEFAULT" />
+        <data android:mimeType="image/*" />
+      </intent-filter>
+
+      <!--TODO:
+      Add this filter if you want to handle shared videos-->
+      <intent-filter android:label="Upload to Immich">
+        <action android:name="android.intent.action.SEND" />
+        <category android:name="android.intent.category.DEFAULT" />
+        <data android:mimeType="video/*" />
+      </intent-filter>
+      <intent-filter android:label="Upload to Immich">
+        <action android:name="android.intent.action.SEND_MULTIPLE" />
+        <category android:name="android.intent.category.DEFAULT" />
+        <data android:mimeType="video/*" />
+      </intent-filter>
+
+      <!-- immich:// URL scheme handling -->
+      <intent-filter>
+        <action android:name="android.intent.action.VIEW" />
+        <category android:name="android.intent.category.DEFAULT" />
+        <category android:name="android.intent.category.BROWSABLE" />
+        <data android:scheme="immich" />
+      </intent-filter>
+
+      <!-- my.immich.app deep link -->
+      <intent-filter android:autoVerify="true">
+        <action android:name="android.intent.action.VIEW" />
+        <category android:name="android.intent.category.DEFAULT" />
+        <category android:name="android.intent.category.BROWSABLE" />
+
+        <data android:scheme="https" />
+
+        <data
+          android:host="my.immich.app"
+          android:path="/" />
+        <data
+          android:host="my.immich.app"
+          android:pathPrefix="/albums/" />
+        <data
+          android:host="my.immich.app"
+          android:pathPrefix="/memories/" />
+        <data
+          android:host="my.immich.app"
+          android:path="/memory" />
+        <data
+          android:host="my.immich.app"
+          android:pathPrefix="/photos/" />
+      </intent-filter>
+    </activity>
+
+
+    <activity
+      android:name="com.linusu.flutter_web_auth_2.CallbackActivity"
+      android:exported="true">
+      <intent-filter android:label="flutter_web_auth_2">
+        <action android:name="android.intent.action.VIEW" />
+        <category android:name="android.intent.category.DEFAULT" />
+        <category android:name="android.intent.category.BROWSABLE" />
+        <data android:scheme="app.immich" android:pathPrefix="/oauth-callback" />
+      </intent-filter>
+    </activity>
+    <!-- Don't delete the meta-data below.
+             This is used by the Flutter tool to
+    generate GeneratedPluginRegistrant.java -->
+    <meta-data android:name="flutterEmbedding" android:value="2" />
+    <!-- Disables default WorkManager initialization to use our custom initialization -->
+    <provider
+      android:name="androidx.startup.InitializationProvider"
+      android:authorities="${applicationId}.androidx-startup"
+      tools:node="remove" />
+
+
+    <!-- Widgets -->
+    <receiver
+      android:name=".widget.RandomReceiver"
+      android:exported="true"
+      android:label="@string/random_widget_title">
+      <intent-filter>
+        <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
+      </intent-filter>
+      <meta-data
+        android:name="android.appwidget.provider"
+        android:resource="@xml/random_widget" />
+    </receiver>
+
+    <receiver
+      android:name=".widget.MemoryReceiver"
+      android:exported="true"
+      android:label="@string/memory_widget_title">
+      <intent-filter>
+        <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
+      </intent-filter>
+      <meta-data
+        android:name="android.appwidget.provider"
+        android:resource="@xml/memory_widget" />
+    </receiver>
+
+    <activity android:name=".widget.configure.RandomConfigure"
+      android:exported="true"
+      android:theme="@style/Theme.Material3.DayNight.NoActionBar">
+
+      <intent-filter>
+        <action android:name="android.appwidget.action.APPWIDGET_CONFIGURE"/>
+      </intent-filter>
+    </activity>
+  </application>
+
+
+  <queries>
+    <intent>
+      <action android:name="android.intent.action.VIEW" />
+      <data android:scheme="https" />
+    </intent>
+    <intent>
+      <action android:name="android.intent.action.VIEW" />
+      <data android:scheme="geo" />
+    </intent>
+  </queries>
+</manifest>

mobile/android/app/src/main/cpp/native_buffer.c

@@ -0,0 +1,38 @@
+#include <jni.h>
+#include <stdlib.h>
+#include <string.h>
+
+JNIEXPORT jlong JNICALL
+Java_app_alextran_immich_NativeBuffer_allocate(
+        JNIEnv *env, jclass clazz, jint size) {
+    void *ptr = malloc(size);
+    return (jlong) ptr;
+}
+
+JNIEXPORT void JNICALL
+Java_app_alextran_immich_NativeBuffer_free(
+        JNIEnv *env, jclass clazz, jlong address) {
+    free((void *) address);
+}
+
+JNIEXPORT jlong JNICALL
+Java_app_alextran_immich_NativeBuffer_realloc(
+        JNIEnv *env, jclass clazz, jlong address, jint size) {
+    void *ptr = realloc((void *) address, size);
+    return (jlong) ptr;
+}
+
+JNIEXPORT jobject JNICALL
+Java_app_alextran_immich_NativeBuffer_wrap(
+        JNIEnv *env, jclass clazz, jlong address, jint capacity) {
+    return (*env)->NewDirectByteBuffer(env, (void *) address, capacity);
+}
+
+JNIEXPORT void JNICALL
+Java_app_alextran_immich_NativeBuffer_copy(
+        JNIEnv *env, jclass clazz, jobject buffer, jlong destAddress, jint offset, jint length) {
+    void *src = (*env)->GetDirectBufferAddress(env, buffer);
+    if (src != NULL) {
+        memcpy((void *) destAddress, (char *) src + offset, length);
+    }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/AppGlideModule.kt

@@ -0,0 +1,20 @@
+package app.alextran.immich
+
+import android.content.Context
+import com.bumptech.glide.GlideBuilder
+import com.bumptech.glide.annotation.GlideModule
+import com.bumptech.glide.load.engine.bitmap_recycle.BitmapPoolAdapter
+import com.bumptech.glide.load.engine.cache.DiskCacheAdapter
+import com.bumptech.glide.load.engine.cache.MemoryCacheAdapter
+import com.bumptech.glide.module.AppGlideModule
+
+@GlideModule
+class AppGlideModule : AppGlideModule() {
+  override fun applyOptions(context: Context, builder: GlideBuilder) {
+    super.applyOptions(context, builder)
+    // disable caching as this is already done on the Flutter side
+    builder.setMemoryCache(MemoryCacheAdapter())
+    builder.setDiskCache(DiskCacheAdapter.Factory())
+    builder.setBitmapPool(BitmapPoolAdapter())
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/BackgroundServicePlugin.kt

@@ -0,0 +1,389 @@
+package app.alextran.immich
+
+import android.app.Activity
+import android.content.ContentResolver
+import android.content.ContentUris
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.os.Build
+import android.os.Bundle
+import android.provider.MediaStore
+import android.provider.Settings
+import android.util.Log
+import androidx.annotation.RequiresApi
+import io.flutter.embedding.engine.plugins.FlutterPlugin
+import io.flutter.embedding.engine.plugins.activity.ActivityAware
+import io.flutter.embedding.engine.plugins.activity.ActivityPluginBinding
+import io.flutter.plugin.common.BinaryMessenger
+import io.flutter.plugin.common.MethodCall
+import io.flutter.plugin.common.MethodChannel
+import io.flutter.plugin.common.MethodChannel.Result
+import io.flutter.plugin.common.PluginRegistry
+import java.security.MessageDigest
+import java.io.FileInputStream
+import kotlinx.coroutines.*
+import androidx.core.net.toUri
+
+/**
+ * Android plugin for Dart `BackgroundService` and file trash operations
+ */
+class BackgroundServicePlugin : FlutterPlugin, MethodChannel.MethodCallHandler, ActivityAware, PluginRegistry.ActivityResultListener {
+
+  private var methodChannel: MethodChannel? = null
+  private var fileTrashChannel: MethodChannel? = null
+  private var context: Context? = null
+  private var pendingResult: Result? = null
+  private val permissionRequestCode = 1001
+  private val trashRequestCode = 1002
+  private var activityBinding: ActivityPluginBinding? = null
+
+  override fun onAttachedToEngine(binding: FlutterPlugin.FlutterPluginBinding) {
+    onAttachedToEngine(binding.applicationContext, binding.binaryMessenger)
+  }
+
+  private fun onAttachedToEngine(ctx: Context, messenger: BinaryMessenger) {
+    context = ctx
+    methodChannel = MethodChannel(messenger, "immich/foregroundChannel")
+    methodChannel?.setMethodCallHandler(this)
+
+    // Add file trash channel
+    fileTrashChannel = MethodChannel(messenger, "file_trash")
+    fileTrashChannel?.setMethodCallHandler(this)
+  }
+
+  override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
+    onDetachedFromEngine()
+  }
+
+  private fun onDetachedFromEngine() {
+    methodChannel?.setMethodCallHandler(null)
+    methodChannel = null
+    fileTrashChannel?.setMethodCallHandler(null)
+    fileTrashChannel = null
+  }
+
+  override fun onMethodCall(call: MethodCall, result: Result) {
+    val ctx = context!!
+    when (call.method) {
+      // Existing BackgroundService methods
+      "enable" -> {
+        val args = call.arguments<ArrayList<*>>()!!
+        ctx.getSharedPreferences(BackupWorker.SHARED_PREF_NAME, Context.MODE_PRIVATE)
+          .edit()
+          .putBoolean(ContentObserverWorker.SHARED_PREF_SERVICE_ENABLED, true)
+          .putLong(BackupWorker.SHARED_PREF_CALLBACK_KEY, args[0] as Long)
+          .putString(BackupWorker.SHARED_PREF_NOTIFICATION_TITLE, args[1] as String)
+          .apply()
+        ContentObserverWorker.enable(ctx, immediate = args[2] as Boolean)
+        result.success(true)
+      }
+
+      "configure" -> {
+        val args = call.arguments<ArrayList<*>>()!!
+        val requireUnmeteredNetwork = args[0] as Boolean
+        val requireCharging = args[1] as Boolean
+        val triggerUpdateDelay = (args[2] as Number).toLong()
+        val triggerMaxDelay = (args[3] as Number).toLong()
+        ContentObserverWorker.configureWork(
+          ctx,
+          requireUnmeteredNetwork,
+          requireCharging,
+          triggerUpdateDelay,
+          triggerMaxDelay
+        )
+        result.success(true)
+      }
+
+      "disable" -> {
+        ContentObserverWorker.disable(ctx)
+        BackupWorker.stopWork(ctx)
+        result.success(true)
+      }
+
+      "isEnabled" -> {
+        result.success(ContentObserverWorker.isEnabled(ctx))
+      }
+
+      "isIgnoringBatteryOptimizations" -> {
+        result.success(BackupWorker.isIgnoringBatteryOptimizations(ctx))
+      }
+
+      "digestFiles" -> {
+        val args = call.arguments<ArrayList<String>>()!!
+        GlobalScope.launch(Dispatchers.IO) {
+          val buf = ByteArray(BUFFER_SIZE)
+          val digest: MessageDigest = MessageDigest.getInstance("SHA-1")
+          val hashes = arrayOfNulls<ByteArray>(args.size)
+          for (i in args.indices) {
+            val path = args[i]
+            var len = 0
+            try {
+              val file = FileInputStream(path)
+              file.use { assetFile ->
+                while (true) {
+                  len = assetFile.read(buf)
+                  if (len != BUFFER_SIZE) break
+                  digest.update(buf)
+                }
+              }
+              digest.update(buf, 0, len)
+              hashes[i] = digest.digest()
+            } catch (e: Exception) {
+              // skip this file
+              Log.w(TAG, "Failed to hash file ${args[i]}: $e")
+            }
+          }
+          result.success(hashes.asList())
+        }
+      }
+
+      // File Trash methods moved from MainActivity
+      "moveToTrash" -> {
+        val mediaUrls = call.argument<List<String>>("mediaUrls")
+        if (mediaUrls != null) {
+          if ((Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) && hasManageMediaPermission()) {
+            moveToTrash(mediaUrls, result)
+          } else {
+            result.error("PERMISSION_DENIED", "Media permission required", null)
+          }
+        } else {
+          result.error("INVALID_NAME", "The mediaUrls is not specified.", null)
+        }
+      }
+
+      "restoreFromTrash" -> {
+        val fileName = call.argument<String>("fileName")
+        val type = call.argument<Int>("type")
+        val mediaId = call.argument<String>("mediaId")
+        if (fileName != null && type != null) {
+          if ((Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) && hasManageMediaPermission()) {
+            restoreFromTrash(fileName, type, result)
+          } else {
+            result.error("PERMISSION_DENIED", "Media permission required", null)
+          }
+        } else
+          if (mediaId != null && type != null) {
+            if ((Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) && hasManageMediaPermission()) {
+              restoreFromTrashById(mediaId, type, result)
+            } else {
+              result.error("PERMISSION_DENIED", "Media permission required", null)
+            }
+          } else {
+            result.error("INVALID_PARAMS", "Required params are not specified.", null)
+          }
+      }
+
+      "requestManageMediaPermission" -> {
+        if (!hasManageMediaPermission()) {
+          requestManageMediaPermission(result)
+        } else {
+          Log.e("Manage storage permission", "Permission already granted")
+          result.success(true)
+        }
+      }
+
+      "hasManageMediaPermission" -> {
+        if (hasManageMediaPermission()) {
+          Log.i("Manage storage permission", "Permission already granted")
+          result.success(true)
+        } else {
+          result.success(false)
+        }
+      }
+
+      "manageMediaPermission" -> requestManageMediaPermission(result)
+
+      else -> result.notImplemented()
+    }
+  }
+
+  private fun hasManageMediaPermission(): Boolean {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      MediaStore.canManageMedia(context!!);
+    } else  {
+      false
+    }
+  }
+
+  private fun requestManageMediaPermission(result: Result) {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      pendingResult = result // Store the result callback
+      val activity = activityBinding?.activity ?: return
+
+      val intent = Intent(Settings.ACTION_REQUEST_MANAGE_MEDIA)
+      intent.data = "package:${activity.packageName}".toUri()
+      activity.startActivityForResult(intent, permissionRequestCode)
+    } else {
+      result.success(false)
+    }
+  }
+
+  @RequiresApi(Build.VERSION_CODES.R)
+  private fun moveToTrash(mediaUrls: List<String>, result: Result) {
+    val urisToTrash = mediaUrls.map { it.toUri() }
+    if (urisToTrash.isEmpty()) {
+      result.error("INVALID_ARGS", "No valid URIs provided", null)
+      return
+    }
+
+    toggleTrash(urisToTrash, true, result);
+  }
+
+  @RequiresApi(Build.VERSION_CODES.R)
+  private fun restoreFromTrash(name: String, type: Int, result: Result) {
+    val uri = getTrashedFileUri(name, type)
+    if (uri == null) {
+      Log.e("TrashError", "Asset Uri cannot be found obtained")
+      result.error("TrashError", "Asset Uri cannot be found obtained", null)
+      return
+    }
+    Log.e("FILE_URI", uri.toString())
+    uri.let { toggleTrash(listOf(it), false, result) }
+  }
+
+  @RequiresApi(Build.VERSION_CODES.R)
+  private fun restoreFromTrashById(mediaId: String, type: Int, result: Result) {
+    val id = mediaId.toLongOrNull()
+    if (id == null) {
+      result.error("INVALID_ID", "The file id is not a valid number: $mediaId", null)
+      return
+    }
+    if (!isInTrash(id)) {
+      result.error("TrashNotFound", "Item with id=$id not found in trash", null)
+      return
+    }
+
+    val uri = ContentUris.withAppendedId(contentUriForType(type), id)
+
+    try {
+      Log.i(TAG, "restoreFromTrashById: uri=$uri (type=$type,id=$id)")
+      restoreUris(listOf(uri), result)
+    } catch (e: Exception) {
+      Log.w(TAG, "restoreFromTrashById failed", e)
+    }
+  }
+
+  @RequiresApi(Build.VERSION_CODES.R)
+  private fun toggleTrash(contentUris: List<Uri>, isTrashed: Boolean, result: Result) {
+    val activity = activityBinding?.activity
+    val contentResolver = context?.contentResolver
+    if (activity == null || contentResolver == null) {
+      result.error("TrashError", "Activity or ContentResolver not available", null)
+      return
+    }
+
+    try {
+      val pendingIntent = MediaStore.createTrashRequest(contentResolver, contentUris, isTrashed)
+      pendingResult = result // Store for onActivityResult
+      activity.startIntentSenderForResult(
+        pendingIntent.intentSender,
+        trashRequestCode,
+        null, 0, 0, 0
+      )
+    } catch (e: Exception) {
+      Log.e("TrashError", "Error creating or starting trash request", e)
+      result.error("TrashError", "Error creating or starting trash request", null)
+    }
+  }
+
+  @RequiresApi(Build.VERSION_CODES.R)
+  private fun getTrashedFileUri(fileName: String, type: Int): Uri? {
+    val contentResolver = context?.contentResolver ?: return null
+    val queryUri = MediaStore.Files.getContentUri(MediaStore.VOLUME_EXTERNAL)
+    val projection = arrayOf(MediaStore.Files.FileColumns._ID)
+
+    val queryArgs = Bundle().apply {
+      putString(
+        ContentResolver.QUERY_ARG_SQL_SELECTION,
+        "${MediaStore.Files.FileColumns.DISPLAY_NAME} = ?"
+      )
+      putStringArray(ContentResolver.QUERY_ARG_SQL_SELECTION_ARGS, arrayOf(fileName))
+      putInt(MediaStore.QUERY_ARG_MATCH_TRASHED, MediaStore.MATCH_ONLY)
+    }
+
+    contentResolver.query(queryUri, projection, queryArgs, null)?.use { cursor ->
+      if (cursor.moveToFirst()) {
+        val id = cursor.getLong(cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns._ID))
+        return ContentUris.withAppendedId(contentUriForType(type), id)
+      }
+    }
+    return null
+  }
+
+  // ActivityAware implementation
+  override fun onAttachedToActivity(binding: ActivityPluginBinding) {
+    activityBinding = binding
+    binding.addActivityResultListener(this)
+  }
+
+  override fun onDetachedFromActivityForConfigChanges() {
+    activityBinding?.removeActivityResultListener(this)
+    activityBinding = null
+  }
+
+  override fun onReattachedToActivityForConfigChanges(binding: ActivityPluginBinding) {
+    activityBinding = binding
+    binding.addActivityResultListener(this)
+  }
+
+  override fun onDetachedFromActivity() {
+    activityBinding?.removeActivityResultListener(this)
+    activityBinding = null
+  }
+
+  // ActivityResultListener implementation
+  override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?): Boolean {
+    if (requestCode == permissionRequestCode) {
+      val granted = hasManageMediaPermission()
+      pendingResult?.success(granted)
+      pendingResult = null
+      return true
+    }
+
+    if (requestCode == trashRequestCode) {
+      val approved = resultCode == Activity.RESULT_OK
+      pendingResult?.success(approved)
+      pendingResult = null
+      return true
+    }
+    return false
+  }
+
+  @RequiresApi(Build.VERSION_CODES.R)
+  private fun isInTrash(id: Long): Boolean {
+    val contentResolver = context?.contentResolver ?: return false
+    val filesUri = MediaStore.Files.getContentUri(MediaStore.VOLUME_EXTERNAL)
+    val args = Bundle().apply {
+      putString(ContentResolver.QUERY_ARG_SQL_SELECTION, "${MediaStore.Files.FileColumns._ID}=?")
+      putStringArray(ContentResolver.QUERY_ARG_SQL_SELECTION_ARGS, arrayOf(id.toString()))
+      putInt(MediaStore.QUERY_ARG_MATCH_TRASHED, MediaStore.MATCH_ONLY)
+      putInt(ContentResolver.QUERY_ARG_LIMIT, 1)
+    }
+    return contentResolver.query(filesUri, arrayOf(MediaStore.Files.FileColumns._ID), args, null)
+      ?.use { it.moveToFirst() } == true
+  }
+
+  @RequiresApi(Build.VERSION_CODES.R)
+  private fun restoreUris(uris: List<Uri>, result: Result) {
+    if (uris.isEmpty()) {
+      result.error("TrashError", "No URIs to restore", null)
+      return
+    }
+    Log.i(TAG, "restoreUris: count=${uris.size}, first=${uris.first()}")
+    toggleTrash(uris, false, result)
+  }
+
+  @RequiresApi(Build.VERSION_CODES.Q)
+  private fun contentUriForType(type: Int): Uri =
+    when (type) {
+      // same order as AssetType from dart
+      1 -> MediaStore.Images.Media.EXTERNAL_CONTENT_URI
+      2 -> MediaStore.Video.Media.EXTERNAL_CONTENT_URI
+      3 -> MediaStore.Audio.Media.EXTERNAL_CONTENT_URI
+      else -> MediaStore.Files.getContentUri(MediaStore.VOLUME_EXTERNAL)
+    }
+}
+
+private const val TAG = "BackgroundServicePlugin"
+private const val BUFFER_SIZE = 2 * 1024 * 1024

mobile/android/app/src/main/kotlin/app/alextran/immich/BackupWorker.kt

@@ -0,0 +1,394 @@
+package app.alextran.immich
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.content.Context
+import android.content.pm.ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.os.PowerManager
+import android.os.SystemClock
+import android.util.Log
+import androidx.annotation.RequiresApi
+import androidx.core.app.NotificationCompat
+import androidx.concurrent.futures.ResolvableFuture
+import androidx.work.BackoffPolicy
+import androidx.work.Constraints
+import androidx.work.ForegroundInfo
+import androidx.work.ListenableWorker
+import androidx.work.NetworkType
+import androidx.work.WorkerParameters
+import androidx.work.ExistingWorkPolicy
+import androidx.work.OneTimeWorkRequest
+import androidx.work.WorkManager
+import androidx.work.WorkInfo
+import com.google.common.util.concurrent.ListenableFuture
+import io.flutter.embedding.engine.FlutterEngine
+import io.flutter.embedding.engine.dart.DartExecutor
+import io.flutter.embedding.engine.loader.FlutterLoader
+import io.flutter.plugin.common.MethodCall
+import io.flutter.plugin.common.MethodChannel
+import io.flutter.view.FlutterCallbackInformation
+import java.util.concurrent.TimeUnit
+
+/**
+ * Worker executed by Android WorkManager to perform backup in background
+ *
+ * Starts the Dart runtime/engine and calls `_nativeEntry` function in
+ * `background.service.dart` to run the actual backup logic.
+ * Called by Android WorkManager when all constraints for the work are met,
+ * i.e. battery is not low and optionally Wifi and charging are active.
+ */
+class BackupWorker(ctx: Context, params: WorkerParameters) : ListenableWorker(ctx, params),
+  MethodChannel.MethodCallHandler {
+
+  private val resolvableFuture = ResolvableFuture.create<Result>()
+  private var engine: FlutterEngine? = null
+  private lateinit var backgroundChannel: MethodChannel
+  private val notificationManager =
+    ctx.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+  private val isIgnoringBatteryOptimizations = isIgnoringBatteryOptimizations(applicationContext)
+  private var timeBackupStarted: Long = 0L
+  private var notificationBuilder: NotificationCompat.Builder? = null
+  private var notificationDetailBuilder: NotificationCompat.Builder? = null
+  private var fgFuture: ListenableFuture<Void>? = null
+
+  override fun startWork(): ListenableFuture<ListenableWorker.Result> {
+
+    Log.d(TAG, "startWork")
+
+    val ctx = applicationContext
+
+    if (!flutterLoader.initialized()) {
+      flutterLoader.startInitialization(ctx)
+    }
+
+    // Create a Notification channel
+    createChannel()
+
+    Log.d(TAG, "isIgnoringBatteryOptimizations $isIgnoringBatteryOptimizations")
+    if (isIgnoringBatteryOptimizations) {
+      // normal background services can only up to 10 minutes
+      // foreground services are allowed to run indefinitely
+      // requires battery optimizations to be disabled (either manually by the user
+      // or by the system learning that immich is important to the user)
+      val title = ctx.getSharedPreferences(SHARED_PREF_NAME, Context.MODE_PRIVATE)
+        .getString(SHARED_PREF_NOTIFICATION_TITLE, NOTIFICATION_DEFAULT_TITLE)!!
+      showInfo(getInfoBuilder(title, indeterminate = true).build())
+    }
+
+    engine = FlutterEngine(ctx)
+
+    flutterLoader.ensureInitializationCompleteAsync(ctx, null, Handler(Looper.getMainLooper())) {
+      runDart()
+
+    }
+
+    return resolvableFuture
+  }
+
+  /**
+   * Starts the Dart runtime/engine and calls `_nativeEntry` function in
+   * `background.service.dart` to run the actual backup logic.
+   */
+  private fun runDart() {
+    val callbackDispatcherHandle = applicationContext.getSharedPreferences(
+      SHARED_PREF_NAME, Context.MODE_PRIVATE
+    ).getLong(SHARED_PREF_CALLBACK_KEY, 0L)
+    val callbackInformation =
+      FlutterCallbackInformation.lookupCallbackInformation(callbackDispatcherHandle)
+    val appBundlePath = flutterLoader.findAppBundlePath()
+
+    engine?.let { engine ->
+      backgroundChannel = MethodChannel(engine.dartExecutor, "immich/backgroundChannel")
+      backgroundChannel.setMethodCallHandler(this@BackupWorker)
+      engine.dartExecutor.executeDartCallback(
+        DartExecutor.DartCallback(
+          applicationContext.assets,
+          appBundlePath,
+          callbackInformation
+        )
+      )
+    }
+  }
+
+  override fun onStopped() {
+    Log.d(TAG, "onStopped")
+    // called when the system has to stop this worker because constraints are
+    // no longer met or the system needs resources for more important tasks
+    Handler(Looper.getMainLooper()).postAtFrontOfQueue {
+      if (::backgroundChannel.isInitialized) {
+        backgroundChannel.invokeMethod("systemStop", null)
+      }
+    }
+    waitOnSetForegroundAsync()
+    // cannot await/get(block) on resolvableFuture as its already cancelled (would throw CancellationException)
+    // instead, wait for 5 seconds until forcefully stopping backup work
+    Handler(Looper.getMainLooper()).postDelayed({
+      stopEngine(null)
+    }, 5000)
+  }
+
+  private fun waitOnSetForegroundAsync() {
+    val fgFuture = this.fgFuture
+    if (fgFuture != null && !fgFuture.isCancelled && !fgFuture.isDone) {
+      try {
+        fgFuture.get(500, TimeUnit.MILLISECONDS)
+      } catch (e: Exception) {
+        // ignored, there is nothing to be done
+      }
+    }
+  }
+
+  private fun stopEngine(result: Result?) {
+    clearBackgroundNotification()
+    engine?.destroy()
+    engine = null
+    if (result != null) {
+      Log.d(TAG, "stopEngine result=${result}")
+      resolvableFuture.set(result)
+    }
+    waitOnSetForegroundAsync()
+  }
+
+  @RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
+  override fun onMethodCall(call: MethodCall, r: MethodChannel.Result) {
+    when (call.method) {
+      "initialized" -> {
+        timeBackupStarted = SystemClock.uptimeMillis()
+        backgroundChannel.invokeMethod(
+          "onAssetsChanged",
+          null,
+          object : MethodChannel.Result {
+            override fun notImplemented() {
+              stopEngine(Result.failure())
+            }
+
+            override fun error(errorCode: String, errorMessage: String?, errorDetails: Any?) {
+              stopEngine(Result.failure())
+            }
+
+            override fun success(receivedResult: Any?) {
+              val success = receivedResult as Boolean
+              stopEngine(if (success) Result.success() else Result.retry())
+            }
+          }
+        )
+      }
+
+      "updateNotification" -> {
+        val args = call.arguments<ArrayList<*>>()!!
+        val title = args[0] as String?
+        val content = args[1] as String?
+        val progress = args[2] as Int
+        val max = args[3] as Int
+        val indeterminate = args[4] as Boolean
+        val isDetail = args[5] as Boolean
+        val onlyIfFG = args[6] as Boolean
+        if (!onlyIfFG || isIgnoringBatteryOptimizations) {
+          showInfo(
+            getInfoBuilder(title, content, isDetail, progress, max, indeterminate).build(),
+            isDetail
+          )
+        }
+      }
+
+      "showError" -> {
+        val args = call.arguments<ArrayList<*>>()!!
+        val title = args[0] as String
+        val content = args[1] as String?
+        val individualTag = args[2] as String?
+        showError(title, content, individualTag)
+      }
+
+      "clearErrorNotifications" -> clearErrorNotifications()
+      "hasContentChanged" -> {
+        val lastChange = applicationContext
+          .getSharedPreferences(SHARED_PREF_NAME, Context.MODE_PRIVATE)
+          .getLong(SHARED_PREF_LAST_CHANGE, timeBackupStarted)
+        val hasContentChanged = lastChange > timeBackupStarted;
+        timeBackupStarted = SystemClock.uptimeMillis()
+        r.success(hasContentChanged)
+      }
+
+      else -> r.notImplemented()
+    }
+  }
+
+  private fun showError(title: String, content: String?, individualTag: String?) {
+    val notification = NotificationCompat.Builder(applicationContext, NOTIFICATION_CHANNEL_ERROR_ID)
+      .setContentTitle(title)
+      .setTicker(title)
+      .setContentText(content)
+      .setSmallIcon(R.drawable.notification_icon)
+      .build()
+    notificationManager.notify(individualTag, NOTIFICATION_ERROR_ID, notification)
+  }
+
+  private fun clearErrorNotifications() {
+    notificationManager.cancel(NOTIFICATION_ERROR_ID)
+  }
+
+  private fun clearBackgroundNotification() {
+    notificationManager.cancel(NOTIFICATION_ID)
+    notificationManager.cancel(NOTIFICATION_DETAIL_ID)
+  }
+
+  private fun showInfo(notification: Notification, isDetail: Boolean = false) {
+    val id = if (isDetail) NOTIFICATION_DETAIL_ID else NOTIFICATION_ID
+
+    if (isIgnoringBatteryOptimizations && !isDetail) {
+      fgFuture = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+        setForegroundAsync(ForegroundInfo(id, notification, FOREGROUND_SERVICE_TYPE_SHORT_SERVICE))
+      } else {
+        setForegroundAsync(ForegroundInfo(id, notification))
+      }
+    } else {
+      notificationManager.notify(id, notification)
+    }
+  }
+
+  private fun getInfoBuilder(
+    title: String? = null,
+    content: String? = null,
+    isDetail: Boolean = false,
+    progress: Int = 0,
+    max: Int = 0,
+    indeterminate: Boolean = false,
+  ): NotificationCompat.Builder {
+    var builder = if (isDetail) notificationDetailBuilder else notificationBuilder
+    if (builder == null) {
+      builder = NotificationCompat.Builder(applicationContext, NOTIFICATION_CHANNEL_ID)
+        .setSmallIcon(R.drawable.notification_icon)
+        .setOnlyAlertOnce(true)
+        .setOngoing(true)
+      if (isDetail) {
+        notificationDetailBuilder = builder
+      } else {
+        notificationBuilder = builder
+      }
+    }
+    if (title != null) {
+      builder.setTicker(title).setContentTitle(title)
+    }
+    if (content != null) {
+      builder.setContentText(content)
+    }
+    return builder.setProgress(max, progress, indeterminate)
+  }
+
+  private fun createChannel() {
+    val foreground = NotificationChannel(
+      NOTIFICATION_CHANNEL_ID,
+      NOTIFICATION_CHANNEL_ID,
+      NotificationManager.IMPORTANCE_LOW
+    )
+    notificationManager.createNotificationChannel(foreground)
+    val error = NotificationChannel(
+      NOTIFICATION_CHANNEL_ERROR_ID,
+      NOTIFICATION_CHANNEL_ERROR_ID,
+      NotificationManager.IMPORTANCE_HIGH
+    )
+    notificationManager.createNotificationChannel(error)
+  }
+
+  companion object {
+    const val SHARED_PREF_NAME = "immichBackgroundService"
+    const val SHARED_PREF_CALLBACK_KEY = "callbackDispatcherHandle"
+    const val SHARED_PREF_NOTIFICATION_TITLE = "notificationTitle"
+    const val SHARED_PREF_LAST_CHANGE = "lastChange"
+
+    private const val TASK_NAME_BACKUP = "immich/BackupWorker"
+    private const val NOTIFICATION_CHANNEL_ID = "immich/backgroundService"
+    private const val NOTIFICATION_CHANNEL_ERROR_ID = "immich/backgroundServiceError"
+    private const val NOTIFICATION_DEFAULT_TITLE = "Immich"
+    private const val NOTIFICATION_ID = 1
+    private const val NOTIFICATION_ERROR_ID = 2
+    private const val NOTIFICATION_DETAIL_ID = 3
+    private const val ONE_MINUTE = 60000L
+
+    /**
+     * Enqueues the BackupWorker to run once the constraints are met
+     */
+    fun enqueueBackupWorker(
+      context: Context,
+      requireWifi: Boolean = false,
+      requireCharging: Boolean = false,
+      delayMilliseconds: Long = 0L
+    ) {
+      val workRequest = buildWorkRequest(requireWifi, requireCharging, delayMilliseconds)
+      WorkManager.getInstance(context)
+        .enqueueUniqueWork(TASK_NAME_BACKUP, ExistingWorkPolicy.KEEP, workRequest)
+      Log.d(TAG, "enqueueBackupWorker: BackupWorker enqueued")
+    }
+
+    /**
+     * Updates the constraints of an already enqueued BackupWorker
+     */
+    fun updateBackupWorker(
+      context: Context,
+      requireWifi: Boolean = false,
+      requireCharging: Boolean = false
+    ) {
+      try {
+        val wm = WorkManager.getInstance(context)
+        val workInfoFuture = wm.getWorkInfosForUniqueWork(TASK_NAME_BACKUP)
+        val workInfoList = workInfoFuture.get(1000, TimeUnit.MILLISECONDS)
+        if (workInfoList != null) {
+          for (workInfo in workInfoList) {
+            if (workInfo.state == WorkInfo.State.ENQUEUED) {
+              val workRequest = buildWorkRequest(requireWifi, requireCharging)
+              wm.enqueueUniqueWork(TASK_NAME_BACKUP, ExistingWorkPolicy.REPLACE, workRequest)
+              Log.d(TAG, "updateBackupWorker updated BackupWorker constraints")
+              return
+            }
+          }
+        }
+        Log.d(TAG, "updateBackupWorker: BackupWorker not enqueued")
+      } catch (e: Exception) {
+        Log.d(TAG, "updateBackupWorker failed: $e")
+      }
+    }
+
+    /**
+     * Stops the currently running worker (if any) and removes it from the work queue
+     */
+    fun stopWork(context: Context) {
+      WorkManager.getInstance(context).cancelUniqueWork(TASK_NAME_BACKUP)
+      Log.d(TAG, "stopWork: BackupWorker cancelled")
+    }
+
+    /**
+     * Returns `true` if the app is ignoring battery optimizations
+     */
+    fun isIgnoringBatteryOptimizations(ctx: Context): Boolean {
+      val powerManager = ctx.getSystemService(Context.POWER_SERVICE) as PowerManager
+      return powerManager.isIgnoringBatteryOptimizations(ctx.packageName)
+    }
+
+    private fun buildWorkRequest(
+      requireWifi: Boolean = false,
+      requireCharging: Boolean = false,
+      delayMilliseconds: Long = 0L
+    ): OneTimeWorkRequest {
+      val constraints = Constraints.Builder()
+        .setRequiredNetworkType(if (requireWifi) NetworkType.UNMETERED else NetworkType.CONNECTED)
+        .setRequiresBatteryNotLow(true)
+        .setRequiresCharging(requireCharging)
+        .build();
+
+      val work = OneTimeWorkRequest.Builder(BackupWorker::class.java)
+        .setConstraints(constraints)
+        .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, ONE_MINUTE, TimeUnit.MILLISECONDS)
+        .setInitialDelay(delayMilliseconds, TimeUnit.MILLISECONDS)
+        .build()
+      return work
+    }
+
+    private val flutterLoader = FlutterLoader()
+  }
+}
+
+private const val TAG = "BackupWorker"

mobile/android/app/src/main/kotlin/app/alextran/immich/ContentObserverWorker.kt

@@ -0,0 +1,144 @@
+package app.alextran.immich
+
+import android.content.Context
+import android.os.SystemClock
+import android.provider.MediaStore
+import android.util.Log
+import androidx.work.Constraints
+import androidx.work.Worker
+import androidx.work.WorkerParameters
+import androidx.work.ExistingWorkPolicy
+import androidx.work.OneTimeWorkRequest
+import androidx.work.WorkManager
+import androidx.work.Operation
+import java.util.concurrent.TimeUnit
+
+/**
+ * Worker executed by Android WorkManager observing content changes (new photos/videos)
+ *
+ * Immediately enqueues the BackupWorker when running.
+ * As this work is not triggered periodically, but on content change, the
+ * worker enqueues itself again after each run.
+ */
+class ContentObserverWorker(ctx: Context, params: WorkerParameters) : Worker(ctx, params) {
+
+    override fun doWork(): Result {
+        if (!isEnabled(applicationContext)) {
+            return Result.failure()
+        }
+        if (triggeredContentUris.size > 0) {
+            startBackupWorker(applicationContext, delayMilliseconds = 0)
+        }
+        enqueueObserverWorker(applicationContext, ExistingWorkPolicy.REPLACE)
+        return Result.success()
+    }
+
+    companion object {
+        const val SHARED_PREF_SERVICE_ENABLED = "serviceEnabled"
+        private const val SHARED_PREF_REQUIRE_WIFI = "requireWifi"
+        private const val SHARED_PREF_REQUIRE_CHARGING = "requireCharging"
+        private const val SHARED_PREF_TRIGGER_UPDATE_DELAY = "triggerUpdateDelay"
+        private const val SHARED_PREF_TRIGGER_MAX_DELAY = "triggerMaxDelay"
+
+        private const val TASK_NAME_OBSERVER = "immich/ContentObserver"
+
+        /**
+         * Enqueues the `ContentObserverWorker`.
+         *
+         * @param context Android Context
+         */
+        fun enable(context: Context, immediate: Boolean = false) {
+            enqueueObserverWorker(context, ExistingWorkPolicy.KEEP)
+            Log.d(TAG, "enabled ContentObserverWorker")
+            if (immediate) {
+                startBackupWorker(context, delayMilliseconds = 5000)
+            }
+        }
+
+        /**
+         * Configures the `BackupWorker` to run when all constraints are met.
+         *
+         * @param context Android Context
+         * @param requireWifi if true, task only runs if connected to wifi
+         * @param requireCharging if true, task only runs if device is charging
+         */
+        fun configureWork(context: Context,
+                          requireWifi: Boolean = false,
+                          requireCharging: Boolean = false,
+                          triggerUpdateDelay: Long = 5000,
+                          triggerMaxDelay: Long = 50000) {
+            context.getSharedPreferences(BackupWorker.SHARED_PREF_NAME, Context.MODE_PRIVATE)
+                .edit()
+                .putBoolean(SHARED_PREF_SERVICE_ENABLED, true)
+                .putBoolean(SHARED_PREF_REQUIRE_WIFI, requireWifi)
+                .putBoolean(SHARED_PREF_REQUIRE_CHARGING, requireCharging)
+                .putLong(SHARED_PREF_TRIGGER_UPDATE_DELAY, triggerUpdateDelay)
+                .putLong(SHARED_PREF_TRIGGER_MAX_DELAY, triggerMaxDelay)
+                .apply()
+            BackupWorker.updateBackupWorker(context, requireWifi, requireCharging)
+        }
+
+        /**
+         * Stops the currently running worker (if any) and removes it from the work queue
+         */
+        fun disable(context: Context) {
+            context.getSharedPreferences(BackupWorker.SHARED_PREF_NAME, Context.MODE_PRIVATE)
+                    .edit().putBoolean(SHARED_PREF_SERVICE_ENABLED, false).apply()
+            WorkManager.getInstance(context).cancelUniqueWork(TASK_NAME_OBSERVER)
+            Log.d(TAG, "disabled ContentObserverWorker")
+        }
+
+        /**
+         * Return true if the user has enabled the background backup service
+         */
+        fun isEnabled(ctx: Context): Boolean {
+            return ctx.getSharedPreferences(BackupWorker.SHARED_PREF_NAME, Context.MODE_PRIVATE)
+                    .getBoolean(SHARED_PREF_SERVICE_ENABLED, false)
+        }
+
+        /**
+         * Enqueue and replace the worker without the content trigger but with a short delay
+         */
+        fun workManagerAppClearedWorkaround(context: Context) {
+            val work = OneTimeWorkRequest.Builder(ContentObserverWorker::class.java)
+                .setInitialDelay(500, TimeUnit.MILLISECONDS)
+                .build()
+            WorkManager
+                .getInstance(context)
+                .enqueueUniqueWork(TASK_NAME_OBSERVER, ExistingWorkPolicy.REPLACE, work)
+                .result
+                .get()
+            Log.d(TAG, "workManagerAppClearedWorkaround")
+        }
+
+        private fun enqueueObserverWorker(context: Context, policy: ExistingWorkPolicy) {
+            val sp = context.getSharedPreferences(BackupWorker.SHARED_PREF_NAME, Context.MODE_PRIVATE)
+            val constraints = Constraints.Builder()
+                .addContentUriTrigger(MediaStore.Images.Media.INTERNAL_CONTENT_URI, true)
+                .addContentUriTrigger(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, true)
+                .addContentUriTrigger(MediaStore.Video.Media.INTERNAL_CONTENT_URI, true)
+                .addContentUriTrigger(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, true)
+                .setTriggerContentUpdateDelay(sp.getLong(SHARED_PREF_TRIGGER_UPDATE_DELAY, 5000), TimeUnit.MILLISECONDS)
+                .setTriggerContentMaxDelay(sp.getLong(SHARED_PREF_TRIGGER_MAX_DELAY, 50000), TimeUnit.MILLISECONDS)
+                .build()
+
+            val work = OneTimeWorkRequest.Builder(ContentObserverWorker::class.java)
+                .setConstraints(constraints)
+                .build()
+            WorkManager.getInstance(context).enqueueUniqueWork(TASK_NAME_OBSERVER, policy, work)
+        }
+
+        fun startBackupWorker(context: Context, delayMilliseconds: Long) {
+            val sp = context.getSharedPreferences(BackupWorker.SHARED_PREF_NAME, Context.MODE_PRIVATE)
+            if (!sp.getBoolean(SHARED_PREF_SERVICE_ENABLED, false))
+                return
+            val requireWifi = sp.getBoolean(SHARED_PREF_REQUIRE_WIFI, true)
+            val requireCharging = sp.getBoolean(SHARED_PREF_REQUIRE_CHARGING, false)
+            BackupWorker.enqueueBackupWorker(context, requireWifi, requireCharging, delayMilliseconds)
+            sp.edit().putLong(BackupWorker.SHARED_PREF_LAST_CHANGE, SystemClock.uptimeMillis()).apply()
+        }
+
+    }
+}
+
+private const val TAG = "ContentObserverWorker"

mobile/android/app/src/main/kotlin/app/alextran/immich/HttpSSLOptionsPlugin.kt

@@ -0,0 +1,153 @@
+package app.alextran.immich
+
+import android.annotation.SuppressLint
+import android.content.Context
+import app.alextran.immich.core.SSLConfig
+import io.flutter.embedding.engine.plugins.FlutterPlugin
+import io.flutter.plugin.common.BinaryMessenger
+import io.flutter.plugin.common.MethodCall
+import io.flutter.plugin.common.MethodChannel
+import java.io.ByteArrayInputStream
+import java.net.InetSocketAddress
+import java.net.Socket
+import java.security.KeyStore
+import java.security.cert.X509Certificate
+import javax.net.ssl.HostnameVerifier
+import javax.net.ssl.HttpsURLConnection
+import javax.net.ssl.KeyManager
+import javax.net.ssl.KeyManagerFactory
+import javax.net.ssl.SSLContext
+import javax.net.ssl.SSLEngine
+import javax.net.ssl.SSLSession
+import javax.net.ssl.TrustManager
+import javax.net.ssl.TrustManagerFactory
+import javax.net.ssl.X509ExtendedTrustManager
+
+/**
+ * Android plugin for Dart `HttpSSLOptions`
+ */
+class HttpSSLOptionsPlugin : FlutterPlugin, MethodChannel.MethodCallHandler {
+  private var methodChannel: MethodChannel? = null
+
+  override fun onAttachedToEngine(binding: FlutterPlugin.FlutterPluginBinding) {
+    onAttachedToEngine(binding.applicationContext, binding.binaryMessenger)
+  }
+
+  private fun onAttachedToEngine(ctx: Context, messenger: BinaryMessenger) {
+    methodChannel = MethodChannel(messenger, "immich/httpSSLOptions")
+    methodChannel?.setMethodCallHandler(this)
+  }
+
+  override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
+    onDetachedFromEngine()
+  }
+
+  private fun onDetachedFromEngine() {
+    methodChannel?.setMethodCallHandler(null)
+    methodChannel = null
+  }
+
+  override fun onMethodCall(call: MethodCall, result: MethodChannel.Result) {
+    try {
+      when (call.method) {
+        "apply" -> {
+          val args = call.arguments<ArrayList<*>>()!!
+          val allowSelfSigned = args[0] as Boolean
+          val serverHost = args[1] as? String
+          val clientCertHash = (args[2] as? ByteArray)
+
+          var tm: Array<TrustManager>? = null
+          if (allowSelfSigned) {
+            tm = arrayOf(AllowSelfSignedTrustManager(serverHost))
+          }
+
+          var km: Array<KeyManager>? = null
+          if (clientCertHash != null) {
+            val cert = ByteArrayInputStream(clientCertHash)
+            val password = (args[3] as String).toCharArray()
+            val keyStore = KeyStore.getInstance("PKCS12")
+            keyStore.load(cert, password)
+            val keyManagerFactory =
+              KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm())
+            keyManagerFactory.init(keyStore, null)
+            km = keyManagerFactory.keyManagers
+          }
+
+          // Update shared SSL config for OkHttp and other HTTP clients
+          SSLConfig.apply(km, tm, allowSelfSigned, serverHost, clientCertHash?.contentHashCode() ?: 0)
+
+          val sslContext = SSLContext.getInstance("TLS")
+          sslContext.init(km, tm, null)
+          HttpsURLConnection.setDefaultSSLSocketFactory(sslContext.socketFactory)
+
+          HttpsURLConnection.setDefaultHostnameVerifier(AllowSelfSignedHostnameVerifier(args[1] as? String))
+
+          result.success(true)
+        }
+
+        else -> result.notImplemented()
+      }
+    } catch (e: Throwable) {
+      result.error("error", e.message, null)
+    }
+  }
+
+  @SuppressLint("CustomX509TrustManager")
+  class AllowSelfSignedTrustManager(private val serverHost: String?) : X509ExtendedTrustManager() {
+    private val defaultTrustManager: X509ExtendedTrustManager = getDefaultTrustManager()
+
+    override fun checkClientTrusted(chain: Array<out X509Certificate>?, authType: String?) =
+      defaultTrustManager.checkClientTrusted(chain, authType)
+
+    override fun checkClientTrusted(
+      chain: Array<out X509Certificate>?, authType: String?, socket: Socket?
+    ) = defaultTrustManager.checkClientTrusted(chain, authType, socket)
+
+    override fun checkClientTrusted(
+      chain: Array<out X509Certificate>?, authType: String?, engine: SSLEngine?
+    ) = defaultTrustManager.checkClientTrusted(chain, authType, engine)
+
+    override fun checkServerTrusted(chain: Array<out X509Certificate>?, authType: String?) {
+      if (serverHost == null) return
+      defaultTrustManager.checkServerTrusted(chain, authType)
+    }
+
+    override fun checkServerTrusted(
+      chain: Array<out X509Certificate>?, authType: String?, socket: Socket?
+    ) {
+      if (serverHost == null) return
+      val socketAddress = socket?.remoteSocketAddress
+      if (socketAddress is InetSocketAddress && socketAddress.hostName == serverHost) return
+      defaultTrustManager.checkServerTrusted(chain, authType, socket)
+    }
+
+    override fun checkServerTrusted(
+      chain: Array<out X509Certificate>?, authType: String?, engine: SSLEngine?
+    ) {
+      if (serverHost == null || engine?.peerHost == serverHost) return
+      defaultTrustManager.checkServerTrusted(chain, authType, engine)
+    }
+
+    override fun getAcceptedIssuers(): Array<X509Certificate> = defaultTrustManager.acceptedIssuers
+
+    private fun getDefaultTrustManager(): X509ExtendedTrustManager {
+      val factory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
+      factory.init(null as KeyStore?)
+      return factory.trustManagers.filterIsInstance<X509ExtendedTrustManager>().first()
+    }
+  }
+
+  class AllowSelfSignedHostnameVerifier(private val serverHost: String?) : HostnameVerifier {
+    companion object {
+      private val _defaultHostnameVerifier = HttpsURLConnection.getDefaultHostnameVerifier()
+    }
+
+    override fun verify(hostname: String?, session: SSLSession?): Boolean {
+      if (serverHost == null || hostname == serverHost) {
+        return true
+      } else {
+        return _defaultHostnameVerifier.verify(hostname, session)
+      }
+    }
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/ImmichApp.kt

@@ -0,0 +1,30 @@
+package app.alextran.immich
+
+import android.app.Application
+import android.os.Handler
+import android.os.Looper
+import androidx.work.Configuration
+import androidx.work.WorkManager
+import app.alextran.immich.background.BackgroundEngineLock
+import app.alextran.immich.background.BackgroundWorkerApiImpl
+
+class ImmichApp : Application() {
+  override fun onCreate() {
+    super.onCreate()
+    val config = Configuration.Builder().build()
+    WorkManager.initialize(this, config)
+    // always start BackupWorker after WorkManager init; this fixes the following bug:
+    // After the process is killed (by user or system), the first trigger (taking a new picture) is lost.
+    // Thus, the BackupWorker is not started. If the system kills the process after each initialization
+    // (because of low memory etc.), the backup is never performed.
+    // As a workaround, we also run a backup check when initializing the application
+
+    ContentObserverWorker.startBackupWorker(context = this, delayMilliseconds = 0)
+    Handler(Looper.getMainLooper()).postDelayed({
+      // We can only check the engine count and not the status of the lock here,
+      // as the previous start might have been killed without unlocking.
+      if (BackgroundEngineLock.connectEngines > 0) return@postDelayed
+      BackgroundWorkerApiImpl.enqueueBackgroundWorker(this)
+    }, 5000)
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/MainActivity.kt

@@ -0,0 +1,60 @@
+package app.alextran.immich
+
+import android.content.Context
+import android.os.Build
+import android.os.ext.SdkExtensions
+import app.alextran.immich.background.BackgroundEngineLock
+import app.alextran.immich.background.BackgroundWorkerApiImpl
+import app.alextran.immich.background.BackgroundWorkerFgHostApi
+import app.alextran.immich.background.BackgroundWorkerLockApi
+import app.alextran.immich.connectivity.ConnectivityApi
+import app.alextran.immich.connectivity.ConnectivityApiImpl
+import app.alextran.immich.core.ImmichPlugin
+import app.alextran.immich.images.LocalImageApi
+import app.alextran.immich.images.LocalImagesImpl
+import app.alextran.immich.images.RemoteImageApi
+import app.alextran.immich.images.RemoteImagesImpl
+import app.alextran.immich.sync.NativeSyncApi
+import app.alextran.immich.sync.NativeSyncApiImpl26
+import app.alextran.immich.sync.NativeSyncApiImpl30
+import io.flutter.embedding.android.FlutterFragmentActivity
+import io.flutter.embedding.engine.FlutterEngine
+
+class MainActivity : FlutterFragmentActivity() {
+  override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
+    super.configureFlutterEngine(flutterEngine)
+    registerPlugins(this, flutterEngine)
+  }
+
+  companion object {
+    fun registerPlugins(ctx: Context, flutterEngine: FlutterEngine) {
+      val messenger = flutterEngine.dartExecutor.binaryMessenger
+      val backgroundEngineLockImpl = BackgroundEngineLock(ctx)
+      BackgroundWorkerLockApi.setUp(messenger, backgroundEngineLockImpl)
+      val nativeSyncApiImpl =
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R || SdkExtensions.getExtensionVersion(Build.VERSION_CODES.R) < 1) {
+          NativeSyncApiImpl26(ctx)
+        } else {
+          NativeSyncApiImpl30(ctx)
+        }
+      NativeSyncApi.setUp(messenger, nativeSyncApiImpl)
+      LocalImageApi.setUp(messenger, LocalImagesImpl(ctx))
+      RemoteImageApi.setUp(messenger, RemoteImagesImpl(ctx))
+
+      BackgroundWorkerFgHostApi.setUp(messenger, BackgroundWorkerApiImpl(ctx))
+      ConnectivityApi.setUp(messenger, ConnectivityApiImpl(ctx))
+
+      flutterEngine.plugins.add(BackgroundServicePlugin())
+      flutterEngine.plugins.add(HttpSSLOptionsPlugin())
+      flutterEngine.plugins.add(backgroundEngineLockImpl)
+      flutterEngine.plugins.add(nativeSyncApiImpl)
+    }
+
+    fun cancelPlugins(flutterEngine: FlutterEngine) {
+      val nativeApi =
+        flutterEngine.plugins.get(NativeSyncApiImpl26::class.java) as ImmichPlugin?
+          ?: flutterEngine.plugins.get(NativeSyncApiImpl30::class.java) as ImmichPlugin?
+      nativeApi?.detachFromEngine()
+    }
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/NativeBuffer.kt

@@ -0,0 +1,52 @@
+package app.alextran.immich
+
+import java.nio.ByteBuffer
+
+const val INITIAL_BUFFER_SIZE = 32 * 1024
+
+object NativeBuffer {
+  init {
+    System.loadLibrary("native_buffer")
+  }
+
+  @JvmStatic
+  external fun allocate(size: Int): Long
+
+  @JvmStatic
+  external fun free(address: Long)
+
+  @JvmStatic
+  external fun realloc(address: Long, size: Int): Long
+
+  @JvmStatic
+  external fun wrap(address: Long, capacity: Int): ByteBuffer
+
+  @JvmStatic
+  external fun copy(buffer: ByteBuffer, destAddress: Long, offset: Int, length: Int)
+}
+
+class NativeByteBuffer(initialCapacity: Int) {
+  var pointer = NativeBuffer.allocate(initialCapacity)
+  var capacity = initialCapacity
+  var offset = 0
+
+  inline fun ensureHeadroom() {
+    if (offset == capacity) {
+      capacity *= 2
+      pointer = NativeBuffer.realloc(pointer, capacity)
+    }
+  }
+
+  inline fun wrapRemaining() = NativeBuffer.wrap(pointer + offset, capacity - offset)
+
+  inline fun advance(bytesRead: Int) {
+    offset += bytesRead
+  }
+
+  inline fun free() {
+    if (pointer != 0L) {
+      NativeBuffer.free(pointer)
+      pointer = 0L
+    }
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundEngineLock.kt

@@ -0,0 +1,56 @@
+package app.alextran.immich.background
+
+import android.content.Context
+import android.util.Log
+import app.alextran.immich.core.ImmichPlugin
+import io.flutter.embedding.engine.plugins.FlutterPlugin
+import java.util.concurrent.atomic.AtomicInteger
+
+private const val TAG = "BackgroundEngineLock"
+
+class BackgroundEngineLock(context: Context) : BackgroundWorkerLockApi, ImmichPlugin() {
+  private val ctx: Context = context.applicationContext
+
+  companion object {
+
+    private var engineCount = AtomicInteger(0)
+
+    val connectEngines: Int
+      get() = engineCount.get()
+
+    private fun checkAndEnforceBackgroundLock(ctx: Context) {
+      // work manager task is running while the main app is opened, cancel the worker
+      if (BackgroundWorkerPreferences(ctx).isLocked() &&
+        connectEngines > 1 &&
+        BackgroundWorkerApiImpl.isBackgroundWorkerRunning()
+      ) {
+        Log.i(TAG, "Background worker is locked, cancelling the background worker")
+        BackgroundWorkerApiImpl.cancelBackgroundWorker(ctx)
+      }
+    }
+  }
+
+  override fun lock() {
+    BackgroundWorkerPreferences(ctx).setLocked(true)
+    checkAndEnforceBackgroundLock(ctx)
+    Log.i(TAG, "Background worker is locked")
+  }
+
+  override fun unlock() {
+    BackgroundWorkerPreferences(ctx).setLocked(false)
+    Log.i(TAG, "Background worker is unlocked")
+  }
+
+  override fun onAttachedToEngine(binding: FlutterPlugin.FlutterPluginBinding) {
+    super.onAttachedToEngine(binding)
+    checkAndEnforceBackgroundLock(binding.applicationContext)
+    engineCount.incrementAndGet()
+    Log.i(TAG, "Flutter engine attached. Attached Engines count: $engineCount")
+  }
+
+  override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
+    super.onDetachedFromEngine(binding)
+    engineCount.decrementAndGet()
+    Log.i(TAG, "Flutter engine detached. Attached Engines count: $engineCount")
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorker.g.kt

@@ -0,0 +1,332 @@
+// Autogenerated from Pigeon (v26.0.2), do not edit directly.
+// See also: https://pub.dev/packages/pigeon
+@file:Suppress("UNCHECKED_CAST", "ArrayInDataClass")
+
+package app.alextran.immich.background
+
+import android.util.Log
+import io.flutter.plugin.common.BasicMessageChannel
+import io.flutter.plugin.common.BinaryMessenger
+import io.flutter.plugin.common.EventChannel
+import io.flutter.plugin.common.MessageCodec
+import io.flutter.plugin.common.StandardMethodCodec
+import io.flutter.plugin.common.StandardMessageCodec
+import java.io.ByteArrayOutputStream
+import java.nio.ByteBuffer
+private object BackgroundWorkerPigeonUtils {
+
+  fun createConnectionError(channelName: String): FlutterError {
+    return FlutterError("channel-error",  "Unable to establish connection on channel: '$channelName'.", "")  }
+
+  fun wrapResult(result: Any?): List<Any?> {
+    return listOf(result)
+  }
+
+  fun wrapError(exception: Throwable): List<Any?> {
+    return if (exception is FlutterError) {
+      listOf(
+        exception.code,
+        exception.message,
+        exception.details
+      )
+    } else {
+      listOf(
+        exception.javaClass.simpleName,
+        exception.toString(),
+        "Cause: " + exception.cause + ", Stacktrace: " + Log.getStackTraceString(exception)
+      )
+    }
+  }
+  fun deepEquals(a: Any?, b: Any?): Boolean {
+    if (a is ByteArray && b is ByteArray) {
+        return a.contentEquals(b)
+    }
+    if (a is IntArray && b is IntArray) {
+        return a.contentEquals(b)
+    }
+    if (a is LongArray && b is LongArray) {
+        return a.contentEquals(b)
+    }
+    if (a is DoubleArray && b is DoubleArray) {
+        return a.contentEquals(b)
+    }
+    if (a is Array<*> && b is Array<*>) {
+      return a.size == b.size &&
+          a.indices.all{ deepEquals(a[it], b[it]) }
+    }
+    if (a is List<*> && b is List<*>) {
+      return a.size == b.size &&
+          a.indices.all{ deepEquals(a[it], b[it]) }
+    }
+    if (a is Map<*, *> && b is Map<*, *>) {
+      return a.size == b.size && a.all {
+          (b as Map<Any?, Any?>).containsKey(it.key) &&
+          deepEquals(it.value, b[it.key])
+      }
+    }
+    return a == b
+  }
+      
+}
+
+/**
+ * Error class for passing custom error details to Flutter via a thrown PlatformException.
+ * @property code The error code.
+ * @property message The error message.
+ * @property details The error details. Must be a datatype supported by the api codec.
+ */
+class FlutterError (
+  val code: String,
+  override val message: String? = null,
+  val details: Any? = null
+) : Throwable()
+
+/** Generated class from Pigeon that represents data sent in messages. */
+data class BackgroundWorkerSettings (
+  val requiresCharging: Boolean,
+  val minimumDelaySeconds: Long
+)
+ {
+  companion object {
+    fun fromList(pigeonVar_list: List<Any?>): BackgroundWorkerSettings {
+      val requiresCharging = pigeonVar_list[0] as Boolean
+      val minimumDelaySeconds = pigeonVar_list[1] as Long
+      return BackgroundWorkerSettings(requiresCharging, minimumDelaySeconds)
+    }
+  }
+  fun toList(): List<Any?> {
+    return listOf(
+      requiresCharging,
+      minimumDelaySeconds,
+    )
+  }
+  override fun equals(other: Any?): Boolean {
+    if (other !is BackgroundWorkerSettings) {
+      return false
+    }
+    if (this === other) {
+      return true
+    }
+    return BackgroundWorkerPigeonUtils.deepEquals(toList(), other.toList())  }
+
+  override fun hashCode(): Int = toList().hashCode()
+}
+private open class BackgroundWorkerPigeonCodec : StandardMessageCodec() {
+  override fun readValueOfType(type: Byte, buffer: ByteBuffer): Any? {
+    return when (type) {
+      129.toByte() -> {
+        return (readValue(buffer) as? List<Any?>)?.let {
+          BackgroundWorkerSettings.fromList(it)
+        }
+      }
+      else -> super.readValueOfType(type, buffer)
+    }
+  }
+  override fun writeValue(stream: ByteArrayOutputStream, value: Any?)   {
+    when (value) {
+      is BackgroundWorkerSettings -> {
+        stream.write(129)
+        writeValue(stream, value.toList())
+      }
+      else -> super.writeValue(stream, value)
+    }
+  }
+}
+
+/** Generated interface from Pigeon that represents a handler of messages from Flutter. */
+interface BackgroundWorkerFgHostApi {
+  fun enable()
+  fun saveNotificationMessage(title: String, body: String)
+  fun configure(settings: BackgroundWorkerSettings)
+  fun disable()
+
+  companion object {
+    /** The codec used by BackgroundWorkerFgHostApi. */
+    val codec: MessageCodec<Any?> by lazy {
+      BackgroundWorkerPigeonCodec()
+    }
+    /** Sets up an instance of `BackgroundWorkerFgHostApi` to handle messages through the `binaryMessenger`. */
+    @JvmOverloads
+    fun setUp(binaryMessenger: BinaryMessenger, api: BackgroundWorkerFgHostApi?, messageChannelSuffix: String = "") {
+      val separatedMessageChannelSuffix = if (messageChannelSuffix.isNotEmpty()) ".$messageChannelSuffix" else ""
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.BackgroundWorkerFgHostApi.enable$separatedMessageChannelSuffix", codec)
+        if (api != null) {
+          channel.setMessageHandler { _, reply ->
+            val wrapped: List<Any?> = try {
+              api.enable()
+              listOf(null)
+            } catch (exception: Throwable) {
+              BackgroundWorkerPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.BackgroundWorkerFgHostApi.saveNotificationMessage$separatedMessageChannelSuffix", codec)
+        if (api != null) {
+          channel.setMessageHandler { message, reply ->
+            val args = message as List<Any?>
+            val titleArg = args[0] as String
+            val bodyArg = args[1] as String
+            val wrapped: List<Any?> = try {
+              api.saveNotificationMessage(titleArg, bodyArg)
+              listOf(null)
+            } catch (exception: Throwable) {
+              BackgroundWorkerPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.BackgroundWorkerFgHostApi.configure$separatedMessageChannelSuffix", codec)
+        if (api != null) {
+          channel.setMessageHandler { message, reply ->
+            val args = message as List<Any?>
+            val settingsArg = args[0] as BackgroundWorkerSettings
+            val wrapped: List<Any?> = try {
+              api.configure(settingsArg)
+              listOf(null)
+            } catch (exception: Throwable) {
+              BackgroundWorkerPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.BackgroundWorkerFgHostApi.disable$separatedMessageChannelSuffix", codec)
+        if (api != null) {
+          channel.setMessageHandler { _, reply ->
+            val wrapped: List<Any?> = try {
+              api.disable()
+              listOf(null)
+            } catch (exception: Throwable) {
+              BackgroundWorkerPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+    }
+  }
+}
+/** Generated interface from Pigeon that represents a handler of messages from Flutter. */
+interface BackgroundWorkerBgHostApi {
+  fun onInitialized()
+  fun close()
+
+  companion object {
+    /** The codec used by BackgroundWorkerBgHostApi. */
+    val codec: MessageCodec<Any?> by lazy {
+      BackgroundWorkerPigeonCodec()
+    }
+    /** Sets up an instance of `BackgroundWorkerBgHostApi` to handle messages through the `binaryMessenger`. */
+    @JvmOverloads
+    fun setUp(binaryMessenger: BinaryMessenger, api: BackgroundWorkerBgHostApi?, messageChannelSuffix: String = "") {
+      val separatedMessageChannelSuffix = if (messageChannelSuffix.isNotEmpty()) ".$messageChannelSuffix" else ""
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.BackgroundWorkerBgHostApi.onInitialized$separatedMessageChannelSuffix", codec)
+        if (api != null) {
+          channel.setMessageHandler { _, reply ->
+            val wrapped: List<Any?> = try {
+              api.onInitialized()
+              listOf(null)
+            } catch (exception: Throwable) {
+              BackgroundWorkerPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.BackgroundWorkerBgHostApi.close$separatedMessageChannelSuffix", codec)
+        if (api != null) {
+          channel.setMessageHandler { _, reply ->
+            val wrapped: List<Any?> = try {
+              api.close()
+              listOf(null)
+            } catch (exception: Throwable) {
+              BackgroundWorkerPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+    }
+  }
+}
+/** Generated class from Pigeon that represents Flutter messages that can be called from Kotlin. */
+class BackgroundWorkerFlutterApi(private val binaryMessenger: BinaryMessenger, private val messageChannelSuffix: String = "") {
+  companion object {
+    /** The codec used by BackgroundWorkerFlutterApi. */
+    val codec: MessageCodec<Any?> by lazy {
+      BackgroundWorkerPigeonCodec()
+    }
+  }
+  fun onIosUpload(isRefreshArg: Boolean, maxSecondsArg: Long?, callback: (Result<Unit>) -> Unit)
+{
+    val separatedMessageChannelSuffix = if (messageChannelSuffix.isNotEmpty()) ".$messageChannelSuffix" else ""
+    val channelName = "dev.flutter.pigeon.immich_mobile.BackgroundWorkerFlutterApi.onIosUpload$separatedMessageChannelSuffix"
+    val channel = BasicMessageChannel<Any?>(binaryMessenger, channelName, codec)
+    channel.send(listOf(isRefreshArg, maxSecondsArg)) {
+      if (it is List<*>) {
+        if (it.size > 1) {
+          callback(Result.failure(FlutterError(it[0] as String, it[1] as String, it[2] as String?)))
+        } else {
+          callback(Result.success(Unit))
+        }
+      } else {
+        callback(Result.failure(BackgroundWorkerPigeonUtils.createConnectionError(channelName)))
+      } 
+    }
+  }
+  fun onAndroidUpload(callback: (Result<Unit>) -> Unit)
+{
+    val separatedMessageChannelSuffix = if (messageChannelSuffix.isNotEmpty()) ".$messageChannelSuffix" else ""
+    val channelName = "dev.flutter.pigeon.immich_mobile.BackgroundWorkerFlutterApi.onAndroidUpload$separatedMessageChannelSuffix"
+    val channel = BasicMessageChannel<Any?>(binaryMessenger, channelName, codec)
+    channel.send(null) {
+      if (it is List<*>) {
+        if (it.size > 1) {
+          callback(Result.failure(FlutterError(it[0] as String, it[1] as String, it[2] as String?)))
+        } else {
+          callback(Result.success(Unit))
+        }
+      } else {
+        callback(Result.failure(BackgroundWorkerPigeonUtils.createConnectionError(channelName)))
+      } 
+    }
+  }
+  fun cancel(callback: (Result<Unit>) -> Unit)
+{
+    val separatedMessageChannelSuffix = if (messageChannelSuffix.isNotEmpty()) ".$messageChannelSuffix" else ""
+    val channelName = "dev.flutter.pigeon.immich_mobile.BackgroundWorkerFlutterApi.cancel$separatedMessageChannelSuffix"
+    val channel = BasicMessageChannel<Any?>(binaryMessenger, channelName, codec)
+    channel.send(null) {
+      if (it is List<*>) {
+        if (it.size > 1) {
+          callback(Result.failure(FlutterError(it[0] as String, it[1] as String, it[2] as String?)))
+        } else {
+          callback(Result.success(Unit))
+        }
+      } else {
+        callback(Result.failure(BackgroundWorkerPigeonUtils.createConnectionError(channelName)))
+      } 
+    }
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorker.kt

@@ -0,0 +1,228 @@
+package app.alextran.immich.background
+
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.content.Context
+import android.content.pm.ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.os.PowerManager
+import android.util.Log
+import androidx.core.app.NotificationCompat
+import androidx.work.ForegroundInfo
+import androidx.work.ListenableWorker
+import androidx.work.WorkerParameters
+import app.alextran.immich.MainActivity
+import app.alextran.immich.R
+import com.google.common.util.concurrent.ListenableFuture
+import com.google.common.util.concurrent.SettableFuture
+import io.flutter.FlutterInjector
+import io.flutter.embedding.engine.FlutterEngine
+import io.flutter.embedding.engine.FlutterEngineCache
+import io.flutter.embedding.engine.dart.DartExecutor
+import io.flutter.embedding.engine.loader.FlutterLoader
+import java.util.concurrent.TimeUnit
+
+private const val TAG = "BackgroundWorker"
+
+class BackgroundWorker(context: Context, params: WorkerParameters) :
+  ListenableWorker(context, params), BackgroundWorkerBgHostApi {
+  private val ctx: Context = context.applicationContext
+
+  /// The Flutter loader that loads the native Flutter library and resources.
+  /// This must be initialized before starting the Flutter engine.
+  private var loader: FlutterLoader = FlutterInjector.instance().flutterLoader()
+
+  /// The Flutter engine created specifically for background execution.
+  /// This is a separate instance from the main Flutter engine that handles the UI.
+  /// It operates in its own isolate and doesn't share memory with the main engine.
+  /// Must be properly started, registered, and torn down during background execution.
+  private var engine: FlutterEngine? = null
+
+  // Used to call methods on the flutter side
+  private var flutterApi: BackgroundWorkerFlutterApi? = null
+
+  /// Result returned when the background task completes. This is used to signal
+  /// to the WorkManager that the task has finished, either successfully or with failure.
+  private val completionHandler: SettableFuture<Result> = SettableFuture.create()
+
+  /// Flag to track whether the background task has completed to prevent duplicate completions
+  private var isComplete = false
+
+  private val notificationManager =
+    ctx.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+  private var foregroundFuture: ListenableFuture<Void>? = null
+
+  companion object {
+    private const val NOTIFICATION_CHANNEL_ID = "immich::background_worker::notif"
+    private const val NOTIFICATION_ID = 100
+  }
+
+  override fun startWork(): ListenableFuture<Result> {
+    Log.i(TAG, "Starting background upload worker")
+
+    if (!loader.initialized()) {
+      loader.startInitialization(ctx)
+    }
+
+    val notificationChannel = NotificationChannel(
+      NOTIFICATION_CHANNEL_ID,
+      NOTIFICATION_CHANNEL_ID,
+      NotificationManager.IMPORTANCE_LOW
+    )
+    notificationManager.createNotificationChannel(notificationChannel)
+    val notificationConfig = BackgroundWorkerPreferences(ctx).getNotificationConfig()
+    showNotification(notificationConfig.first, notificationConfig.second)
+
+    loader.ensureInitializationCompleteAsync(ctx, null, Handler(Looper.getMainLooper())) {
+      engine = FlutterEngine(ctx)
+      FlutterEngineCache.getInstance().put(BackgroundWorkerApiImpl.ENGINE_CACHE_KEY, engine!!)
+
+      // Register custom plugins
+      MainActivity.registerPlugins(ctx, engine!!)
+      flutterApi =
+        BackgroundWorkerFlutterApi(binaryMessenger = engine!!.dartExecutor.binaryMessenger)
+      BackgroundWorkerBgHostApi.setUp(
+        binaryMessenger = engine!!.dartExecutor.binaryMessenger,
+        api = this
+      )
+
+      engine!!.dartExecutor.executeDartEntrypoint(
+        DartExecutor.DartEntrypoint(
+          loader.findAppBundlePath(),
+          "package:immich_mobile/domain/services/background_worker.service.dart",
+          "backgroundSyncNativeEntrypoint"
+        )
+      )
+    }
+
+    return completionHandler
+  }
+
+  /**
+   * Called by the Flutter side when it has finished initialization and is ready to receive commands.
+   * Routes the appropriate task type (refresh or processing) to the corresponding Flutter method.
+   * This method acts as a bridge between the native Android background task system and Flutter.
+   */
+  override fun onInitialized() {
+    flutterApi?.onAndroidUpload { handleHostResult(it) }
+  }
+
+  // TODO: Move this to a separate NotificationManager class
+  private fun showNotification(title: String, content: String) {
+    val notification = NotificationCompat.Builder(applicationContext, NOTIFICATION_CHANNEL_ID)
+      .setSmallIcon(R.drawable.notification_icon)
+      .setOnlyAlertOnce(true)
+      .setOngoing(true)
+      .setTicker(title)
+      .setContentTitle(title)
+      .setContentText(content)
+      .build()
+
+    if (isIgnoringBatteryOptimizations()) {
+      foregroundFuture = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+        setForegroundAsync(
+          ForegroundInfo(
+            NOTIFICATION_ID,
+            notification,
+            FOREGROUND_SERVICE_TYPE_DATA_SYNC
+          )
+        )
+      } else {
+        setForegroundAsync(ForegroundInfo(NOTIFICATION_ID, notification))
+      }
+    } else {
+      notificationManager.notify(NOTIFICATION_ID, notification)
+    }
+  }
+
+  override fun close() {
+    if (isComplete) {
+      return
+    }
+
+    Handler(Looper.getMainLooper()).postAtFrontOfQueue {
+      if (flutterApi != null) {
+        flutterApi?.cancel {
+          complete(Result.failure())
+        }
+      }
+    }
+
+    waitForForegroundPromotion()
+
+    Handler(Looper.getMainLooper()).postDelayed({
+      complete(Result.failure())
+    }, 5000)
+  }
+
+  /**
+   * Called when the system has to stop this worker because constraints are
+   * no longer met or the system needs resources for more important tasks
+   * This is also called when the worker has been explicitly cancelled or replaced
+   */
+  override fun onStopped() {
+    Log.d(TAG, "About to stop BackupWorker")
+    close()
+  }
+
+  private fun handleHostResult(result: kotlin.Result<Unit>) {
+    if (isComplete) {
+      return
+    }
+
+    result.fold(
+      onSuccess = { _ -> complete(Result.success()) },
+      onFailure = { _ -> onStopped() }
+    )
+  }
+
+  /**
+   * Cleans up resources by destroying the Flutter engine context and invokes the completion handler.
+   * This method ensures that the background task is marked as complete, releases the Flutter engine,
+   * and notifies the caller of the task's success or failure. This is the final step in the
+   * background task lifecycle and should only be called once per task instance.
+   *
+   * - Parameter success: Indicates whether the background task completed successfully
+   */
+  private fun complete(success: Result) {
+    Log.d(TAG, "About to complete BackupWorker with result: $success")
+    isComplete = true
+    if (engine != null) {
+      MainActivity.cancelPlugins(engine!!)
+    }
+    engine?.destroy()
+    engine = null
+    flutterApi = null
+    notificationManager.cancel(NOTIFICATION_ID)
+    FlutterEngineCache.getInstance().remove(BackgroundWorkerApiImpl.ENGINE_CACHE_KEY)
+    waitForForegroundPromotion()
+    completionHandler.set(success)
+  }
+
+  /**
+   * Returns `true` if the app is ignoring battery optimizations
+   */
+  private fun isIgnoringBatteryOptimizations(): Boolean {
+    val powerManager = ctx.getSystemService(Context.POWER_SERVICE) as PowerManager
+    return powerManager.isIgnoringBatteryOptimizations(ctx.packageName)
+  }
+
+  /**
+   *  Calls to setForegroundAsync() that do not complete before completion of a ListenableWorker will signal an IllegalStateException
+   * https://android-review.googlesource.com/c/platform/frameworks/support/+/1262743
+   * Wait for a short period of time for the foreground promotion to complete before completing the worker
+   */
+  private fun waitForForegroundPromotion() {
+    val foregroundFuture = this.foregroundFuture
+    if (foregroundFuture != null && !foregroundFuture.isCancelled && !foregroundFuture.isDone) {
+      try {
+        foregroundFuture.get(500, TimeUnit.MILLISECONDS)
+      } catch (e: Exception) {
+        // ignored, there is nothing to be done
+      }
+    }
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorkerApiImpl.kt

@@ -0,0 +1,96 @@
+package app.alextran.immich.background
+
+import android.content.Context
+import android.provider.MediaStore
+import android.util.Log
+import androidx.work.BackoffPolicy
+import androidx.work.Constraints
+import androidx.work.ExistingWorkPolicy
+import androidx.work.OneTimeWorkRequest
+import androidx.work.WorkManager
+import io.flutter.embedding.engine.FlutterEngineCache
+import java.util.concurrent.TimeUnit
+
+private const val TAG = "BackgroundWorkerApiImpl"
+
+class BackgroundWorkerApiImpl(context: Context) : BackgroundWorkerFgHostApi {
+  private val ctx: Context = context.applicationContext
+
+  override fun enable() {
+    enqueueMediaObserver(ctx)
+  }
+
+  override fun saveNotificationMessage(title: String, body: String) {
+    BackgroundWorkerPreferences(ctx).updateNotificationConfig(title, body)
+  }
+
+  override fun configure(settings: BackgroundWorkerSettings) {
+    BackgroundWorkerPreferences(ctx).updateSettings(settings)
+    enqueueMediaObserver(ctx)
+  }
+
+  override fun disable() {
+    WorkManager.getInstance(ctx).apply {
+      cancelUniqueWork(OBSERVER_WORKER_NAME)
+      cancelUniqueWork(BACKGROUND_WORKER_NAME)
+    }
+    Log.i(TAG, "Cancelled background upload tasks")
+  }
+
+  companion object {
+    private const val BACKGROUND_WORKER_NAME = "immich/BackgroundWorkerV1"
+    private const val OBSERVER_WORKER_NAME = "immich/MediaObserverV1"
+    const val ENGINE_CACHE_KEY = "immich::background_worker::engine"
+
+
+    fun enqueueMediaObserver(ctx: Context) {
+      val settings = BackgroundWorkerPreferences(ctx).getSettings()
+      val constraints = Constraints.Builder().apply {
+        addContentUriTrigger(MediaStore.Images.Media.INTERNAL_CONTENT_URI, true)
+        addContentUriTrigger(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, true)
+        addContentUriTrigger(MediaStore.Video.Media.INTERNAL_CONTENT_URI, true)
+        addContentUriTrigger(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, true)
+        setTriggerContentUpdateDelay(settings.minimumDelaySeconds, TimeUnit.SECONDS)
+        setTriggerContentMaxDelay(settings.minimumDelaySeconds * 10, TimeUnit.SECONDS)
+        setRequiresCharging(settings.requiresCharging)
+      }.build()
+
+      val work = OneTimeWorkRequest.Builder(MediaObserver::class.java)
+        .setConstraints(constraints)
+        .build()
+      WorkManager.getInstance(ctx)
+        .enqueueUniqueWork(OBSERVER_WORKER_NAME, ExistingWorkPolicy.REPLACE, work)
+
+      Log.i(
+        TAG,
+        "Enqueued media observer worker with name: $OBSERVER_WORKER_NAME and settings: $settings"
+      )
+    }
+
+    fun enqueueBackgroundWorker(ctx: Context) {
+      val constraints = Constraints.Builder().setRequiresBatteryNotLow(true).build()
+
+      val work = OneTimeWorkRequest.Builder(BackgroundWorker::class.java)
+        .setConstraints(constraints)
+        .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 1, TimeUnit.MINUTES)
+        .build()
+      WorkManager.getInstance(ctx)
+        .enqueueUniqueWork(BACKGROUND_WORKER_NAME, ExistingWorkPolicy.KEEP, work)
+
+      Log.i(TAG, "Enqueued background worker with name: $BACKGROUND_WORKER_NAME")
+    }
+
+    fun isBackgroundWorkerRunning(): Boolean {
+      // Easier to check if the engine is cached as we always cache the engine when starting the worker
+      // and remove it when the worker is finished
+      return FlutterEngineCache.getInstance().get(ENGINE_CACHE_KEY) != null
+    }
+
+    fun cancelBackgroundWorker(ctx: Context) {
+      WorkManager.getInstance(ctx).cancelUniqueWork(BACKGROUND_WORKER_NAME)
+      FlutterEngineCache.getInstance().remove(ENGINE_CACHE_KEY)
+
+      Log.i(TAG, "Cancelled background upload task")
+    }
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorkerLock.g.kt

@@ -0,0 +1,95 @@
+// Autogenerated from Pigeon (v26.0.2), do not edit directly.
+// See also: https://pub.dev/packages/pigeon
+@file:Suppress("UNCHECKED_CAST", "ArrayInDataClass")
+
+package app.alextran.immich.background
+
+import android.util.Log
+import io.flutter.plugin.common.BasicMessageChannel
+import io.flutter.plugin.common.BinaryMessenger
+import io.flutter.plugin.common.EventChannel
+import io.flutter.plugin.common.MessageCodec
+import io.flutter.plugin.common.StandardMethodCodec
+import io.flutter.plugin.common.StandardMessageCodec
+import java.io.ByteArrayOutputStream
+import java.nio.ByteBuffer
+private object BackgroundWorkerLockPigeonUtils {
+
+  fun wrapResult(result: Any?): List<Any?> {
+    return listOf(result)
+  }
+
+  fun wrapError(exception: Throwable): List<Any?> {
+    return if (exception is FlutterError) {
+      listOf(
+        exception.code,
+        exception.message,
+        exception.details
+      )
+    } else {
+      listOf(
+        exception.javaClass.simpleName,
+        exception.toString(),
+        "Cause: " + exception.cause + ", Stacktrace: " + Log.getStackTraceString(exception)
+      )
+    }
+  }
+}
+private open class BackgroundWorkerLockPigeonCodec : StandardMessageCodec() {
+  override fun readValueOfType(type: Byte, buffer: ByteBuffer): Any? {
+    return     super.readValueOfType(type, buffer)
+  }
+  override fun writeValue(stream: ByteArrayOutputStream, value: Any?)   {
+    super.writeValue(stream, value)
+  }
+}
+
+/** Generated interface from Pigeon that represents a handler of messages from Flutter. */
+interface BackgroundWorkerLockApi {
+  fun lock()
+  fun unlock()
+
+  companion object {
+    /** The codec used by BackgroundWorkerLockApi. */
+    val codec: MessageCodec<Any?> by lazy {
+      BackgroundWorkerLockPigeonCodec()
+    }
+    /** Sets up an instance of `BackgroundWorkerLockApi` to handle messages through the `binaryMessenger`. */
+    @JvmOverloads
+    fun setUp(binaryMessenger: BinaryMessenger, api: BackgroundWorkerLockApi?, messageChannelSuffix: String = "") {
+      val separatedMessageChannelSuffix = if (messageChannelSuffix.isNotEmpty()) ".$messageChannelSuffix" else ""
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.BackgroundWorkerLockApi.lock$separatedMessageChannelSuffix", codec)
+        if (api != null) {
+          channel.setMessageHandler { _, reply ->
+            val wrapped: List<Any?> = try {
+              api.lock()
+              listOf(null)
+            } catch (exception: Throwable) {
+              BackgroundWorkerLockPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.BackgroundWorkerLockApi.unlock$separatedMessageChannelSuffix", codec)
+        if (api != null) {
+          channel.setMessageHandler { _, reply ->
+            val wrapped: List<Any?> = try {
+              api.unlock()
+              listOf(null)
+            } catch (exception: Throwable) {
+              BackgroundWorkerLockPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+    }
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/background/BackgroundWorkerPreferences.kt

@@ -0,0 +1,69 @@
+package app.alextran.immich.background
+
+import android.content.Context
+import android.content.SharedPreferences
+import androidx.core.content.edit
+
+class BackgroundWorkerPreferences(private val ctx: Context) {
+  companion object {
+    const val SHARED_PREF_NAME = "Immich::BackgroundWorker"
+    private const val SHARED_PREF_MIN_DELAY_KEY = "BackgroundWorker::minDelaySeconds"
+    private const val SHARED_PREF_REQUIRE_CHARGING_KEY = "BackgroundWorker::requireCharging"
+    private const val SHARED_PREF_LOCK_KEY = "BackgroundWorker::isLocked"
+    private const val SHARED_PREF_NOTIF_TITLE_KEY = "BackgroundWorker::notificationTitle"
+    private const val SHARED_PREF_NOTIF_MSG_KEY = "BackgroundWorker::notificationMessage"
+
+    private const val DEFAULT_MIN_DELAY_SECONDS = 30L
+    private const val DEFAULT_REQUIRE_CHARGING = false
+    private const val DEFAULT_NOTIF_TITLE = "Uploading media"
+    private const val DEFAULT_NOTIF_MSG = "Checking for new assets…"
+  }
+
+  private val sp: SharedPreferences by lazy {
+    ctx.getSharedPreferences(SHARED_PREF_NAME, Context.MODE_PRIVATE)
+  }
+
+  fun updateSettings(settings: BackgroundWorkerSettings) {
+    sp.edit {
+      putLong(SHARED_PREF_MIN_DELAY_KEY, settings.minimumDelaySeconds)
+      putBoolean(SHARED_PREF_REQUIRE_CHARGING_KEY, settings.requiresCharging)
+    }
+  }
+
+  fun getSettings(): BackgroundWorkerSettings {
+    val delaySeconds = sp.getLong(SHARED_PREF_MIN_DELAY_KEY, DEFAULT_MIN_DELAY_SECONDS)
+
+    return BackgroundWorkerSettings(
+      minimumDelaySeconds = if (delaySeconds >= 1000) delaySeconds / 1000 else delaySeconds,
+      requiresCharging = sp.getBoolean(
+        SHARED_PREF_REQUIRE_CHARGING_KEY,
+        DEFAULT_REQUIRE_CHARGING
+      ),
+    )
+  }
+
+  fun updateNotificationConfig(title: String, message: String) {
+    sp.edit {
+      putString(SHARED_PREF_NOTIF_TITLE_KEY, title)
+      putString(SHARED_PREF_NOTIF_MSG_KEY, message)
+    }
+  }
+
+  fun getNotificationConfig(): Pair<String, String> {
+    val title =
+      sp.getString(SHARED_PREF_NOTIF_TITLE_KEY, DEFAULT_NOTIF_TITLE) ?: DEFAULT_NOTIF_TITLE
+    val message = sp.getString(SHARED_PREF_NOTIF_MSG_KEY, DEFAULT_NOTIF_MSG) ?: DEFAULT_NOTIF_MSG
+    return Pair(title, message)
+  }
+
+  fun setLocked(paused: Boolean) {
+    sp.edit {
+      putBoolean(SHARED_PREF_LOCK_KEY, paused)
+    }
+  }
+
+  fun isLocked(): Boolean {
+    return sp.getBoolean(SHARED_PREF_LOCK_KEY, true)
+  }
+}
+

mobile/android/app/src/main/kotlin/app/alextran/immich/background/MediaObserver.kt

@@ -0,0 +1,22 @@
+package app.alextran.immich.background
+
+import android.content.Context
+import android.util.Log
+import androidx.work.Worker
+import androidx.work.WorkerParameters
+
+class MediaObserver(context: Context, params: WorkerParameters) : Worker(context, params) {
+  private val ctx: Context = context.applicationContext
+
+  override fun doWork(): Result {
+    Log.i("MediaObserver", "Content change detected, starting background worker")
+    // Re-enqueue itself to listen for future changes
+    BackgroundWorkerApiImpl.enqueueMediaObserver(ctx)
+
+    // Enqueue backup worker only if there are new media changes
+    if (triggeredContentUris.isNotEmpty()) {
+      BackgroundWorkerApiImpl.enqueueBackgroundWorker(ctx)
+    }
+    return Result.success()
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/connectivity/Connectivity.g.kt

@@ -0,0 +1,116 @@
+// Autogenerated from Pigeon (v26.0.2), do not edit directly.
+// See also: https://pub.dev/packages/pigeon
+@file:Suppress("UNCHECKED_CAST", "ArrayInDataClass")
+
+package app.alextran.immich.connectivity
+
+import android.util.Log
+import io.flutter.plugin.common.BasicMessageChannel
+import io.flutter.plugin.common.BinaryMessenger
+import io.flutter.plugin.common.EventChannel
+import io.flutter.plugin.common.MessageCodec
+import io.flutter.plugin.common.StandardMethodCodec
+import io.flutter.plugin.common.StandardMessageCodec
+import java.io.ByteArrayOutputStream
+import java.nio.ByteBuffer
+private object ConnectivityPigeonUtils {
+
+  fun wrapResult(result: Any?): List<Any?> {
+    return listOf(result)
+  }
+
+  fun wrapError(exception: Throwable): List<Any?> {
+    return if (exception is FlutterError) {
+      listOf(
+        exception.code,
+        exception.message,
+        exception.details
+      )
+    } else {
+      listOf(
+        exception.javaClass.simpleName,
+        exception.toString(),
+        "Cause: " + exception.cause + ", Stacktrace: " + Log.getStackTraceString(exception)
+      )
+    }
+  }
+}
+
+/**
+ * Error class for passing custom error details to Flutter via a thrown PlatformException.
+ * @property code The error code.
+ * @property message The error message.
+ * @property details The error details. Must be a datatype supported by the api codec.
+ */
+class FlutterError (
+  val code: String,
+  override val message: String? = null,
+  val details: Any? = null
+) : Throwable()
+
+enum class NetworkCapability(val raw: Int) {
+  CELLULAR(0),
+  WIFI(1),
+  VPN(2),
+  UNMETERED(3);
+
+  companion object {
+    fun ofRaw(raw: Int): NetworkCapability? {
+      return values().firstOrNull { it.raw == raw }
+    }
+  }
+}
+private open class ConnectivityPigeonCodec : StandardMessageCodec() {
+  override fun readValueOfType(type: Byte, buffer: ByteBuffer): Any? {
+    return when (type) {
+      129.toByte() -> {
+        return (readValue(buffer) as Long?)?.let {
+          NetworkCapability.ofRaw(it.toInt())
+        }
+      }
+      else -> super.readValueOfType(type, buffer)
+    }
+  }
+  override fun writeValue(stream: ByteArrayOutputStream, value: Any?)   {
+    when (value) {
+      is NetworkCapability -> {
+        stream.write(129)
+        writeValue(stream, value.raw)
+      }
+      else -> super.writeValue(stream, value)
+    }
+  }
+}
+
+/** Generated interface from Pigeon that represents a handler of messages from Flutter. */
+interface ConnectivityApi {
+  fun getCapabilities(): List<NetworkCapability>
+
+  companion object {
+    /** The codec used by ConnectivityApi. */
+    val codec: MessageCodec<Any?> by lazy {
+      ConnectivityPigeonCodec()
+    }
+    /** Sets up an instance of `ConnectivityApi` to handle messages through the `binaryMessenger`. */
+    @JvmOverloads
+    fun setUp(binaryMessenger: BinaryMessenger, api: ConnectivityApi?, messageChannelSuffix: String = "") {
+      val separatedMessageChannelSuffix = if (messageChannelSuffix.isNotEmpty()) ".$messageChannelSuffix" else ""
+      val taskQueue = binaryMessenger.makeBackgroundTaskQueue()
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.ConnectivityApi.getCapabilities$separatedMessageChannelSuffix", codec, taskQueue)
+        if (api != null) {
+          channel.setMessageHandler { _, reply ->
+            val wrapped: List<Any?> = try {
+              listOf(api.getCapabilities())
+            } catch (exception: Throwable) {
+              ConnectivityPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+    }
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/connectivity/ConnectivityApiImpl.kt

@@ -0,0 +1,39 @@
+package app.alextran.immich.connectivity
+
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.NetworkCapabilities
+import android.net.wifi.WifiManager
+
+class ConnectivityApiImpl(context: Context) : ConnectivityApi {
+  private val connectivityManager =
+    context.applicationContext.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+  private val wifiManager =
+    context.applicationContext.getSystemService(Context.WIFI_SERVICE) as WifiManager
+
+  override fun getCapabilities(): List<NetworkCapability> {
+    val capabilities = connectivityManager.getNetworkCapabilities(connectivityManager.activeNetwork)
+      ?: return emptyList()
+
+    val hasWifi = capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) ||
+      capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI_AWARE)
+    val hasCellular = capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)
+    val hasVpn = capabilities.hasTransport(NetworkCapabilities.TRANSPORT_VPN)
+    val isUnmetered = capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED)
+
+    return buildList {
+      if (hasWifi) add(NetworkCapability.WIFI)
+      if (hasCellular) add(NetworkCapability.CELLULAR)
+      if (hasVpn) {
+        add(NetworkCapability.VPN)
+        if (!hasWifi && !hasCellular) {
+          if (wifiManager.isWifiEnabled) add(NetworkCapability.WIFI)
+          // If VPN is active, but neither WIFI nor CELLULAR is reported as active,
+          // assume CELLULAR if WIFI is not enabled
+          else add(NetworkCapability.CELLULAR)
+        }
+      }
+      if (isUnmetered) add(NetworkCapability.UNMETERED)
+    }
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/core/ImmichPlugin.kt

@@ -0,0 +1,29 @@
+package app.alextran.immich.core
+
+import androidx.annotation.CallSuper
+import io.flutter.embedding.engine.plugins.FlutterPlugin
+
+abstract class ImmichPlugin : FlutterPlugin {
+  private var detached: Boolean = false;
+
+  @CallSuper
+  override fun onAttachedToEngine(binding: FlutterPlugin.FlutterPluginBinding) {
+    detached = false;
+  }
+
+  fun detachFromEngine() {
+    detached = true
+  }
+
+  @CallSuper
+  override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
+    detachFromEngine()
+  }
+
+  fun <T> completeWhenActive(callback: (T) -> Unit, value: T) {
+    if (detached) {
+      return;
+    }
+    callback(value);
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/core/SSLConfig.kt

@@ -0,0 +1,73 @@
+package app.alextran.immich.core
+
+import java.security.KeyStore
+import javax.net.ssl.KeyManager
+import javax.net.ssl.SSLContext
+import javax.net.ssl.SSLSocketFactory
+import javax.net.ssl.TrustManager
+import javax.net.ssl.TrustManagerFactory
+import javax.net.ssl.X509TrustManager
+
+/**
+ * Shared SSL configuration for OkHttp and HttpsURLConnection.
+ * Stores the SSLSocketFactory and X509TrustManager configured by HttpSSLOptionsPlugin.
+ */
+object SSLConfig {
+  var sslSocketFactory: SSLSocketFactory? = null
+    private set
+
+  var trustManager: X509TrustManager? = null
+    private set
+
+  var requiresCustomSSL: Boolean = false
+    private set
+
+  private val listeners = mutableListOf<() -> Unit>()
+  private var configHash: Int = 0
+
+  fun addListener(listener: () -> Unit) {
+    listeners.add(listener)
+  }
+
+  fun apply(
+    keyManagers: Array<KeyManager>?,
+    trustManagers: Array<TrustManager>?,
+    allowSelfSigned: Boolean,
+    serverHost: String?,
+    clientCertHash: Int
+  ) {
+    synchronized(this) {
+      val newHash = computeHash(allowSelfSigned, serverHost, clientCertHash)
+      val newRequiresCustomSSL = allowSelfSigned || keyManagers != null
+      if (newHash == configHash && sslSocketFactory != null && requiresCustomSSL == newRequiresCustomSSL) {
+        return  // Config unchanged, skip
+      }
+
+      val sslContext = SSLContext.getInstance("TLS")
+      sslContext.init(keyManagers, trustManagers, null)
+      sslSocketFactory = sslContext.socketFactory
+      trustManager = trustManagers?.filterIsInstance<X509TrustManager>()?.firstOrNull()
+        ?: getDefaultTrustManager()
+      requiresCustomSSL = newRequiresCustomSSL
+      configHash = newHash
+      notifyListeners()
+    }
+  }
+
+  private fun computeHash(allowSelfSigned: Boolean, serverHost: String?, clientCertHash: Int): Int {
+    var result = allowSelfSigned.hashCode()
+    result = 31 * result + (serverHost?.hashCode() ?: 0)
+    result = 31 * result + clientCertHash
+    return result
+  }
+
+  private fun notifyListeners() {
+    listeners.forEach { it() }
+  }
+
+  private fun getDefaultTrustManager(): X509TrustManager {
+    val factory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
+    factory.init(null as KeyStore?)
+    return factory.trustManagers.filterIsInstance<X509TrustManager>().first()
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/images/LocalImages.g.kt

@@ -0,0 +1,139 @@
+// Autogenerated from Pigeon (v26.0.2), do not edit directly.
+// See also: https://pub.dev/packages/pigeon
+@file:Suppress("UNCHECKED_CAST", "ArrayInDataClass")
+
+package app.alextran.immich.images
+
+import android.util.Log
+import io.flutter.plugin.common.BasicMessageChannel
+import io.flutter.plugin.common.BinaryMessenger
+import io.flutter.plugin.common.EventChannel
+import io.flutter.plugin.common.MessageCodec
+import io.flutter.plugin.common.StandardMethodCodec
+import io.flutter.plugin.common.StandardMessageCodec
+import java.io.ByteArrayOutputStream
+import java.nio.ByteBuffer
+private object LocalImagesPigeonUtils {
+
+  fun wrapResult(result: Any?): List<Any?> {
+    return listOf(result)
+  }
+
+  fun wrapError(exception: Throwable): List<Any?> {
+    return if (exception is FlutterError) {
+      listOf(
+        exception.code,
+        exception.message,
+        exception.details
+      )
+    } else {
+      listOf(
+        exception.javaClass.simpleName,
+        exception.toString(),
+        "Cause: " + exception.cause + ", Stacktrace: " + Log.getStackTraceString(exception)
+      )
+    }
+  }
+}
+
+/**
+ * Error class for passing custom error details to Flutter via a thrown PlatformException.
+ * @property code The error code.
+ * @property message The error message.
+ * @property details The error details. Must be a datatype supported by the api codec.
+ */
+class FlutterError (
+  val code: String,
+  override val message: String? = null,
+  val details: Any? = null
+) : Throwable()
+private open class LocalImagesPigeonCodec : StandardMessageCodec() {
+  override fun readValueOfType(type: Byte, buffer: ByteBuffer): Any? {
+    return     super.readValueOfType(type, buffer)
+  }
+  override fun writeValue(stream: ByteArrayOutputStream, value: Any?)   {
+    super.writeValue(stream, value)
+  }
+}
+
+
+/** Generated interface from Pigeon that represents a handler of messages from Flutter. */
+interface LocalImageApi {
+  fun requestImage(assetId: String, requestId: Long, width: Long, height: Long, isVideo: Boolean, callback: (Result<Map<String, Long>?>) -> Unit)
+  fun cancelRequest(requestId: Long)
+  fun getThumbhash(thumbhash: String, callback: (Result<Map<String, Long>>) -> Unit)
+
+  companion object {
+    /** The codec used by LocalImageApi. */
+    val codec: MessageCodec<Any?> by lazy {
+      LocalImagesPigeonCodec()
+    }
+    /** Sets up an instance of `LocalImageApi` to handle messages through the `binaryMessenger`. */
+    @JvmOverloads
+    fun setUp(binaryMessenger: BinaryMessenger, api: LocalImageApi?, messageChannelSuffix: String = "") {
+      val separatedMessageChannelSuffix = if (messageChannelSuffix.isNotEmpty()) ".$messageChannelSuffix" else ""
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.LocalImageApi.requestImage$separatedMessageChannelSuffix", codec)
+        if (api != null) {
+          channel.setMessageHandler { message, reply ->
+            val args = message as List<Any?>
+            val assetIdArg = args[0] as String
+            val requestIdArg = args[1] as Long
+            val widthArg = args[2] as Long
+            val heightArg = args[3] as Long
+            val isVideoArg = args[4] as Boolean
+            api.requestImage(assetIdArg, requestIdArg, widthArg, heightArg, isVideoArg) { result: Result<Map<String, Long>?> ->
+              val error = result.exceptionOrNull()
+              if (error != null) {
+                reply.reply(LocalImagesPigeonUtils.wrapError(error))
+              } else {
+                val data = result.getOrNull()
+                reply.reply(LocalImagesPigeonUtils.wrapResult(data))
+              }
+            }
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.LocalImageApi.cancelRequest$separatedMessageChannelSuffix", codec)
+        if (api != null) {
+          channel.setMessageHandler { message, reply ->
+            val args = message as List<Any?>
+            val requestIdArg = args[0] as Long
+            val wrapped: List<Any?> = try {
+              api.cancelRequest(requestIdArg)
+              listOf(null)
+            } catch (exception: Throwable) {
+              LocalImagesPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.LocalImageApi.getThumbhash$separatedMessageChannelSuffix", codec)
+        if (api != null) {
+          channel.setMessageHandler { message, reply ->
+            val args = message as List<Any?>
+            val thumbhashArg = args[0] as String
+            api.getThumbhash(thumbhashArg) { result: Result<Map<String, Long>> ->
+              val error = result.exceptionOrNull()
+              if (error != null) {
+                reply.reply(LocalImagesPigeonUtils.wrapError(error))
+              } else {
+                val data = result.getOrNull()
+                reply.reply(LocalImagesPigeonUtils.wrapResult(data))
+              }
+            }
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+    }
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/images/LocalImagesImpl.kt

@@ -0,0 +1,208 @@
+package app.alextran.immich.images
+
+import android.content.ContentResolver
+import android.content.ContentUris
+import android.content.Context
+import android.graphics.*
+import android.net.Uri
+import android.os.Build
+import android.os.CancellationSignal
+import android.os.OperationCanceledException
+import android.provider.MediaStore.Images
+import android.provider.MediaStore.Video
+import android.util.Size
+import androidx.annotation.RequiresApi
+import app.alextran.immich.NativeBuffer
+import kotlin.math.*
+import java.util.concurrent.Executors
+import com.bumptech.glide.Glide
+import com.bumptech.glide.Priority
+import com.bumptech.glide.load.DecodeFormat
+import com.bumptech.glide.request.target.Target.SIZE_ORIGINAL
+import java.util.Base64
+import java.util.concurrent.CancellationException
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.Future
+
+data class Request(
+  val taskFuture: Future<*>,
+  val cancellationSignal: CancellationSignal,
+  val callback: (Result<Map<String, Long>?>) -> Unit
+)
+
+@RequiresApi(Build.VERSION_CODES.Q)
+inline fun ImageDecoder.Source.decodeBitmap(target: Size = Size(0, 0)): Bitmap {
+  return ImageDecoder.decodeBitmap(this) { decoder, info, _ ->
+    if (target.width > 0 && target.height > 0) {
+      val sample = max(1, min(info.size.width / target.width, info.size.height / target.height))
+      decoder.setTargetSampleSize(sample)
+    }
+    decoder.allocator = ImageDecoder.ALLOCATOR_SOFTWARE
+    decoder.setTargetColorSpace(ColorSpace.get(ColorSpace.Named.SRGB))
+  }
+}
+
+fun Bitmap.toNativeBuffer(): Map<String, Long>  {
+  val size = width * height * 4
+  val pointer = NativeBuffer.allocate(size)
+  try {
+    val buffer = NativeBuffer.wrap(pointer, size)
+    copyPixelsToBuffer(buffer)
+    recycle()
+    return mapOf(
+      "pointer" to pointer,
+      "width" to width.toLong(),
+      "height" to height.toLong(),
+      "rowBytes" to (width * 4).toLong()
+    )
+  } catch (e: Exception) {
+    NativeBuffer.free(pointer)
+    recycle()
+    throw e
+  }
+}
+
+class LocalImagesImpl(context: Context) : LocalImageApi {
+  private val ctx: Context = context.applicationContext
+  private val resolver: ContentResolver = ctx.contentResolver
+  private val requestThread = Executors.newSingleThreadExecutor()
+  private val threadPool =
+    Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() / 2 + 1)
+  private val requestMap = ConcurrentHashMap<Long, Request>()
+
+  companion object {
+    val CANCELLED = Result.success<Map<String, Long>?>(null)
+    val OPTIONS = BitmapFactory.Options().apply { inPreferredConfig = Bitmap.Config.ARGB_8888 }
+  }
+
+  override fun getThumbhash(thumbhash: String, callback: (Result<Map<String, Long>>) -> Unit) {
+    threadPool.execute {
+      try {
+        val bytes = Base64.getDecoder().decode(thumbhash)
+        val image = ThumbHash.thumbHashToRGBA(bytes)
+        val res = mapOf(
+          "pointer" to image.pointer,
+          "width" to image.width.toLong(),
+          "height" to image.height.toLong(),
+          "rowBytes" to (image.width * 4).toLong()
+        )
+        callback(Result.success(res))
+      } catch (e: Exception) {
+        callback(Result.failure(e))
+      }
+    }
+  }
+
+  override fun requestImage(
+    assetId: String,
+    requestId: Long,
+    width: Long,
+    height: Long,
+    isVideo: Boolean,
+    callback: (Result<Map<String, Long>?>) -> Unit
+  ) {
+    val signal = CancellationSignal()
+    val task = threadPool.submit {
+      try {
+        getThumbnailBufferInternal(assetId, width, height, isVideo, callback, signal)
+      } catch (e: Exception) {
+        when (e) {
+          is OperationCanceledException -> callback(CANCELLED)
+          is CancellationException -> callback(CANCELLED)
+          else -> callback(Result.failure(e))
+        }
+      } finally {
+        requestMap.remove(requestId)
+      }
+    }
+    val request = Request(task, signal, callback)
+    requestMap[requestId] = request
+  }
+
+  override fun cancelRequest(requestId: Long) {
+    val request = requestMap.remove(requestId) ?: return
+    request.taskFuture.cancel(false)
+    request.cancellationSignal.cancel()
+    if (request.taskFuture.isCancelled) {
+      requestThread.execute {
+        try {
+          request.callback(CANCELLED)
+        } catch (_: Exception) {
+        }
+      }
+    }
+  }
+
+  private fun getThumbnailBufferInternal(
+    assetId: String,
+    width: Long,
+    height: Long,
+    isVideo: Boolean,
+    callback: (Result<Map<String, Long>?>) -> Unit,
+    signal: CancellationSignal
+  ) {
+    signal.throwIfCanceled()
+    val size = Size(width.toInt(), height.toInt())
+    val id = assetId.toLong()
+
+    signal.throwIfCanceled()
+    val bitmap = if (isVideo) {
+      decodeVideoThumbnail(id, size, signal)
+    } else {
+      decodeImage(id, size, signal)
+    }
+
+    try {
+      signal.throwIfCanceled()
+      val res = bitmap.toNativeBuffer()
+      signal.throwIfCanceled()
+      callback(Result.success(res))
+    } catch (e: Exception) {
+      callback(if (e is OperationCanceledException) CANCELLED else Result.failure(e))
+    }
+  }
+
+  private fun decodeImage(id: Long, size: Size, signal: CancellationSignal): Bitmap {
+    signal.throwIfCanceled()
+    val uri = ContentUris.withAppendedId(Images.Media.EXTERNAL_CONTENT_URI, id)
+    if (size.width <= 0 || size.height <= 0 || size.width > 768 || size.height > 768) {
+      return decodeSource(uri, size, signal)
+    }
+
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+      resolver.loadThumbnail(uri, size, signal)
+    } else {
+      signal.setOnCancelListener { Images.Thumbnails.cancelThumbnailRequest(resolver, id) }
+      Images.Thumbnails.getThumbnail(resolver, id, Images.Thumbnails.MINI_KIND, OPTIONS)
+    }
+  }
+
+  private fun decodeVideoThumbnail(id: Long, target: Size, signal: CancellationSignal): Bitmap {
+    signal.throwIfCanceled()
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+      val uri = ContentUris.withAppendedId(Video.Media.EXTERNAL_CONTENT_URI, id)
+      // ensure a valid resolution as the thumbnail is used for videos even when no scaling is needed
+      val size = if (target.width > 0 && target.height > 0) target else Size(768, 768)
+      resolver.loadThumbnail(uri, size, signal)
+    } else {
+      signal.setOnCancelListener { Video.Thumbnails.cancelThumbnailRequest(resolver, id) }
+      Video.Thumbnails.getThumbnail(resolver, id, Video.Thumbnails.MINI_KIND, OPTIONS)
+    }
+  }
+
+  private fun decodeSource(uri: Uri, target: Size, signal: CancellationSignal): Bitmap {
+    signal.throwIfCanceled()
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+      ImageDecoder.createSource(resolver, uri).decodeBitmap(target)
+    } else {
+      val ref =
+        Glide.with(ctx).asBitmap().priority(Priority.IMMEDIATE).load(uri).disallowHardwareConfig()
+          .format(DecodeFormat.PREFER_ARGB_8888).submit(
+            if (target.width > 0) target.width else SIZE_ORIGINAL,
+            if (target.height > 0) target.height else SIZE_ORIGINAL,
+          )
+      signal.setOnCancelListener { Glide.with(ctx).clear(ref) }
+      ref.get()
+    }
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/images/RemoteImages.g.kt

@@ -0,0 +1,123 @@
+// Autogenerated from Pigeon (v26.0.2), do not edit directly.
+// See also: https://pub.dev/packages/pigeon
+@file:Suppress("UNCHECKED_CAST", "ArrayInDataClass")
+
+package app.alextran.immich.images
+
+import android.util.Log
+import io.flutter.plugin.common.BasicMessageChannel
+import io.flutter.plugin.common.BinaryMessenger
+import io.flutter.plugin.common.EventChannel
+import io.flutter.plugin.common.MessageCodec
+import io.flutter.plugin.common.StandardMethodCodec
+import io.flutter.plugin.common.StandardMessageCodec
+import java.io.ByteArrayOutputStream
+import java.nio.ByteBuffer
+private object RemoteImagesPigeonUtils {
+
+  fun wrapResult(result: Any?): List<Any?> {
+    return listOf(result)
+  }
+
+  fun wrapError(exception: Throwable): List<Any?> {
+    return if (exception is FlutterError) {
+      listOf(
+        exception.code,
+        exception.message,
+        exception.details
+      )
+    } else {
+      listOf(
+        exception.javaClass.simpleName,
+        exception.toString(),
+        "Cause: " + exception.cause + ", Stacktrace: " + Log.getStackTraceString(exception)
+      )
+    }
+  }
+}
+private open class RemoteImagesPigeonCodec : StandardMessageCodec() {
+  override fun readValueOfType(type: Byte, buffer: ByteBuffer): Any? {
+    return     super.readValueOfType(type, buffer)
+  }
+  override fun writeValue(stream: ByteArrayOutputStream, value: Any?)   {
+    super.writeValue(stream, value)
+  }
+}
+
+
+/** Generated interface from Pigeon that represents a handler of messages from Flutter. */
+interface RemoteImageApi {
+  fun requestImage(url: String, headers: Map<String, String>, requestId: Long, callback: (Result<Map<String, Long>?>) -> Unit)
+  fun cancelRequest(requestId: Long)
+  fun clearCache(callback: (Result<Long>) -> Unit)
+
+  companion object {
+    /** The codec used by RemoteImageApi. */
+    val codec: MessageCodec<Any?> by lazy {
+      RemoteImagesPigeonCodec()
+    }
+    /** Sets up an instance of `RemoteImageApi` to handle messages through the `binaryMessenger`. */
+    @JvmOverloads
+    fun setUp(binaryMessenger: BinaryMessenger, api: RemoteImageApi?, messageChannelSuffix: String = "") {
+      val separatedMessageChannelSuffix = if (messageChannelSuffix.isNotEmpty()) ".$messageChannelSuffix" else ""
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.RemoteImageApi.requestImage$separatedMessageChannelSuffix", codec)
+        if (api != null) {
+          channel.setMessageHandler { message, reply ->
+            val args = message as List<Any?>
+            val urlArg = args[0] as String
+            val headersArg = args[1] as Map<String, String>
+            val requestIdArg = args[2] as Long
+            api.requestImage(urlArg, headersArg, requestIdArg) { result: Result<Map<String, Long>?> ->
+              val error = result.exceptionOrNull()
+              if (error != null) {
+                reply.reply(RemoteImagesPigeonUtils.wrapError(error))
+              } else {
+                val data = result.getOrNull()
+                reply.reply(RemoteImagesPigeonUtils.wrapResult(data))
+              }
+            }
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.RemoteImageApi.cancelRequest$separatedMessageChannelSuffix", codec)
+        if (api != null) {
+          channel.setMessageHandler { message, reply ->
+            val args = message as List<Any?>
+            val requestIdArg = args[0] as Long
+            val wrapped: List<Any?> = try {
+              api.cancelRequest(requestIdArg)
+              listOf(null)
+            } catch (exception: Throwable) {
+              RemoteImagesPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.RemoteImageApi.clearCache$separatedMessageChannelSuffix", codec)
+        if (api != null) {
+          channel.setMessageHandler { _, reply ->
+            api.clearCache{ result: Result<Long> ->
+              val error = result.exceptionOrNull()
+              if (error != null) {
+                reply.reply(RemoteImagesPigeonUtils.wrapError(error))
+              } else {
+                val data = result.getOrNull()
+                reply.reply(RemoteImagesPigeonUtils.wrapResult(data))
+              }
+            }
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+    }
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/images/RemoteImagesImpl.kt

@@ -0,0 +1,530 @@
+package app.alextran.immich.images
+
+import android.content.Context
+import android.os.CancellationSignal
+import android.os.OperationCanceledException
+import app.alextran.immich.BuildConfig
+import app.alextran.immich.INITIAL_BUFFER_SIZE
+import app.alextran.immich.NativeBuffer
+import app.alextran.immich.NativeByteBuffer
+import app.alextran.immich.core.SSLConfig
+import kotlinx.coroutines.*
+import okhttp3.Cache
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.ConnectionPool
+import okhttp3.Dispatcher
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import org.chromium.net.CronetEngine
+import org.chromium.net.CronetException
+import org.chromium.net.UrlRequest
+import org.chromium.net.UrlResponseInfo
+import java.io.EOFException
+import java.io.File
+import java.io.IOException
+import java.nio.ByteBuffer
+import java.nio.file.FileVisitResult
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.SimpleFileVisitor
+import java.nio.file.attribute.BasicFileAttributes
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.Executors
+import java.util.concurrent.TimeUnit
+import javax.net.ssl.SSLSocketFactory
+import javax.net.ssl.X509TrustManager
+
+
+private const val USER_AGENT = "Immich_Android_${BuildConfig.VERSION_NAME}"
+private const val MAX_REQUESTS_PER_HOST = 64
+private const val KEEP_ALIVE_CONNECTIONS = 10
+private const val KEEP_ALIVE_DURATION_MINUTES = 5L
+private const val CACHE_SIZE_BYTES = 1024L * 1024 * 1024
+
+private class RemoteRequest(val cancellationSignal: CancellationSignal)
+
+class RemoteImagesImpl(context: Context) : RemoteImageApi {
+  private val requestMap = ConcurrentHashMap<Long, RemoteRequest>()
+
+  init {
+    ImageFetcherManager.initialize(context)
+  }
+
+  companion object {
+    val CANCELLED = Result.success<Map<String, Long>?>(null)
+  }
+
+  override fun requestImage(
+    url: String,
+    headers: Map<String, String>,
+    requestId: Long,
+    callback: (Result<Map<String, Long>?>) -> Unit
+  ) {
+    val signal = CancellationSignal()
+    requestMap[requestId] = RemoteRequest(signal)
+
+    ImageFetcherManager.fetch(
+      url,
+      headers,
+      signal,
+      onSuccess = { buffer ->
+        requestMap.remove(requestId)
+        if (signal.isCanceled) {
+          NativeBuffer.free(buffer.pointer)
+          return@fetch callback(CANCELLED)
+        }
+
+        callback(
+          Result.success(
+            mapOf(
+              "pointer" to buffer.pointer,
+              "length" to buffer.offset.toLong()
+            )
+          )
+        )
+      },
+      onFailure = { e ->
+        requestMap.remove(requestId)
+        val result = if (signal.isCanceled) CANCELLED else Result.failure(e)
+        callback(result)
+      }
+    )
+  }
+
+  override fun cancelRequest(requestId: Long) {
+    requestMap.remove(requestId)?.cancellationSignal?.cancel()
+  }
+
+  override fun clearCache(callback: (Result<Long>) -> Unit) {
+    CoroutineScope(Dispatchers.IO).launch {
+      try {
+        ImageFetcherManager.clearCache(callback)
+      } catch (e: Exception) {
+        callback(Result.failure(e))
+      }
+    }
+  }
+}
+
+private object ImageFetcherManager {
+  private lateinit var appContext: Context
+  private lateinit var cacheDir: File
+  private lateinit var fetcher: ImageFetcher
+  private var initialized = false
+
+  fun initialize(context: Context) {
+    if (initialized) return
+    synchronized(this) {
+      if (initialized) return
+      appContext = context.applicationContext
+      cacheDir = context.cacheDir
+      fetcher = build()
+      SSLConfig.addListener(::invalidate)
+      initialized = true
+    }
+  }
+
+  fun fetch(
+    url: String,
+    headers: Map<String, String>,
+    signal: CancellationSignal,
+    onSuccess: (NativeByteBuffer) -> Unit,
+    onFailure: (Exception) -> Unit,
+  ) {
+    fetcher.fetch(url, headers, signal, onSuccess, onFailure)
+  }
+
+  fun clearCache(onCleared: (Result<Long>) -> Unit) {
+    fetcher.clearCache(onCleared)
+  }
+
+  private fun invalidate() {
+    synchronized(this) {
+      val oldFetcher = fetcher
+      if (oldFetcher is OkHttpImageFetcher && SSLConfig.requiresCustomSSL) {
+        fetcher = oldFetcher.reconfigure(SSLConfig.sslSocketFactory, SSLConfig.trustManager)
+        return
+      }
+      fetcher = build()
+      oldFetcher.drain()
+    }
+  }
+
+  private fun build(): ImageFetcher {
+    return if (SSLConfig.requiresCustomSSL) {
+      OkHttpImageFetcher.create(cacheDir, SSLConfig.sslSocketFactory, SSLConfig.trustManager)
+    } else {
+      CronetImageFetcher(appContext, cacheDir)
+    }
+  }
+}
+
+private sealed interface ImageFetcher {
+  fun fetch(
+    url: String,
+    headers: Map<String, String>,
+    signal: CancellationSignal,
+    onSuccess: (NativeByteBuffer) -> Unit,
+    onFailure: (Exception) -> Unit,
+  )
+
+  fun drain()
+
+  fun clearCache(onCleared: (Result<Long>) -> Unit)
+}
+
+private class CronetImageFetcher(context: Context, cacheDir: File) : ImageFetcher {
+  private val ctx = context
+  private var engine: CronetEngine
+  private val executor = Executors.newFixedThreadPool(4)
+  private val stateLock = Any()
+  private var activeCount = 0
+  private var draining = false
+  private var onCacheCleared: ((Result<Long>) -> Unit)? = null
+  private val storageDir = File(cacheDir, "cronet").apply { mkdirs() }
+
+  init {
+    engine = build(context)
+  }
+
+  override fun fetch(
+    url: String,
+    headers: Map<String, String>,
+    signal: CancellationSignal,
+    onSuccess: (NativeByteBuffer) -> Unit,
+    onFailure: (Exception) -> Unit,
+  ) {
+    synchronized(stateLock) {
+      if (draining) {
+        onFailure(IllegalStateException("Engine is draining"))
+        return
+      }
+      activeCount++
+    }
+
+    val callback = FetchCallback(onSuccess, onFailure, ::onComplete)
+    val requestBuilder = engine.newUrlRequestBuilder(url, callback, executor)
+    headers.forEach { (key, value) -> requestBuilder.addHeader(key, value) }
+    val request = requestBuilder.build()
+    signal.setOnCancelListener(request::cancel)
+    request.start()
+  }
+
+  private fun build(ctx: Context): CronetEngine {
+    return CronetEngine.Builder(ctx)
+      .enableHttp2(true)
+      .enableQuic(true)
+      .enableBrotli(true)
+      .setStoragePath(storageDir.absolutePath)
+      .setUserAgent(USER_AGENT)
+      .enableHttpCache(CronetEngine.Builder.HTTP_CACHE_DISK, CACHE_SIZE_BYTES)
+      .build()
+  }
+
+  private fun onComplete() {
+    val didDrain = synchronized(stateLock) {
+      activeCount--
+      draining && activeCount == 0
+    }
+    if (didDrain) {
+      onDrained()
+    }
+  }
+
+  override fun drain() {
+    val didDrain = synchronized(stateLock) {
+      if (draining) return
+      draining = true
+      activeCount == 0
+    }
+    if (didDrain) {
+      onDrained()
+    }
+  }
+
+  private fun onDrained() {
+    engine.shutdown()
+    val onCacheCleared = synchronized(stateLock) {
+      val onCacheCleared = onCacheCleared
+      this.onCacheCleared = null
+      onCacheCleared
+    }
+    if (onCacheCleared == null) {
+      executor.shutdown()
+    } else {
+      CoroutineScope(Dispatchers.IO).launch {
+        val result = runCatching { deleteFolderAndGetSize(storageDir.toPath()) }
+        // Cronet is very good at self-repair, so it shouldn't fail here regardless of clear result
+        engine = build(ctx)
+        synchronized(stateLock) { draining = false }
+        onCacheCleared(result)
+      }
+    }
+  }
+
+  override fun clearCache(onCleared: (Result<Long>) -> Unit) {
+    synchronized(stateLock) {
+      if (onCacheCleared != null) {
+        return onCleared(Result.success(-1))
+      }
+      onCacheCleared = onCleared
+    }
+    drain()
+  }
+
+  private class FetchCallback(
+    private val onSuccess: (NativeByteBuffer) -> Unit,
+    private val onFailure: (Exception) -> Unit,
+    private val onComplete: () -> Unit,
+  ) : UrlRequest.Callback() {
+    private var buffer: NativeByteBuffer? = null
+    private var wrapped: ByteBuffer? = null
+    private var error: Exception? = null
+
+    override fun onRedirectReceived(request: UrlRequest, info: UrlResponseInfo, newUrl: String) {
+      request.followRedirect()
+    }
+
+    override fun onResponseStarted(request: UrlRequest, info: UrlResponseInfo) {
+      if (info.httpStatusCode !in 200..299) {
+        error = IOException("HTTP ${info.httpStatusCode}: ${info.httpStatusText}")
+        return request.cancel()
+      }
+
+      try {
+        val contentLength = info.allHeaders["content-length"]?.firstOrNull()?.toIntOrNull() ?: 0
+        if (contentLength > 0) {
+          buffer = NativeByteBuffer(contentLength + 1)
+          wrapped = NativeBuffer.wrap(buffer!!.pointer, contentLength + 1)
+          request.read(wrapped)
+        } else {
+          buffer = NativeByteBuffer(INITIAL_BUFFER_SIZE)
+          request.read(buffer!!.wrapRemaining())
+        }
+      } catch (e: Exception) {
+        error = e
+        return request.cancel()
+      }
+    }
+
+    override fun onReadCompleted(
+      request: UrlRequest,
+      info: UrlResponseInfo,
+      byteBuffer: ByteBuffer
+    ) {
+      try {
+        val buf = if (wrapped == null) {
+          buffer!!.run {
+            advance(byteBuffer.position())
+            ensureHeadroom()
+            wrapRemaining()
+          }
+        } else {
+          wrapped
+        }
+        request.read(buf)
+      } catch (e: Exception) {
+        error = e
+        return request.cancel()
+      }
+    }
+
+    override fun onSucceeded(request: UrlRequest, info: UrlResponseInfo) {
+      wrapped?.let { buffer!!.advance(it.position()) }
+      onSuccess(buffer!!)
+      onComplete()
+    }
+
+    override fun onFailed(request: UrlRequest, info: UrlResponseInfo?, error: CronetException) {
+      buffer?.free()
+      onFailure(error)
+      onComplete()
+    }
+
+    override fun onCanceled(request: UrlRequest, info: UrlResponseInfo?) {
+      buffer?.free()
+      onFailure(error ?: OperationCanceledException())
+      onComplete()
+    }
+  }
+
+  suspend fun deleteFolderAndGetSize(root: Path): Long = withContext(Dispatchers.IO) {
+    var totalSize = 0L
+
+    Files.walkFileTree(root, object : SimpleFileVisitor<Path>() {
+      override fun visitFile(file: Path, attrs: BasicFileAttributes): FileVisitResult {
+        totalSize += attrs.size()
+        Files.delete(file)
+        return FileVisitResult.CONTINUE
+      }
+
+      override fun postVisitDirectory(dir: Path, exc: IOException?): FileVisitResult {
+        if (dir != root) {
+          Files.delete(dir)
+        }
+        return FileVisitResult.CONTINUE
+      }
+    })
+
+    totalSize
+  }
+}
+
+private class OkHttpImageFetcher private constructor(
+  private val client: OkHttpClient,
+) : ImageFetcher {
+  private val stateLock = Any()
+  private var activeCount = 0
+  private var draining = false
+
+  companion object {
+    fun create(
+      cacheDir: File,
+      sslSocketFactory: SSLSocketFactory?,
+      trustManager: X509TrustManager?,
+    ): OkHttpImageFetcher {
+      val dir = File(cacheDir, "okhttp")
+      val connectionPool = ConnectionPool(
+        maxIdleConnections = KEEP_ALIVE_CONNECTIONS,
+        keepAliveDuration = KEEP_ALIVE_DURATION_MINUTES,
+        timeUnit = TimeUnit.MINUTES
+      )
+
+      val builder = OkHttpClient.Builder()
+        .addInterceptor { chain ->
+          chain.proceed(
+            chain.request().newBuilder()
+              .header("User-Agent", USER_AGENT)
+              .build()
+          )
+        }
+        .dispatcher(Dispatcher().apply { maxRequestsPerHost = MAX_REQUESTS_PER_HOST })
+        .connectionPool(connectionPool)
+        .cache(Cache(File(dir, "thumbnails"), CACHE_SIZE_BYTES))
+
+      if (sslSocketFactory != null && trustManager != null) {
+        builder.sslSocketFactory(sslSocketFactory, trustManager)
+      }
+
+      return OkHttpImageFetcher(builder.build())
+    }
+  }
+
+  fun reconfigure(
+    sslSocketFactory: SSLSocketFactory?,
+    trustManager: X509TrustManager?,
+  ): OkHttpImageFetcher {
+    val builder = client.newBuilder()
+    if (sslSocketFactory != null && trustManager != null) {
+      builder.sslSocketFactory(sslSocketFactory, trustManager)
+    }
+    // Evict idle connections using old SSL config
+    client.connectionPool.evictAll()
+    return OkHttpImageFetcher(builder.build())
+  }
+
+  private fun onComplete() {
+    val shouldClose = synchronized(stateLock) {
+      activeCount--
+      draining && activeCount == 0
+    }
+    if (shouldClose) {
+      client.cache?.close()
+    }
+  }
+
+  override fun fetch(
+    url: String,
+    headers: Map<String, String>,
+    signal: CancellationSignal,
+    onSuccess: (NativeByteBuffer) -> Unit,
+    onFailure: (Exception) -> Unit,
+  ) {
+    synchronized(stateLock) {
+      if (draining) {
+        return onFailure(IllegalStateException("Client is draining"))
+      }
+      activeCount++
+    }
+
+    val requestBuilder = Request.Builder().url(url)
+    headers.forEach { (key, value) -> requestBuilder.addHeader(key, value) }
+    val call = client.newCall(requestBuilder.build())
+    signal.setOnCancelListener(call::cancel)
+
+    call.enqueue(object : Callback {
+      override fun onFailure(call: Call, e: IOException) {
+        onFailure(e)
+        onComplete()
+      }
+
+      override fun onResponse(call: Call, response: Response) {
+        response.use {
+          if (!response.isSuccessful) {
+            return onFailure(IOException("HTTP ${response.code}: ${response.message}")).also { onComplete() }
+          }
+
+          val body = response.body
+            ?: return onFailure(IOException("Empty response body")).also { onComplete() }
+
+          if (call.isCanceled()) {
+            onFailure(OperationCanceledException())
+            return onComplete()
+          }
+
+          body.source().use { source ->
+            val length = body.contentLength().toInt()
+            val buffer = NativeByteBuffer(if (length > 0) length else INITIAL_BUFFER_SIZE)
+            try {
+              if (length > 0) {
+                val wrapped = NativeBuffer.wrap(buffer.pointer, length)
+                while (wrapped.hasRemaining()) {
+                  if (call.isCanceled()) throw OperationCanceledException()
+                  if (source.read(wrapped) == -1) throw EOFException()
+                }
+                buffer.advance(length)
+              } else {
+                while (true) {
+                  if (call.isCanceled()) throw OperationCanceledException()
+                  val bytesRead = source.read(buffer.wrapRemaining())
+                  if (bytesRead == -1) break
+                  buffer.advance(bytesRead)
+                  buffer.ensureHeadroom()
+                }
+              }
+              onSuccess(buffer)
+            } catch (e: Exception) {
+              buffer.free()
+              onFailure(e)
+            }
+            onComplete()
+          }
+        }
+      }
+    })
+  }
+
+  override fun drain() {
+    val shouldClose = synchronized(stateLock) {
+      if (draining) return
+      draining = true
+      activeCount == 0
+    }
+    client.connectionPool.evictAll()
+    if (shouldClose) {
+      client.cache?.close()
+    }
+  }
+
+  override fun clearCache(onCleared: (Result<Long>) -> Unit) {
+    try {
+      val size = client.cache!!.size()
+      client.cache!!.evictAll()
+      onCleared(Result.success(size))
+    } catch (e: Exception) {
+      onCleared(Result.failure(e))
+    }
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/images/ThumbHash.java

@@ -0,0 +1,166 @@
+package app.alextran.immich.images;
+
+// Copyright (c) 2023 Evan Wallace
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+import java.nio.ByteBuffer;
+
+import app.alextran.immich.NativeBuffer;
+
+// modified to use native allocations
+public final class ThumbHash {
+  /**
+   * Decodes a ThumbHash to an RGBA image. RGB is not be premultiplied by A.
+   *
+   * @param hash The bytes of the ThumbHash.
+   * @return The width, height, and pixels of the rendered placeholder image.
+   */
+  public static Image thumbHashToRGBA(byte[] hash) {
+    // Read the constants
+    int header24 = (hash[0] & 255) | ((hash[1] & 255) << 8) | ((hash[2] & 255) << 16);
+    int header16 = (hash[3] & 255) | ((hash[4] & 255) << 8);
+    float l_dc = (float) (header24 & 63) / 63.0f;
+    float p_dc = (float) ((header24 >> 6) & 63) / 31.5f - 1.0f;
+    float q_dc = (float) ((header24 >> 12) & 63) / 31.5f - 1.0f;
+    float l_scale = (float) ((header24 >> 18) & 31) / 31.0f;
+    boolean hasAlpha = (header24 >> 23) != 0;
+    float p_scale = (float) ((header16 >> 3) & 63) / 63.0f;
+    float q_scale = (float) ((header16 >> 9) & 63) / 63.0f;
+    boolean isLandscape = (header16 >> 15) != 0;
+    int lx = Math.max(3, isLandscape ? hasAlpha ? 5 : 7 : header16 & 7);
+    int ly = Math.max(3, isLandscape ? header16 & 7 : hasAlpha ? 5 : 7);
+    float a_dc = hasAlpha ? (float) (hash[5] & 15) / 15.0f : 1.0f;
+    float a_scale = (float) ((hash[5] >> 4) & 15) / 15.0f;
+
+    // Read the varying factors (boost saturation by 1.25x to compensate for quantization)
+    int ac_start = hasAlpha ? 6 : 5;
+    int ac_index = 0;
+    Channel l_channel = new Channel(lx, ly);
+    Channel p_channel = new Channel(3, 3);
+    Channel q_channel = new Channel(3, 3);
+    Channel a_channel = null;
+    ac_index = l_channel.decode(hash, ac_start, ac_index, l_scale);
+    ac_index = p_channel.decode(hash, ac_start, ac_index, p_scale * 1.25f);
+    ac_index = q_channel.decode(hash, ac_start, ac_index, q_scale * 1.25f);
+    if (hasAlpha) {
+      a_channel = new Channel(5, 5);
+      a_channel.decode(hash, ac_start, ac_index, a_scale);
+    }
+    float[] l_ac = l_channel.ac;
+    float[] p_ac = p_channel.ac;
+    float[] q_ac = q_channel.ac;
+    float[] a_ac = hasAlpha ? a_channel.ac : null;
+
+    // Decode using the DCT into RGB
+    float ratio = thumbHashToApproximateAspectRatio(hash);
+    int w = Math.round(ratio > 1.0f ? 32.0f : 32.0f * ratio);
+    int h = Math.round(ratio > 1.0f ? 32.0f / ratio : 32.0f);
+    int size = w * h * 4;
+    long pointer = NativeBuffer.allocate(size);
+    ByteBuffer rgba = NativeBuffer.wrap(pointer, size);
+    int cx_stop = Math.max(lx, hasAlpha ? 5 : 3);
+    int cy_stop = Math.max(ly, hasAlpha ? 5 : 3);
+    float[] fx = new float[cx_stop];
+    float[] fy = new float[cy_stop];
+    for (int y = 0, i = 0; y < h; y++) {
+      for (int x = 0; x < w; x++, i += 4) {
+        float l = l_dc, p = p_dc, q = q_dc, a = a_dc;
+
+        // Precompute the coefficients
+        for (int cx = 0; cx < cx_stop; cx++)
+          fx[cx] = (float) Math.cos(Math.PI / w * (x + 0.5f) * cx);
+        for (int cy = 0; cy < cy_stop; cy++)
+          fy[cy] = (float) Math.cos(Math.PI / h * (y + 0.5f) * cy);
+
+        // Decode L
+        for (int cy = 0, j = 0; cy < ly; cy++) {
+          float fy2 = fy[cy] * 2.0f;
+          for (int cx = cy > 0 ? 0 : 1; cx * ly < lx * (ly - cy); cx++, j++)
+            l += l_ac[j] * fx[cx] * fy2;
+        }
+
+        // Decode P and Q
+        for (int cy = 0, j = 0; cy < 3; cy++) {
+          float fy2 = fy[cy] * 2.0f;
+          for (int cx = cy > 0 ? 0 : 1; cx < 3 - cy; cx++, j++) {
+            float f = fx[cx] * fy2;
+            p += p_ac[j] * f;
+            q += q_ac[j] * f;
+          }
+        }
+
+        // Decode A
+        if (hasAlpha)
+          for (int cy = 0, j = 0; cy < 5; cy++) {
+            float fy2 = fy[cy] * 2.0f;
+            for (int cx = cy > 0 ? 0 : 1; cx < 5 - cy; cx++, j++)
+              a += a_ac[j] * fx[cx] * fy2;
+          }
+
+        // Convert to RGB
+        float b = l - 2.0f / 3.0f * p;
+        float r = (3.0f * l - b + q) / 2.0f;
+        float g = r - q;
+        rgba.put(i, (byte) Math.max(0, Math.round(255.0f * Math.min(1, r))));
+        rgba.put(i + 1, (byte) Math.max(0, Math.round(255.0f * Math.min(1, g))));
+        rgba.put(i + 2, (byte) Math.max(0, Math.round(255.0f * Math.min(1, b))));
+        rgba.put(i + 3, (byte) Math.max(0, Math.round(255.0f * Math.min(1, a))));
+      }
+    }
+    return new Image(w, h, pointer);
+  }
+
+  /**
+   * Extracts the approximate aspect ratio of the original image.
+   *
+   * @param hash The bytes of the ThumbHash.
+   * @return The approximate aspect ratio (i.e. width / height).
+   */
+  public static float thumbHashToApproximateAspectRatio(byte[] hash) {
+    byte header = hash[3];
+    boolean hasAlpha = (hash[2] & 0x80) != 0;
+    boolean isLandscape = (hash[4] & 0x80) != 0;
+    int lx = isLandscape ? hasAlpha ? 5 : 7 : header & 7;
+    int ly = isLandscape ? header & 7 : hasAlpha ? 5 : 7;
+    return (float) lx / (float) ly;
+  }
+
+  public static final class Image {
+    public int width;
+    public int height;
+    public long pointer;
+
+    public Image(int width, int height, long pointer) {
+      this.width = width;
+      this.height = height;
+      this.pointer = pointer;
+    }
+  }
+
+  private static final class Channel {
+    int nx;
+    int ny;
+    float[] ac;
+
+    Channel(int nx, int ny) {
+      this.nx = nx;
+      this.ny = ny;
+      int n = 0;
+      for (int cy = 0; cy < ny; cy++)
+        for (int cx = cy > 0 ? 0 : 1; cx * ny < nx * (ny - cy); cx++)
+          n++;
+      ac = new float[n];
+    }
+
+    int decode(byte[] hash, int start, int index, float scale) {
+      for (int i = 0; i < ac.length; i++) {
+        int data = hash[start + (index >> 1)] >> ((index & 1) << 2);
+        ac[i] = ((float) (data & 15) / 7.5f - 1.0f) * scale;
+        index++;
+      }
+      return index;
+    }
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/sync/Messages.g.kt

@@ -0,0 +1,574 @@
+// Autogenerated from Pigeon (v26.0.2), do not edit directly.
+// See also: https://pub.dev/packages/pigeon
+@file:Suppress("UNCHECKED_CAST", "ArrayInDataClass")
+
+package app.alextran.immich.sync
+
+import android.util.Log
+import io.flutter.plugin.common.BasicMessageChannel
+import io.flutter.plugin.common.BinaryMessenger
+import io.flutter.plugin.common.EventChannel
+import io.flutter.plugin.common.MessageCodec
+import io.flutter.plugin.common.StandardMethodCodec
+import io.flutter.plugin.common.StandardMessageCodec
+import java.io.ByteArrayOutputStream
+import java.nio.ByteBuffer
+private object MessagesPigeonUtils {
+
+  fun wrapResult(result: Any?): List<Any?> {
+    return listOf(result)
+  }
+
+  fun wrapError(exception: Throwable): List<Any?> {
+    return if (exception is FlutterError) {
+      listOf(
+        exception.code,
+        exception.message,
+        exception.details
+      )
+    } else {
+      listOf(
+        exception.javaClass.simpleName,
+        exception.toString(),
+        "Cause: " + exception.cause + ", Stacktrace: " + Log.getStackTraceString(exception)
+      )
+    }
+  }
+  fun deepEquals(a: Any?, b: Any?): Boolean {
+    if (a is ByteArray && b is ByteArray) {
+        return a.contentEquals(b)
+    }
+    if (a is IntArray && b is IntArray) {
+        return a.contentEquals(b)
+    }
+    if (a is LongArray && b is LongArray) {
+        return a.contentEquals(b)
+    }
+    if (a is DoubleArray && b is DoubleArray) {
+        return a.contentEquals(b)
+    }
+    if (a is Array<*> && b is Array<*>) {
+      return a.size == b.size &&
+          a.indices.all{ deepEquals(a[it], b[it]) }
+    }
+    if (a is List<*> && b is List<*>) {
+      return a.size == b.size &&
+          a.indices.all{ deepEquals(a[it], b[it]) }
+    }
+    if (a is Map<*, *> && b is Map<*, *>) {
+      return a.size == b.size && a.all {
+          (b as Map<Any?, Any?>).containsKey(it.key) &&
+          deepEquals(it.value, b[it.key])
+      }
+    }
+    return a == b
+  }
+      
+}
+
+/**
+ * Error class for passing custom error details to Flutter via a thrown PlatformException.
+ * @property code The error code.
+ * @property message The error message.
+ * @property details The error details. Must be a datatype supported by the api codec.
+ */
+class FlutterError (
+  val code: String,
+  override val message: String? = null,
+  val details: Any? = null
+) : Throwable()
+
+/** Generated class from Pigeon that represents data sent in messages. */
+data class PlatformAsset (
+  val id: String,
+  val name: String,
+  val type: Long,
+  val createdAt: Long? = null,
+  val updatedAt: Long? = null,
+  val width: Long? = null,
+  val height: Long? = null,
+  val durationInSeconds: Long,
+  val orientation: Long,
+  val isFavorite: Boolean,
+  val adjustmentTime: Long? = null,
+  val latitude: Double? = null,
+  val longitude: Double? = null
+)
+ {
+  companion object {
+    fun fromList(pigeonVar_list: List<Any?>): PlatformAsset {
+      val id = pigeonVar_list[0] as String
+      val name = pigeonVar_list[1] as String
+      val type = pigeonVar_list[2] as Long
+      val createdAt = pigeonVar_list[3] as Long?
+      val updatedAt = pigeonVar_list[4] as Long?
+      val width = pigeonVar_list[5] as Long?
+      val height = pigeonVar_list[6] as Long?
+      val durationInSeconds = pigeonVar_list[7] as Long
+      val orientation = pigeonVar_list[8] as Long
+      val isFavorite = pigeonVar_list[9] as Boolean
+      val adjustmentTime = pigeonVar_list[10] as Long?
+      val latitude = pigeonVar_list[11] as Double?
+      val longitude = pigeonVar_list[12] as Double?
+      return PlatformAsset(id, name, type, createdAt, updatedAt, width, height, durationInSeconds, orientation, isFavorite, adjustmentTime, latitude, longitude)
+    }
+  }
+  fun toList(): List<Any?> {
+    return listOf(
+      id,
+      name,
+      type,
+      createdAt,
+      updatedAt,
+      width,
+      height,
+      durationInSeconds,
+      orientation,
+      isFavorite,
+      adjustmentTime,
+      latitude,
+      longitude,
+    )
+  }
+  override fun equals(other: Any?): Boolean {
+    if (other !is PlatformAsset) {
+      return false
+    }
+    if (this === other) {
+      return true
+    }
+    return MessagesPigeonUtils.deepEquals(toList(), other.toList())  }
+
+  override fun hashCode(): Int = toList().hashCode()
+}
+
+/** Generated class from Pigeon that represents data sent in messages. */
+data class PlatformAlbum (
+  val id: String,
+  val name: String,
+  val updatedAt: Long? = null,
+  val isCloud: Boolean,
+  val assetCount: Long
+)
+ {
+  companion object {
+    fun fromList(pigeonVar_list: List<Any?>): PlatformAlbum {
+      val id = pigeonVar_list[0] as String
+      val name = pigeonVar_list[1] as String
+      val updatedAt = pigeonVar_list[2] as Long?
+      val isCloud = pigeonVar_list[3] as Boolean
+      val assetCount = pigeonVar_list[4] as Long
+      return PlatformAlbum(id, name, updatedAt, isCloud, assetCount)
+    }
+  }
+  fun toList(): List<Any?> {
+    return listOf(
+      id,
+      name,
+      updatedAt,
+      isCloud,
+      assetCount,
+    )
+  }
+  override fun equals(other: Any?): Boolean {
+    if (other !is PlatformAlbum) {
+      return false
+    }
+    if (this === other) {
+      return true
+    }
+    return MessagesPigeonUtils.deepEquals(toList(), other.toList())  }
+
+  override fun hashCode(): Int = toList().hashCode()
+}
+
+/** Generated class from Pigeon that represents data sent in messages. */
+data class SyncDelta (
+  val hasChanges: Boolean,
+  val updates: List<PlatformAsset>,
+  val deletes: List<String>,
+  val assetAlbums: Map<String, List<String>>
+)
+ {
+  companion object {
+    fun fromList(pigeonVar_list: List<Any?>): SyncDelta {
+      val hasChanges = pigeonVar_list[0] as Boolean
+      val updates = pigeonVar_list[1] as List<PlatformAsset>
+      val deletes = pigeonVar_list[2] as List<String>
+      val assetAlbums = pigeonVar_list[3] as Map<String, List<String>>
+      return SyncDelta(hasChanges, updates, deletes, assetAlbums)
+    }
+  }
+  fun toList(): List<Any?> {
+    return listOf(
+      hasChanges,
+      updates,
+      deletes,
+      assetAlbums,
+    )
+  }
+  override fun equals(other: Any?): Boolean {
+    if (other !is SyncDelta) {
+      return false
+    }
+    if (this === other) {
+      return true
+    }
+    return MessagesPigeonUtils.deepEquals(toList(), other.toList())  }
+
+  override fun hashCode(): Int = toList().hashCode()
+}
+
+/** Generated class from Pigeon that represents data sent in messages. */
+data class HashResult (
+  val assetId: String,
+  val error: String? = null,
+  val hash: String? = null
+)
+ {
+  companion object {
+    fun fromList(pigeonVar_list: List<Any?>): HashResult {
+      val assetId = pigeonVar_list[0] as String
+      val error = pigeonVar_list[1] as String?
+      val hash = pigeonVar_list[2] as String?
+      return HashResult(assetId, error, hash)
+    }
+  }
+  fun toList(): List<Any?> {
+    return listOf(
+      assetId,
+      error,
+      hash,
+    )
+  }
+  override fun equals(other: Any?): Boolean {
+    if (other !is HashResult) {
+      return false
+    }
+    if (this === other) {
+      return true
+    }
+    return MessagesPigeonUtils.deepEquals(toList(), other.toList())  }
+
+  override fun hashCode(): Int = toList().hashCode()
+}
+
+/** Generated class from Pigeon that represents data sent in messages. */
+data class CloudIdResult (
+  val assetId: String,
+  val error: String? = null,
+  val cloudId: String? = null
+)
+ {
+  companion object {
+    fun fromList(pigeonVar_list: List<Any?>): CloudIdResult {
+      val assetId = pigeonVar_list[0] as String
+      val error = pigeonVar_list[1] as String?
+      val cloudId = pigeonVar_list[2] as String?
+      return CloudIdResult(assetId, error, cloudId)
+    }
+  }
+  fun toList(): List<Any?> {
+    return listOf(
+      assetId,
+      error,
+      cloudId,
+    )
+  }
+  override fun equals(other: Any?): Boolean {
+    if (other !is CloudIdResult) {
+      return false
+    }
+    if (this === other) {
+      return true
+    }
+    return MessagesPigeonUtils.deepEquals(toList(), other.toList())  }
+
+  override fun hashCode(): Int = toList().hashCode()
+}
+private open class MessagesPigeonCodec : StandardMessageCodec() {
+  override fun readValueOfType(type: Byte, buffer: ByteBuffer): Any? {
+    return when (type) {
+      129.toByte() -> {
+        return (readValue(buffer) as? List<Any?>)?.let {
+          PlatformAsset.fromList(it)
+        }
+      }
+      130.toByte() -> {
+        return (readValue(buffer) as? List<Any?>)?.let {
+          PlatformAlbum.fromList(it)
+        }
+      }
+      131.toByte() -> {
+        return (readValue(buffer) as? List<Any?>)?.let {
+          SyncDelta.fromList(it)
+        }
+      }
+      132.toByte() -> {
+        return (readValue(buffer) as? List<Any?>)?.let {
+          HashResult.fromList(it)
+        }
+      }
+      133.toByte() -> {
+        return (readValue(buffer) as? List<Any?>)?.let {
+          CloudIdResult.fromList(it)
+        }
+      }
+      else -> super.readValueOfType(type, buffer)
+    }
+  }
+  override fun writeValue(stream: ByteArrayOutputStream, value: Any?)   {
+    when (value) {
+      is PlatformAsset -> {
+        stream.write(129)
+        writeValue(stream, value.toList())
+      }
+      is PlatformAlbum -> {
+        stream.write(130)
+        writeValue(stream, value.toList())
+      }
+      is SyncDelta -> {
+        stream.write(131)
+        writeValue(stream, value.toList())
+      }
+      is HashResult -> {
+        stream.write(132)
+        writeValue(stream, value.toList())
+      }
+      is CloudIdResult -> {
+        stream.write(133)
+        writeValue(stream, value.toList())
+      }
+      else -> super.writeValue(stream, value)
+    }
+  }
+}
+
+
+/** Generated interface from Pigeon that represents a handler of messages from Flutter. */
+interface NativeSyncApi {
+  fun shouldFullSync(): Boolean
+  fun getMediaChanges(): SyncDelta
+  fun checkpointSync()
+  fun clearSyncCheckpoint()
+  fun getAssetIdsForAlbum(albumId: String): List<String>
+  fun getAlbums(): List<PlatformAlbum>
+  fun getAssetsCountSince(albumId: String, timestamp: Long): Long
+  fun getAssetsForAlbum(albumId: String, updatedTimeCond: Long?): List<PlatformAsset>
+  fun hashAssets(assetIds: List<String>, allowNetworkAccess: Boolean, callback: (Result<List<HashResult>>) -> Unit)
+  fun cancelHashing()
+  fun getTrashedAssets(): Map<String, List<PlatformAsset>>
+  fun getCloudIdForAssetIds(assetIds: List<String>): List<CloudIdResult>
+
+  companion object {
+    /** The codec used by NativeSyncApi. */
+    val codec: MessageCodec<Any?> by lazy {
+      MessagesPigeonCodec()
+    }
+    /** Sets up an instance of `NativeSyncApi` to handle messages through the `binaryMessenger`. */
+    @JvmOverloads
+    fun setUp(binaryMessenger: BinaryMessenger, api: NativeSyncApi?, messageChannelSuffix: String = "") {
+      val separatedMessageChannelSuffix = if (messageChannelSuffix.isNotEmpty()) ".$messageChannelSuffix" else ""
+      val taskQueue = binaryMessenger.makeBackgroundTaskQueue()
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.NativeSyncApi.shouldFullSync$separatedMessageChannelSuffix", codec)
+        if (api != null) {
+          channel.setMessageHandler { _, reply ->
+            val wrapped: List<Any?> = try {
+              listOf(api.shouldFullSync())
+            } catch (exception: Throwable) {
+              MessagesPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.NativeSyncApi.getMediaChanges$separatedMessageChannelSuffix", codec, taskQueue)
+        if (api != null) {
+          channel.setMessageHandler { _, reply ->
+            val wrapped: List<Any?> = try {
+              listOf(api.getMediaChanges())
+            } catch (exception: Throwable) {
+              MessagesPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.NativeSyncApi.checkpointSync$separatedMessageChannelSuffix", codec)
+        if (api != null) {
+          channel.setMessageHandler { _, reply ->
+            val wrapped: List<Any?> = try {
+              api.checkpointSync()
+              listOf(null)
+            } catch (exception: Throwable) {
+              MessagesPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.NativeSyncApi.clearSyncCheckpoint$separatedMessageChannelSuffix", codec)
+        if (api != null) {
+          channel.setMessageHandler { _, reply ->
+            val wrapped: List<Any?> = try {
+              api.clearSyncCheckpoint()
+              listOf(null)
+            } catch (exception: Throwable) {
+              MessagesPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.NativeSyncApi.getAssetIdsForAlbum$separatedMessageChannelSuffix", codec, taskQueue)
+        if (api != null) {
+          channel.setMessageHandler { message, reply ->
+            val args = message as List<Any?>
+            val albumIdArg = args[0] as String
+            val wrapped: List<Any?> = try {
+              listOf(api.getAssetIdsForAlbum(albumIdArg))
+            } catch (exception: Throwable) {
+              MessagesPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.NativeSyncApi.getAlbums$separatedMessageChannelSuffix", codec, taskQueue)
+        if (api != null) {
+          channel.setMessageHandler { _, reply ->
+            val wrapped: List<Any?> = try {
+              listOf(api.getAlbums())
+            } catch (exception: Throwable) {
+              MessagesPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.NativeSyncApi.getAssetsCountSince$separatedMessageChannelSuffix", codec, taskQueue)
+        if (api != null) {
+          channel.setMessageHandler { message, reply ->
+            val args = message as List<Any?>
+            val albumIdArg = args[0] as String
+            val timestampArg = args[1] as Long
+            val wrapped: List<Any?> = try {
+              listOf(api.getAssetsCountSince(albumIdArg, timestampArg))
+            } catch (exception: Throwable) {
+              MessagesPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.NativeSyncApi.getAssetsForAlbum$separatedMessageChannelSuffix", codec, taskQueue)
+        if (api != null) {
+          channel.setMessageHandler { message, reply ->
+            val args = message as List<Any?>
+            val albumIdArg = args[0] as String
+            val updatedTimeCondArg = args[1] as Long?
+            val wrapped: List<Any?> = try {
+              listOf(api.getAssetsForAlbum(albumIdArg, updatedTimeCondArg))
+            } catch (exception: Throwable) {
+              MessagesPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.NativeSyncApi.hashAssets$separatedMessageChannelSuffix", codec, taskQueue)
+        if (api != null) {
+          channel.setMessageHandler { message, reply ->
+            val args = message as List<Any?>
+            val assetIdsArg = args[0] as List<String>
+            val allowNetworkAccessArg = args[1] as Boolean
+            api.hashAssets(assetIdsArg, allowNetworkAccessArg) { result: Result<List<HashResult>> ->
+              val error = result.exceptionOrNull()
+              if (error != null) {
+                reply.reply(MessagesPigeonUtils.wrapError(error))
+              } else {
+                val data = result.getOrNull()
+                reply.reply(MessagesPigeonUtils.wrapResult(data))
+              }
+            }
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.NativeSyncApi.cancelHashing$separatedMessageChannelSuffix", codec)
+        if (api != null) {
+          channel.setMessageHandler { _, reply ->
+            val wrapped: List<Any?> = try {
+              api.cancelHashing()
+              listOf(null)
+            } catch (exception: Throwable) {
+              MessagesPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.NativeSyncApi.getTrashedAssets$separatedMessageChannelSuffix", codec, taskQueue)
+        if (api != null) {
+          channel.setMessageHandler { _, reply ->
+            val wrapped: List<Any?> = try {
+              listOf(api.getTrashedAssets())
+            } catch (exception: Throwable) {
+              MessagesPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+      run {
+        val channel = BasicMessageChannel<Any?>(binaryMessenger, "dev.flutter.pigeon.immich_mobile.NativeSyncApi.getCloudIdForAssetIds$separatedMessageChannelSuffix", codec, taskQueue)
+        if (api != null) {
+          channel.setMessageHandler { message, reply ->
+            val args = message as List<Any?>
+            val assetIdsArg = args[0] as List<String>
+            val wrapped: List<Any?> = try {
+              listOf(api.getCloudIdForAssetIds(assetIdsArg))
+            } catch (exception: Throwable) {
+              MessagesPigeonUtils.wrapError(exception)
+            }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
+    }
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/sync/MessagesImpl26.kt

@@ -0,0 +1,29 @@
+package app.alextran.immich.sync
+
+import android.content.Context
+
+
+class NativeSyncApiImpl26(context: Context) : NativeSyncApiImplBase(context), NativeSyncApi {
+  override fun shouldFullSync(): Boolean {
+    return true
+  }
+
+  // No-op for Android 10 and below
+  override fun checkpointSync() {
+    // Cannot throw exception as this is called from the Dart side
+    // during the full sync process as well
+  }
+
+  override fun clearSyncCheckpoint() {
+    // No-op for Android 10 and below
+  }
+
+  override fun getMediaChanges(): SyncDelta {
+    throw IllegalStateException("Method not supported on this Android version.")
+  }
+
+  override fun getTrashedAssets(): Map<String, List<PlatformAsset>> {
+    //Method not supported on this Android version.
+    return emptyMap()
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/sync/MessagesImpl30.kt

@@ -0,0 +1,116 @@
+package app.alextran.immich.sync
+
+import android.content.ContentResolver
+import android.content.Context
+import android.os.Build
+import android.os.Bundle
+import android.provider.MediaStore
+import androidx.annotation.RequiresApi
+import androidx.annotation.RequiresExtension
+import kotlinx.serialization.json.Json
+
+@RequiresApi(Build.VERSION_CODES.Q)
+@RequiresExtension(extension = Build.VERSION_CODES.R, version = 1)
+class NativeSyncApiImpl30(context: Context) : NativeSyncApiImplBase(context), NativeSyncApi {
+  private val ctx: Context = context.applicationContext
+  private val prefs = ctx.getSharedPreferences(SHARED_PREF_NAME, Context.MODE_PRIVATE)
+
+  companion object {
+    const val SHARED_PREF_NAME = "Immich::MediaManager"
+    const val SHARED_PREF_MEDIA_STORE_VERSION_KEY = "MediaStore::getVersion"
+    const val SHARED_PREF_MEDIA_STORE_GEN_KEY = "MediaStore::getGeneration"
+  }
+
+  private fun getSavedGenerationMap(): Map<String, Long> {
+    return prefs.getString(SHARED_PREF_MEDIA_STORE_GEN_KEY, null)?.let {
+      Json.decodeFromString<Map<String, Long>>(it)
+    } ?: emptyMap()
+  }
+
+  override fun clearSyncCheckpoint() {
+    prefs.edit().apply {
+      remove(SHARED_PREF_MEDIA_STORE_VERSION_KEY)
+      remove(SHARED_PREF_MEDIA_STORE_GEN_KEY)
+      apply()
+    }
+  }
+
+  override fun shouldFullSync(): Boolean =
+    MediaStore.getVersion(ctx) != prefs.getString(SHARED_PREF_MEDIA_STORE_VERSION_KEY, null)
+
+  override fun checkpointSync() {
+    val genMap = MediaStore.getExternalVolumeNames(ctx)
+      .associateWith { MediaStore.getGeneration(ctx, it) }
+
+    prefs.edit().apply {
+      putString(SHARED_PREF_MEDIA_STORE_VERSION_KEY, MediaStore.getVersion(ctx))
+      putString(SHARED_PREF_MEDIA_STORE_GEN_KEY, Json.encodeToString(genMap))
+      apply()
+    }
+  }
+
+  override fun getMediaChanges(): SyncDelta {
+    val genMap = getSavedGenerationMap()
+    val currentVolumes = MediaStore.getExternalVolumeNames(ctx)
+    val changed = mutableListOf<PlatformAsset>()
+    val deleted = mutableListOf<String>()
+    val assetAlbums = mutableMapOf<String, List<String>>()
+    var hasChanges = genMap.keys != currentVolumes
+
+    for (volume in currentVolumes) {
+      val currentGen = MediaStore.getGeneration(ctx, volume)
+      val storedGen = genMap[volume] ?: 0
+      if (currentGen <= storedGen) {
+        continue
+      }
+
+      hasChanges = true
+
+      val selection =
+        "$MEDIA_SELECTION AND (${MediaStore.MediaColumns.GENERATION_MODIFIED} > ? OR ${MediaStore.MediaColumns.GENERATION_ADDED} > ?)"
+      val selectionArgs = arrayOf(
+        *MEDIA_SELECTION_ARGS,
+        storedGen.toString(),
+        storedGen.toString()
+      )
+
+      getAssets(getCursor(volume, selection, selectionArgs)).forEach {
+        when (it) {
+          is AssetResult.ValidAsset -> {
+            changed.add(it.asset)
+            assetAlbums[it.asset.id] = listOf(it.albumId)
+          }
+
+          is AssetResult.InvalidAsset -> deleted.add(it.assetId)
+        }
+      }
+    }
+    // Unmounted volumes are handled in dart when the album is removed
+    return SyncDelta(hasChanges, changed, deleted, assetAlbums)
+  }
+
+  override fun getTrashedAssets(): Map<String, List<PlatformAsset>> {
+
+    val result = LinkedHashMap<String, MutableList<PlatformAsset>>()
+    val volumes = MediaStore.getExternalVolumeNames(ctx)
+
+    for (volume in volumes) {
+
+      val queryArgs = Bundle().apply {
+        putString(ContentResolver.QUERY_ARG_SQL_SELECTION, MEDIA_SELECTION)
+        putStringArray(ContentResolver.QUERY_ARG_SQL_SELECTION_ARGS, MEDIA_SELECTION_ARGS)
+        putInt(MediaStore.QUERY_ARG_MATCH_TRASHED, MediaStore.MATCH_ONLY)
+      }
+
+      getCursor(volume, queryArgs).use { cursor ->
+        getAssets(cursor).forEach { res ->
+          if (res is AssetResult.ValidAsset) {
+            result.getOrPut(res.albumId) { mutableListOf() }.add(res.asset)
+          }
+        }
+      }
+    }
+
+    return result.mapValues { it.value.toList() }
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/sync/MessagesImplBase.kt

@@ -0,0 +1,325 @@
+package app.alextran.immich.sync
+
+import android.annotation.SuppressLint
+import android.content.ContentUris
+import android.content.Context
+import android.database.Cursor
+import android.os.Bundle
+import android.provider.MediaStore
+import android.util.Base64
+import androidx.core.database.getStringOrNull
+import app.alextran.immich.core.ImmichPlugin
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.ensureActive
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Semaphore
+import kotlinx.coroutines.sync.withPermit
+import java.io.File
+import java.security.MessageDigest
+import kotlin.coroutines.cancellation.CancellationException
+
+sealed class AssetResult {
+  data class ValidAsset(val asset: PlatformAsset, val albumId: String) : AssetResult()
+  data class InvalidAsset(val assetId: String) : AssetResult()
+}
+
+@SuppressLint("InlinedApi")
+open class NativeSyncApiImplBase(context: Context) : ImmichPlugin() {
+  private val ctx: Context = context.applicationContext
+
+  private var hashTask: Job? = null
+
+  companion object {
+    private const val MAX_CONCURRENT_HASH_OPERATIONS = 16
+    private val hashSemaphore = Semaphore(MAX_CONCURRENT_HASH_OPERATIONS)
+    private const val HASHING_CANCELLED_CODE = "HASH_CANCELLED"
+
+    const val MEDIA_SELECTION =
+      "(${MediaStore.Files.FileColumns.MEDIA_TYPE} = ? OR ${MediaStore.Files.FileColumns.MEDIA_TYPE} = ?)"
+    val MEDIA_SELECTION_ARGS = arrayOf(
+      MediaStore.Files.FileColumns.MEDIA_TYPE_IMAGE.toString(),
+      MediaStore.Files.FileColumns.MEDIA_TYPE_VIDEO.toString()
+    )
+    const val BUCKET_SELECTION = "(${MediaStore.Files.FileColumns.BUCKET_ID} = ?)"
+    val ASSET_PROJECTION = buildList {
+      add(MediaStore.MediaColumns._ID)
+      add(MediaStore.MediaColumns.DATA)
+      add(MediaStore.MediaColumns.DISPLAY_NAME)
+      add(MediaStore.MediaColumns.DATE_TAKEN)
+      add(MediaStore.MediaColumns.DATE_ADDED)
+      add(MediaStore.MediaColumns.DATE_MODIFIED)
+      add(MediaStore.Files.FileColumns.MEDIA_TYPE)
+      add(MediaStore.MediaColumns.BUCKET_ID)
+      add(MediaStore.MediaColumns.WIDTH)
+      add(MediaStore.MediaColumns.HEIGHT)
+      add(MediaStore.MediaColumns.DURATION)
+      add(MediaStore.MediaColumns.ORIENTATION)
+      // IS_FAVORITE is only available on Android 11 and above
+      if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.R) {
+        add(MediaStore.MediaColumns.IS_FAVORITE)
+      }
+    }.toTypedArray()
+
+    const val HASH_BUFFER_SIZE = 2 * 1024 * 1024
+  }
+
+  protected fun getCursor(
+    volume: String,
+    selection: String,
+    selectionArgs: Array<String>,
+    projection: Array<String> = ASSET_PROJECTION,
+    sortOrder: String? = null
+  ): Cursor? = ctx.contentResolver.query(
+    MediaStore.Files.getContentUri(volume),
+    projection,
+    selection,
+    selectionArgs,
+    sortOrder,
+  )
+
+  protected fun getCursor(
+    volume: String,
+    queryArgs: Bundle
+  ): Cursor? = ctx.contentResolver.query(
+    MediaStore.Files.getContentUri(volume),
+    ASSET_PROJECTION,
+    queryArgs,
+    null
+  )
+
+  protected fun getAssets(cursor: Cursor?): Sequence<AssetResult> {
+    return sequence {
+      cursor?.use { c ->
+        val idColumn = c.getColumnIndexOrThrow(MediaStore.MediaColumns._ID)
+        val dataColumn = c.getColumnIndexOrThrow(MediaStore.MediaColumns.DATA)
+        val nameColumn = c.getColumnIndexOrThrow(MediaStore.MediaColumns.DISPLAY_NAME)
+        val dateTakenColumn = c.getColumnIndexOrThrow(MediaStore.MediaColumns.DATE_TAKEN)
+        val dateAddedColumn = c.getColumnIndexOrThrow(MediaStore.MediaColumns.DATE_ADDED)
+        val dateModifiedColumn = c.getColumnIndexOrThrow(MediaStore.MediaColumns.DATE_MODIFIED)
+        val mediaTypeColumn = c.getColumnIndexOrThrow(MediaStore.Files.FileColumns.MEDIA_TYPE)
+        val bucketIdColumn = c.getColumnIndexOrThrow(MediaStore.MediaColumns.BUCKET_ID)
+        val widthColumn = c.getColumnIndexOrThrow(MediaStore.MediaColumns.WIDTH)
+        val heightColumn = c.getColumnIndexOrThrow(MediaStore.MediaColumns.HEIGHT)
+        val durationColumn = c.getColumnIndexOrThrow(MediaStore.MediaColumns.DURATION)
+        val orientationColumn =
+          c.getColumnIndexOrThrow(MediaStore.MediaColumns.ORIENTATION)
+        val favoriteColumn = c.getColumnIndex(MediaStore.MediaColumns.IS_FAVORITE)
+
+        while (c.moveToNext()) {
+          val id = c.getLong(idColumn).toString()
+          val name = c.getStringOrNull(nameColumn)
+          val bucketId = c.getStringOrNull(bucketIdColumn)
+          val path = c.getStringOrNull(dataColumn)
+
+          // Skip assets with invalid metadata
+          if (
+            name.isNullOrBlank() || bucketId.isNullOrBlank() ||
+            path.isNullOrBlank() || !File(path).exists()
+          ) {
+            yield(AssetResult.InvalidAsset(id))
+            continue
+          }
+
+          val mediaType = when (c.getInt(mediaTypeColumn)) {
+            MediaStore.Files.FileColumns.MEDIA_TYPE_IMAGE -> 1
+            MediaStore.Files.FileColumns.MEDIA_TYPE_VIDEO -> 2
+            else -> 0
+          }
+          // Date taken is milliseconds since epoch, Date added is seconds since epoch
+          val createdAt = (c.getLong(dateTakenColumn).takeIf { it > 0 }?.div(1000))
+            ?: c.getLong(dateAddedColumn)
+          // Date modified is seconds since epoch
+          val modifiedAt = c.getLong(dateModifiedColumn)
+          val width = c.getInt(widthColumn).toLong()
+          val height = c.getInt(heightColumn).toLong()
+          // Duration is milliseconds
+          val duration = if (mediaType == MediaStore.Files.FileColumns.MEDIA_TYPE_IMAGE) 0
+          else c.getLong(durationColumn) / 1000
+          val orientation = c.getInt(orientationColumn)
+          val isFavorite = if (favoriteColumn == -1) false else c.getInt(favoriteColumn) != 0
+
+          val asset = PlatformAsset(
+            id,
+            name,
+            mediaType.toLong(),
+            createdAt,
+            modifiedAt,
+            width,
+            height,
+            duration,
+            orientation.toLong(),
+            isFavorite,
+          )
+          yield(AssetResult.ValidAsset(asset, bucketId))
+        }
+      }
+    }
+  }
+
+  fun getAlbums(): List<PlatformAlbum> {
+    val albums = mutableListOf<PlatformAlbum>()
+    val albumsCount = mutableMapOf<String, Int>()
+
+    val projection = arrayOf(
+      MediaStore.Files.FileColumns.BUCKET_ID,
+      MediaStore.Files.FileColumns.BUCKET_DISPLAY_NAME,
+      MediaStore.Files.FileColumns.DATE_MODIFIED,
+    )
+    val selection =
+      "(${MediaStore.Files.FileColumns.BUCKET_ID} IS NOT NULL) AND $MEDIA_SELECTION"
+
+    getCursor(
+      MediaStore.VOLUME_EXTERNAL,
+      selection,
+      MEDIA_SELECTION_ARGS,
+      projection,
+      "${MediaStore.Files.FileColumns.DATE_MODIFIED} DESC"
+    )?.use { cursor ->
+      val bucketIdColumn =
+        cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns.BUCKET_ID)
+      val bucketNameColumn =
+        cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns.BUCKET_DISPLAY_NAME)
+      val dateModified =
+        cursor.getColumnIndexOrThrow(MediaStore.Files.FileColumns.DATE_MODIFIED)
+
+      while (cursor.moveToNext()) {
+        val id = cursor.getString(bucketIdColumn)
+
+        val count = albumsCount.getOrDefault(id, 0)
+        if (count != 0) {
+          albumsCount[id] = count + 1
+          continue
+        }
+
+        // MediaStore might return null for bucket name (commonly for the Root Directory), so default to "Internal Storage"
+        val name = cursor.getStringOrNull(bucketNameColumn) ?: "Internal Storage"
+        val updatedAt = cursor.getLong(dateModified)
+        albums.add(PlatformAlbum(id, name, updatedAt, false, 0))
+        albumsCount[id] = 1
+      }
+    }
+
+    return albums.map { it.copy(assetCount = albumsCount[it.id]?.toLong() ?: 0) }
+      .sortedBy { it.id }
+  }
+
+  fun getAssetIdsForAlbum(albumId: String): List<String> {
+    val projection = arrayOf(MediaStore.MediaColumns._ID)
+
+    return getCursor(
+      MediaStore.VOLUME_EXTERNAL,
+      "$BUCKET_SELECTION AND $MEDIA_SELECTION",
+      arrayOf(albumId, *MEDIA_SELECTION_ARGS),
+      projection
+    )?.use { cursor ->
+      val idColumn = cursor.getColumnIndexOrThrow(MediaStore.MediaColumns._ID)
+      generateSequence {
+        if (cursor.moveToNext()) cursor.getLong(idColumn).toString() else null
+      }.toList()
+    } ?: emptyList()
+  }
+
+  fun getAssetsCountSince(albumId: String, timestamp: Long): Long =
+    getCursor(
+      MediaStore.VOLUME_EXTERNAL,
+      "$BUCKET_SELECTION AND ${MediaStore.Files.FileColumns.DATE_ADDED} > ? AND $MEDIA_SELECTION",
+      arrayOf(albumId, timestamp.toString(), *MEDIA_SELECTION_ARGS),
+    )?.use { cursor -> cursor.count.toLong() } ?: 0L
+
+
+  fun getAssetsForAlbum(albumId: String, updatedTimeCond: Long?): List<PlatformAsset> {
+    var selection = "$BUCKET_SELECTION AND $MEDIA_SELECTION"
+    val selectionArgs = mutableListOf(albumId, *MEDIA_SELECTION_ARGS)
+
+    if (updatedTimeCond != null) {
+      selection += " AND (${MediaStore.Files.FileColumns.DATE_MODIFIED} > ? OR ${MediaStore.Files.FileColumns.DATE_ADDED} > ?)"
+      selectionArgs.addAll(listOf(updatedTimeCond.toString(), updatedTimeCond.toString()))
+    }
+
+    return getAssets(getCursor(MediaStore.VOLUME_EXTERNAL, selection, selectionArgs.toTypedArray()))
+      .mapNotNull { result -> (result as? AssetResult.ValidAsset)?.asset }
+      .toList()
+  }
+
+  fun hashAssets(
+    assetIds: List<String>,
+    // allowNetworkAccess is only used on the iOS implementation
+    @Suppress("UNUSED_PARAMETER") allowNetworkAccess: Boolean,
+    callback: (Result<List<HashResult>>) -> Unit
+  ) {
+    if (assetIds.isEmpty()) {
+      completeWhenActive(callback, Result.success(emptyList()))
+      return
+    }
+
+    hashTask?.cancel()
+    hashTask = CoroutineScope(Dispatchers.IO).launch {
+      try {
+        val results = assetIds.map { assetId ->
+          async {
+            hashSemaphore.withPermit {
+              ensureActive()
+              hashAsset(assetId)
+            }
+          }
+        }.awaitAll()
+
+        completeWhenActive(callback, Result.success(results))
+      } catch (e: CancellationException) {
+        completeWhenActive(
+          callback, Result.failure(
+            FlutterError(
+              HASHING_CANCELLED_CODE,
+              "Hashing operation was cancelled",
+              null
+            )
+          )
+        )
+      } catch (e: Exception) {
+        completeWhenActive(callback, Result.failure(e))
+      }
+    }
+  }
+
+  private suspend fun hashAsset(assetId: String): HashResult {
+    return try {
+      val assetUri = ContentUris.withAppendedId(
+        MediaStore.Files.getContentUri(MediaStore.VOLUME_EXTERNAL),
+        assetId.toLong()
+      )
+
+      val digest = MessageDigest.getInstance("SHA-1")
+      ctx.contentResolver.openInputStream(assetUri)?.use { inputStream ->
+        var bytesRead: Int
+        val buffer = ByteArray(HASH_BUFFER_SIZE)
+        while (inputStream.read(buffer).also { bytesRead = it } > 0) {
+          currentCoroutineContext().ensureActive()
+          digest.update(buffer, 0, bytesRead)
+        }
+      } ?: return HashResult(assetId, "Cannot open input stream for asset", null)
+
+      val hashString = Base64.encodeToString(digest.digest(), Base64.NO_WRAP)
+      HashResult(assetId, null, hashString)
+    } catch (e: SecurityException) {
+      HashResult(assetId, "Permission denied accessing asset: ${e.message}", null)
+    } catch (e: Exception) {
+      HashResult(assetId, "Failed to hash asset: ${e.message}", null)
+    }
+  }
+
+  fun cancelHashing() {
+    hashTask?.cancel()
+    hashTask = null
+  }
+
+  // This method is only implemented on iOS; on Android, we do not have a concept of cloud IDs
+  @Suppress("unused", "UNUSED_PARAMETER")
+  fun getCloudIdForAssetIds(assetIds: List<String>): List<CloudIdResult> {
+    return emptyList()
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/widget/BitmapUtils.kt

@@ -0,0 +1,33 @@
+package app.alextran.immich.widget
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import java.io.File
+
+fun loadScaledBitmap(file: File, reqWidth: Int, reqHeight: Int): Bitmap? {
+  val options = BitmapFactory.Options().apply {
+    inJustDecodeBounds = true
+  }
+  BitmapFactory.decodeFile(file.absolutePath, options)
+
+  options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight)
+  options.inJustDecodeBounds = false
+
+  return BitmapFactory.decodeFile(file.absolutePath, options)
+}
+
+fun calculateInSampleSize(options: BitmapFactory.Options, reqWidth: Int, reqHeight: Int): Int {
+  val (height: Int, width: Int) = options.run { outHeight to outWidth }
+  var inSampleSize = 1
+
+  if (height > reqHeight || width > reqWidth) {
+    val halfHeight: Int = height / 2
+    val halfWidth: Int = width / 2
+
+    while ((halfHeight / inSampleSize) >= reqHeight && (halfWidth / inSampleSize) >= reqWidth) {
+      inSampleSize *= 2
+    }
+  }
+
+  return inSampleSize
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/widget/ImageDownloadWorker.kt

@@ -0,0 +1,244 @@
+package app.alextran.immich.widget
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.util.Log
+import androidx.datastore.preferences.core.Preferences
+import androidx.glance.*
+import androidx.glance.appwidget.GlanceAppWidgetManager
+import androidx.glance.appwidget.state.updateAppWidgetState
+import androidx.work.*
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.io.File
+import java.io.FileOutputStream
+import java.util.UUID
+import java.util.concurrent.TimeUnit
+import androidx.glance.appwidget.state.getAppWidgetState
+import androidx.glance.state.PreferencesGlanceStateDefinition
+import app.alextran.immich.widget.model.*
+import java.time.LocalDate
+
+class ImageDownloadWorker(
+  private val context: Context,
+  workerParameters: WorkerParameters
+) : CoroutineWorker(context, workerParameters) {
+
+  companion object {
+
+    private val uniqueWorkName = ImageDownloadWorker::class.java.simpleName
+
+    private fun buildConstraints(): Constraints {
+      return Constraints.Builder()
+        .setRequiredNetworkType(NetworkType.CONNECTED)
+        .build()
+    }
+
+    private fun buildInputData(appWidgetId: Int, widgetType: WidgetType): Data {
+      return Data.Builder()
+        .putString(kWorkerWidgetType, widgetType.toString())
+        .putInt(kWorkerWidgetID, appWidgetId)
+        .build()
+    }
+
+    fun enqueuePeriodic(context: Context, appWidgetId: Int, widgetType: WidgetType) {
+      val manager = WorkManager.getInstance(context)
+
+      val workRequest = PeriodicWorkRequestBuilder<ImageDownloadWorker>(
+        20, TimeUnit.MINUTES
+      )
+        .setConstraints(buildConstraints())
+        .setInputData(buildInputData(appWidgetId, widgetType))
+        .addTag(appWidgetId.toString())
+        .build()
+
+      manager.enqueueUniquePeriodicWork(
+        "$uniqueWorkName-$appWidgetId",
+        ExistingPeriodicWorkPolicy.UPDATE,
+        workRequest
+      )
+    }
+
+    fun singleShot(context: Context, appWidgetId: Int, widgetType: WidgetType) {
+      val manager = WorkManager.getInstance(context)
+
+      val workRequest = OneTimeWorkRequestBuilder<ImageDownloadWorker>()
+        .setConstraints(buildConstraints())
+        .setInputData(buildInputData(appWidgetId, widgetType))
+        .addTag(appWidgetId.toString())
+        .build()
+
+      manager.enqueueUniqueWork(
+        "$uniqueWorkName-$appWidgetId-singleShot",
+        ExistingWorkPolicy.REPLACE,
+        workRequest
+      )
+    }
+
+    suspend fun cancel(context: Context, appWidgetId: Int) {
+      WorkManager.getInstance(context).cancelAllWorkByTag("$uniqueWorkName-$appWidgetId")
+
+      // delete cached image
+      val glanceId = GlanceAppWidgetManager(context).getGlanceIdBy(appWidgetId)
+      val widgetConfig = getAppWidgetState(context, PreferencesGlanceStateDefinition, glanceId)
+      val currentImgUUID = widgetConfig[kImageUUID]
+
+      if (!currentImgUUID.isNullOrEmpty()) {
+        val file = File(context.cacheDir, imageFilename(currentImgUUID))
+        file.delete()
+      }
+    }
+  }
+
+  override suspend fun doWork(): Result {
+    return try {
+      val widgetType = WidgetType.valueOf(inputData.getString(kWorkerWidgetType) ?: "")
+      val widgetId = inputData.getInt(kWorkerWidgetID, -1)
+      val glanceId = GlanceAppWidgetManager(context).getGlanceIdBy(widgetId)
+      val widgetConfig = getAppWidgetState(context, PreferencesGlanceStateDefinition, glanceId)
+      val currentImgUUID = widgetConfig[kImageUUID]
+
+      val serverConfig = ImmichAPI.getServerConfig(context)
+
+      // clear any image caches and go to "login" state if no credentials
+      if (serverConfig == null) {
+        if (!currentImgUUID.isNullOrEmpty()) {
+          deleteImage(currentImgUUID)
+          updateWidget(
+            glanceId,
+            "",
+            "",
+            "immich://",
+            WidgetState.LOG_IN
+          )
+        }
+
+        return Result.success()
+      }
+
+      // fetch new image
+      val entry = when (widgetType) {
+        WidgetType.RANDOM -> fetchRandom(serverConfig, widgetConfig)
+        WidgetType.MEMORIES -> fetchMemory(serverConfig)
+      }
+
+      // clear current image if it exists
+      if (!currentImgUUID.isNullOrEmpty()) {
+        deleteImage(currentImgUUID)
+      }
+
+      // save a new image
+      val imgUUID = UUID.randomUUID().toString()
+      saveImage(entry.image, imgUUID)
+
+      // trigger the update routine with new image uuid
+      updateWidget(glanceId, imgUUID, entry.subtitle, entry.deeplink)
+
+      Result.success()
+    } catch (e: Exception) {
+      Log.e(uniqueWorkName, "Error while loading image", e)
+      if (runAttemptCount < 10) {
+        Result.retry()
+      } else {
+        Result.failure()
+      }
+    }
+  }
+
+  private suspend fun updateWidget(
+    glanceId: GlanceId,
+    imageUUID: String,
+    subtitle: String?,
+    deeplink: String?,
+    widgetState: WidgetState = WidgetState.SUCCESS
+  ) {
+    updateAppWidgetState(context, glanceId) { prefs ->
+      prefs[kNow] = System.currentTimeMillis()
+      prefs[kImageUUID] = imageUUID
+      prefs[kWidgetState] = widgetState.toString()
+      prefs[kSubtitleText] = subtitle ?: ""
+      prefs[kDeeplinkURL] = deeplink ?: ""
+    }
+
+    PhotoWidget().update(context,glanceId)
+  }
+
+  private suspend fun fetchRandom(
+    serverConfig: ServerConfig,
+    widgetConfig: Preferences
+  ): WidgetEntry {
+    val api = ImmichAPI(serverConfig)
+
+    val filters = SearchFilters()
+    val albumId = widgetConfig[kSelectedAlbum]
+    val showSubtitle = widgetConfig[kShowAlbumName]
+    val albumName = widgetConfig[kSelectedAlbumName]
+    var subtitle: String? = if (showSubtitle == true) albumName else ""
+
+
+    if (albumId == "FAVORITES") {
+      filters.isFavorite = true
+    } else if (albumId != null) {
+      filters.albumIds = listOf(albumId)
+    }
+
+    var randomSearch = api.fetchSearchResults(filters)
+
+    // handle an empty album, fallback to random
+    if (randomSearch.isEmpty() && albumId != null) {
+      randomSearch = api.fetchSearchResults(SearchFilters())
+      subtitle = ""
+    }
+
+    val random = randomSearch.first()
+    val image = api.fetchImage(random)
+
+    return WidgetEntry(
+      image,
+      subtitle,
+      assetDeeplink(random)
+    )
+  }
+
+  private suspend fun fetchMemory(
+    serverConfig: ServerConfig
+  ): WidgetEntry {
+    val api = ImmichAPI(serverConfig)
+
+    val today = LocalDate.now()
+    val memories = api.fetchMemory(today)
+    val asset: Asset
+    var subtitle: String? = null
+
+    if (memories.isNotEmpty()) {
+      // pick a random asset from a random memory
+      val memory = memories.random()
+      asset = memory.assets.random()
+
+      val yearDiff = today.year - memory.data.year
+      subtitle = "$yearDiff ${if (yearDiff == 1) "year" else "years"} ago"
+    } else {
+      val filters = SearchFilters(size=1)
+      asset = api.fetchSearchResults(filters).first()
+    }
+
+    val image = api.fetchImage(asset)
+    return WidgetEntry(
+      image,
+      subtitle,
+      assetDeeplink(asset)
+    )
+  }
+
+  private suspend fun deleteImage(uuid: String) = withContext(Dispatchers.IO) {
+    val file = File(context.cacheDir, imageFilename(uuid))
+    file.delete()
+  }
+
+  private suspend fun saveImage(bitmap: Bitmap, uuid: String) = withContext(Dispatchers.IO) {
+    val file = File(context.cacheDir, imageFilename(uuid))
+    FileOutputStream(file).use { out ->
+      bitmap.compress(Bitmap.CompressFormat.JPEG, 90, out)
+    }
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/widget/ImmichAPI.kt

@@ -0,0 +1,122 @@
+package app.alextran.immich.widget
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import app.alextran.immich.widget.model.*
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+import es.antonborri.home_widget.HomeWidgetPlugin
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.io.OutputStreamWriter
+import java.net.HttpURLConnection
+import java.net.URL
+import java.net.URLEncoder
+import java.time.LocalDate
+import java.time.format.DateTimeFormatter
+
+class ImmichAPI(cfg: ServerConfig) {
+
+  companion object {
+    fun getServerConfig(context: Context): ServerConfig? {
+      val prefs = HomeWidgetPlugin.getData(context)
+
+      val serverURL = prefs.getString("widget_server_url", "") ?: ""
+      val sessionKey = prefs.getString("widget_auth_token", "") ?: ""
+      val customHeadersJSON = prefs.getString("widget_custom_headers", "") ?: ""
+
+      if (serverURL.isBlank() || sessionKey.isBlank()) {
+        return null
+      }
+
+      var customHeaders: Map<String, String> = HashMap<String, String>()
+
+      if (customHeadersJSON.isNotBlank()) {
+        val stringMapType = object : TypeToken<Map<String, String>>() {}.type
+        customHeaders = Gson().fromJson(customHeadersJSON, stringMapType)
+      }
+
+      return ServerConfig(
+        serverURL,
+        sessionKey,
+        customHeaders
+      )
+    }
+  }
+
+
+  private val gson = Gson()
+  private val serverConfig = cfg
+
+  private fun buildRequestURL(endpoint: String, params: List<Pair<String, String>> = emptyList()): URL {
+    val urlString = StringBuilder("${serverConfig.serverEndpoint}$endpoint?sessionKey=${serverConfig.sessionKey}")
+
+    for ((key, value) in params) {
+      urlString.append("&${URLEncoder.encode(key, "UTF-8")}=${URLEncoder.encode(value, "UTF-8")}")
+    }
+
+    return URL(urlString.toString())
+  }
+
+  private fun HttpURLConnection.applyCustomHeaders() {
+    serverConfig.customHeaders.forEach { (key, value) ->
+      setRequestProperty(key, value)
+    }
+  }
+
+  suspend fun fetchSearchResults(filters: SearchFilters): List<Asset> = withContext(Dispatchers.IO) {
+    val url = buildRequestURL("/search/random")
+    val connection = (url.openConnection() as HttpURLConnection).apply {
+      requestMethod = "POST"
+      setRequestProperty("Content-Type", "application/json")
+      applyCustomHeaders()
+
+      doOutput = true
+    }
+
+    connection.outputStream.use {
+      OutputStreamWriter(it).use { writer ->
+        writer.write(gson.toJson(filters))
+        writer.flush()
+      }
+    }
+
+    val response = connection.inputStream.bufferedReader().readText()
+    val type = object : TypeToken<List<Asset>>() {}.type
+    gson.fromJson(response, type)
+  }
+
+  suspend fun fetchMemory(date: LocalDate): List<MemoryResult> = withContext(Dispatchers.IO) {
+    val iso8601 = date.format(DateTimeFormatter.ISO_LOCAL_DATE)
+    val url = buildRequestURL("/memories", listOf("for" to iso8601))
+    val connection = (url.openConnection() as HttpURLConnection).apply {
+      requestMethod = "GET"
+      applyCustomHeaders()
+    }
+
+    val response = connection.inputStream.bufferedReader().readText()
+    val type = object : TypeToken<List<MemoryResult>>() {}.type
+    gson.fromJson(response, type)
+  }
+
+  suspend fun fetchImage(asset: Asset): Bitmap = withContext(Dispatchers.IO) {
+    val url = buildRequestURL("/assets/${asset.id}/thumbnail", listOf("size" to "preview", "edited" to "true"))
+    val connection = url.openConnection()
+    val data = connection.getInputStream().readBytes()
+    BitmapFactory.decodeByteArray(data, 0, data.size)
+      ?: throw Exception("Invalid image data")
+  }
+
+  suspend fun fetchAlbums(): List<Album> = withContext(Dispatchers.IO) {
+    val url = buildRequestURL("/albums")
+    val connection = (url.openConnection() as HttpURLConnection).apply {
+      requestMethod = "GET"
+      applyCustomHeaders()
+    }
+
+    val response = connection.inputStream.bufferedReader().readText()
+    val type = object : TypeToken<List<Album>>() {}.type
+    gson.fromJson(response, type)
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/widget/MemoryReceiver.kt

@@ -0,0 +1,58 @@
+package app.alextran.immich.widget
+
+import android.appwidget.AppWidgetManager
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import androidx.glance.appwidget.GlanceAppWidgetReceiver
+import app.alextran.immich.widget.model.*
+import es.antonborri.home_widget.HomeWidgetPlugin
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+class MemoryReceiver : GlanceAppWidgetReceiver() {
+  override val glanceAppWidget = PhotoWidget()
+
+  override fun onUpdate(
+    context: Context,
+    appWidgetManager: AppWidgetManager,
+    appWidgetIds: IntArray
+  ) {
+    super.onUpdate(context, appWidgetManager, appWidgetIds)
+
+    appWidgetIds.forEach { widgetID ->
+      ImageDownloadWorker.enqueuePeriodic(context, widgetID, WidgetType.MEMORIES)
+    }
+  }
+
+  override fun onReceive(context: Context, intent: Intent) {
+    val fromMainApp = intent.getBooleanExtra(HomeWidgetPlugin.TRIGGERED_FROM_HOME_WIDGET, false)
+    val provider = ComponentName(context, MemoryReceiver::class.java)
+    val glanceIds = AppWidgetManager.getInstance(context).getAppWidgetIds(provider)
+
+    // Launch coroutine to setup a single shot if the app requested the update
+    if (fromMainApp) {
+      glanceIds.forEach { widgetID ->
+        ImageDownloadWorker.singleShot(context, widgetID, WidgetType.MEMORIES)
+      }
+    }
+
+    // make sure the periodic jobs are running
+    glanceIds.forEach { widgetID ->
+      ImageDownloadWorker.enqueuePeriodic(context, widgetID, WidgetType.MEMORIES)
+    }
+
+    super.onReceive(context, intent)
+  }
+
+  override fun onDeleted(context: Context, appWidgetIds: IntArray) {
+    super.onDeleted(context, appWidgetIds)
+    CoroutineScope(Dispatchers.Default).launch {
+      appWidgetIds.forEach { id ->
+        ImageDownloadWorker.cancel(context, id)
+      }
+    }
+  }
+}
+

mobile/android/app/src/main/kotlin/app/alextran/immich/widget/PhotoWidget.kt

@@ -0,0 +1,124 @@
+package app.alextran.immich.widget
+
+import android.content.Context
+import android.content.Intent
+import android.graphics.Bitmap
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.*
+import androidx.core.net.toUri
+import androidx.datastore.preferences.core.MutablePreferences
+import androidx.glance.appwidget.*
+import androidx.glance.*
+import androidx.glance.action.clickable
+import androidx.glance.layout.*
+import androidx.glance.state.GlanceStateDefinition
+import androidx.glance.state.PreferencesGlanceStateDefinition
+import androidx.glance.text.Text
+import androidx.glance.text.TextAlign
+import androidx.glance.text.TextStyle
+import androidx.glance.unit.ColorProvider
+import app.alextran.immich.R
+import app.alextran.immich.widget.model.*
+import java.io.File
+
+class PhotoWidget : GlanceAppWidget() {
+  override var stateDefinition: GlanceStateDefinition<*> = PreferencesGlanceStateDefinition
+
+  override suspend fun provideGlance(context: Context, id: GlanceId) {
+    provideContent {
+      val prefs = currentState<MutablePreferences>()
+
+      val imageUUID = prefs[kImageUUID]
+      val subtitle = prefs[kSubtitleText]
+      val deeplinkURL = prefs[kDeeplinkURL]?.toUri()
+      val widgetState = prefs[kWidgetState]
+      var bitmap: Bitmap? = null
+
+      if (imageUUID != null) {
+        // fetch a random photo from server
+        val file = File(context.cacheDir, imageFilename(imageUUID))
+
+        if (file.exists()) {
+          bitmap = loadScaledBitmap(file, 500, 500)
+        }
+      }
+
+      // WIDGET CONTENT
+      Box(
+        modifier = GlanceModifier
+          .fillMaxSize()
+          .background(GlanceTheme.colors.background)
+          .clickable {
+            val intent = Intent(Intent.ACTION_VIEW, deeplinkURL ?: "immich://".toUri())
+            intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
+            context.startActivity(intent)
+          }
+      ) {
+        if (bitmap != null) {
+          Image(
+            provider = ImageProvider(bitmap),
+            contentDescription = "Widget Image",
+            contentScale = ContentScale.Crop,
+            modifier = GlanceModifier.fillMaxSize()
+          )
+
+          if (!subtitle.isNullOrBlank()) {
+            Column(
+              verticalAlignment = Alignment.Bottom,
+              horizontalAlignment = Alignment.Start,
+              modifier = GlanceModifier
+                .fillMaxSize()
+                .padding(12.dp)
+            ) {
+              Text(
+                text = subtitle,
+                style = TextStyle(
+                  color = ColorProvider(Color.White),
+                  fontSize = 16.sp
+                ),
+                modifier = GlanceModifier
+                  .background(ColorProvider(Color(0x99000000))) // 60% black
+                  .padding(8.dp)
+                  .cornerRadius(8.dp)
+              )
+            }
+          }
+        } else {
+          Column(
+            modifier = GlanceModifier.fillMaxSize(),
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalAlignment = Alignment.CenterHorizontally
+          ) {
+            Image(
+              provider = ImageProvider(R.drawable.splash),
+              contentDescription = null,
+            )
+
+            if (widgetState == WidgetState.LOG_IN.toString()) {
+              Box(
+                modifier = GlanceModifier.fillMaxWidth().padding(16.dp),
+                contentAlignment = Alignment.Center
+              ) {
+                Text("Log in to your Immich server", style = TextStyle(textAlign = TextAlign.Center, color = GlanceTheme.colors.primary))
+              }
+            } else {
+              Row(
+                verticalAlignment = Alignment.CenterVertically,
+                horizontalAlignment = Alignment.CenterHorizontally,
+                modifier = GlanceModifier.fillMaxWidth().padding(16.dp)
+              ) {
+                CircularProgressIndicator(
+                  modifier = GlanceModifier.size(12.dp)
+                )
+
+                Spacer(modifier = GlanceModifier.width(8.dp))
+
+                Text("Loading widget...", style = TextStyle(textAlign = TextAlign.Center, color = GlanceTheme.colors.primary))
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/widget/RandomReceiver.kt

@@ -0,0 +1,57 @@
+package app.alextran.immich.widget
+
+import android.appwidget.AppWidgetManager
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import es.antonborri.home_widget.HomeWidgetPlugin
+import androidx.glance.appwidget.GlanceAppWidgetReceiver
+import app.alextran.immich.widget.model.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+class RandomReceiver : GlanceAppWidgetReceiver() {
+  override val glanceAppWidget = PhotoWidget()
+
+  override fun onUpdate(
+    context: Context,
+    appWidgetManager: AppWidgetManager,
+    appWidgetIds: IntArray
+  ) {
+    super.onUpdate(context, appWidgetManager, appWidgetIds)
+
+    appWidgetIds.forEach { widgetID ->
+      ImageDownloadWorker.enqueuePeriodic(context, widgetID, WidgetType.RANDOM)
+    }
+  }
+
+  override fun onReceive(context: Context, intent: Intent) {
+    val fromMainApp = intent.getBooleanExtra(HomeWidgetPlugin.TRIGGERED_FROM_HOME_WIDGET, false)
+    val provider = ComponentName(context, RandomReceiver::class.java)
+    val glanceIds = AppWidgetManager.getInstance(context).getAppWidgetIds(provider)
+
+    // Launch coroutine to setup a single shot if the app requested the update
+    if (fromMainApp) {
+      glanceIds.forEach { widgetID ->
+        ImageDownloadWorker.singleShot(context, widgetID, WidgetType.RANDOM)
+      }
+    }
+
+    // make sure the periodic jobs are running
+    glanceIds.forEach { widgetID ->
+      ImageDownloadWorker.enqueuePeriodic(context, widgetID, WidgetType.RANDOM)
+    }
+
+    super.onReceive(context, intent)
+  }
+
+  override fun onDeleted(context: Context, appWidgetIds: IntArray) {
+    super.onDeleted(context, appWidgetIds)
+    CoroutineScope(Dispatchers.Default).launch {
+      appWidgetIds.forEach { id ->
+        ImageDownloadWorker.cancel(context, id)
+      }
+    }
+  }
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/widget/configure/Dropdown.kt

@@ -0,0 +1,64 @@
+package app.alextran.immich.widget.configure
+
+import androidx.compose.foundation.layout.*
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.*
+
+
+data class DropdownItem (
+  val label: String,
+  val id: String,
+)
+
+// Creating a composable to display a drop down menu
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun Dropdown(items: List<DropdownItem>,
+             selectedItem: DropdownItem?,
+             onItemSelected: (DropdownItem) -> Unit,
+             enabled: Boolean = true
+) {
+
+  var expanded by remember { mutableStateOf(false) }
+  var selectedOption by remember { mutableStateOf(selectedItem?.label ?: items[0].label) }
+
+    ExposedDropdownMenuBox(
+      expanded = expanded,
+      onExpandedChange = { expanded = !expanded && enabled },
+    ) {
+
+      TextField(
+        value = selectedOption,
+        onValueChange = {},
+        readOnly = true,
+        enabled = enabled,
+        trailingIcon = {
+          ExposedDropdownMenuDefaults.TrailingIcon(expanded = expanded)
+        },
+        colors = ExposedDropdownMenuDefaults.textFieldColors(),
+        modifier = Modifier
+          .fillMaxWidth()
+          .menuAnchor()
+      )
+
+      ExposedDropdownMenu(
+        expanded = expanded,
+        onDismissRequest = { expanded = false }
+      ) {
+        items.forEach { option ->
+          DropdownMenuItem(
+            text = { Text(option.label, color = MaterialTheme.colorScheme.onSurface) },
+            onClick = {
+              selectedOption = option.label
+              onItemSelected(option)
+
+              expanded = false
+            },
+            contentPadding = ExposedDropdownMenuDefaults.ItemContentPadding
+          )
+        }
+      }
+    }
+  }
+

mobile/android/app/src/main/kotlin/app/alextran/immich/widget/configure/LightDarkTheme.kt

@@ -0,0 +1,28 @@
+package app.alextran.immich.widget.configure
+
+import android.os.Build
+import androidx.compose.foundation.*
+import androidx.compose.material3.*
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.platform.LocalContext
+
+@Composable
+fun LightDarkTheme(
+  content: @Composable () -> Unit
+) {
+  val context = LocalContext.current
+  val isDarkTheme = isSystemInDarkTheme()
+
+  val colorScheme = when {
+    Build.VERSION.SDK_INT >= Build.VERSION_CODES.S && isDarkTheme ->
+      dynamicDarkColorScheme(context)
+    Build.VERSION.SDK_INT >= Build.VERSION_CODES.S && !isDarkTheme ->
+      dynamicLightColorScheme(context)
+    isDarkTheme -> darkColorScheme()
+    else -> lightColorScheme()
+  }
+  MaterialTheme(
+    colorScheme = colorScheme,
+    content = content
+  )
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/widget/configure/RandomConfigure.kt

@@ -0,0 +1,210 @@
+package app.alextran.immich.widget.configure
+
+import android.appwidget.AppWidgetManager
+import android.content.Context
+import android.os.Bundle
+import android.util.Log
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Check
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material.icons.filled.Warning
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.unit.dp
+import androidx.glance.GlanceId
+import androidx.glance.appwidget.GlanceAppWidgetManager
+import androidx.glance.appwidget.state.getAppWidgetState
+import androidx.glance.appwidget.state.updateAppWidgetState
+import androidx.glance.state.PreferencesGlanceStateDefinition
+import app.alextran.immich.widget.ImageDownloadWorker
+import app.alextran.immich.widget.ImmichAPI
+import app.alextran.immich.widget.model.*
+import kotlinx.coroutines.launch
+import java.io.FileNotFoundException
+
+class RandomConfigure : ComponentActivity() {
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+
+    // Get widget ID from intent
+    val appWidgetId = intent?.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID,
+      AppWidgetManager.INVALID_APPWIDGET_ID)
+      ?: AppWidgetManager.INVALID_APPWIDGET_ID
+
+    if (appWidgetId == AppWidgetManager.INVALID_APPWIDGET_ID) {
+      finish()
+      return
+    }
+
+    val glanceId = GlanceAppWidgetManager(applicationContext)
+      .getGlanceIdBy(appWidgetId)
+
+    setContent {
+      LightDarkTheme {
+        RandomConfiguration(applicationContext, appWidgetId, glanceId, onDone = {
+          finish()
+          Log.w("WIDGET_ACTIVITY", "SAVING")
+        })
+      }
+    }
+  }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun RandomConfiguration(context: Context, appWidgetId: Int, glanceId: GlanceId, onDone: () -> Unit) {
+
+  var selectedAlbum by remember { mutableStateOf<DropdownItem?>(null) }
+  var showAlbumName by remember { mutableStateOf(false) }
+  var availableAlbums by remember { mutableStateOf<List<DropdownItem>>(listOf()) }
+  var state by remember { mutableStateOf(WidgetConfigState.LOADING) }
+
+  val scope = rememberCoroutineScope()
+
+  LaunchedEffect(Unit) {
+    // get albums from server
+    val serverCfg = ImmichAPI.getServerConfig(context)
+
+    if (serverCfg == null) {
+      state = WidgetConfigState.LOG_IN
+      return@LaunchedEffect
+    }
+
+    val api = ImmichAPI(serverCfg)
+
+    val currentState = getAppWidgetState(context, PreferencesGlanceStateDefinition, glanceId)
+    val currentAlbumId = currentState[kSelectedAlbum] ?: "NONE"
+    val currentAlbumName = currentState[kSelectedAlbumName] ?: "None"
+    var albumItems: List<DropdownItem>
+
+    try {
+      albumItems = api.fetchAlbums().map {
+        DropdownItem(it.albumName, it.id)
+      }
+
+      state = WidgetConfigState.SUCCESS
+    } catch (e: FileNotFoundException) {
+      Log.e("WidgetWorker", "Error fetching albums: ${e.message}")
+
+      state = WidgetConfigState.NO_CONNECTION
+      albumItems = listOf(DropdownItem(currentAlbumName, currentAlbumId))
+    }
+
+    availableAlbums = listOf(DropdownItem("None", "NONE"), DropdownItem("Favorites", "FAVORITES")) + albumItems
+
+    // load selected configuration
+    val albumEntity = availableAlbums.firstOrNull { it.id == currentAlbumId }
+    selectedAlbum = albumEntity ?: availableAlbums.first()
+
+    // load showAlbumName
+    showAlbumName = currentState[kShowAlbumName] == true
+  }
+
+  suspend fun saveConfiguration() {
+    updateAppWidgetState(context, glanceId) { prefs ->
+      prefs[kSelectedAlbum] = selectedAlbum?.id ?: ""
+      prefs[kSelectedAlbumName] = selectedAlbum?.label ?: ""
+      prefs[kShowAlbumName] = showAlbumName
+    }
+
+    ImageDownloadWorker.singleShot(context, appWidgetId, WidgetType.RANDOM)
+  }
+
+  Scaffold(
+    topBar = {
+      TopAppBar (
+        title = { Text("Widget Configuration") },
+        actions = {
+          IconButton(onClick = {
+            scope.launch {
+              saveConfiguration()
+              onDone()
+            }
+          }) {
+            Icon(Icons.Default.Check, contentDescription = "Close", tint = MaterialTheme.colorScheme.primary)
+          }
+        }
+      )
+    }
+  ) { innerPadding ->
+    Surface(
+      modifier = Modifier
+        .fillMaxSize()
+        .padding(innerPadding), // Respect the top bar
+      color = MaterialTheme.colorScheme.background
+    ) {
+      Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.TopCenter) {
+        when (state) {
+          WidgetConfigState.LOADING -> CircularProgressIndicator(modifier = Modifier.size(48.dp))
+          WidgetConfigState.LOG_IN -> Text("You must log in inside the Immich App to configure this widget.")
+          else -> {
+            Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+              Text("View a random image from your library or a specific album.", style = MaterialTheme.typography.bodyMedium)
+
+              // no connection warning
+              if (state == WidgetConfigState.NO_CONNECTION) {
+                Row(
+                  modifier = Modifier
+                    .fillMaxWidth()
+                    .clip(RoundedCornerShape(12.dp))
+                    .background(MaterialTheme.colorScheme.errorContainer)
+                    .padding(12.dp),
+                  verticalAlignment = Alignment.CenterVertically
+                ) {
+                  Icon(
+                    imageVector = Icons.Default.Warning,
+                    contentDescription = "Warning",
+                    modifier = Modifier.size(24.dp)
+                  )
+                  Spacer(modifier = Modifier.width(12.dp))
+                  Text(
+                    text = "No connection to the server is available. Please try again later.",
+                    style = MaterialTheme.typography.bodyMedium
+                  )
+                }
+              }
+
+              Column(
+                modifier = Modifier
+                  .clip(RoundedCornerShape(12.dp))
+                  .background(MaterialTheme.colorScheme.surfaceContainer)
+                  .padding(16.dp),
+                verticalArrangement = Arrangement.spacedBy(8.dp)
+              ) {
+                Text("Album")
+                Dropdown(
+                  items = availableAlbums,
+                  selectedItem = selectedAlbum,
+                  onItemSelected = { selectedAlbum = it },
+                  enabled = (state != WidgetConfigState.NO_CONNECTION)
+                )
+
+                Row(
+                  verticalAlignment = Alignment.CenterVertically,
+                  horizontalArrangement = Arrangement.SpaceBetween,
+                  modifier = Modifier.fillMaxWidth()
+                ) {
+                  Text(text = "Show Album Name")
+                  Switch(
+                    checked = showAlbumName,
+                    onCheckedChange = { showAlbumName = it },
+                    enabled = (state != WidgetConfigState.NO_CONNECTION)
+                  )
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+

mobile/android/app/src/main/kotlin/app/alextran/immich/widget/model/Model.kt

@@ -0,0 +1,84 @@
+package app.alextran.immich.widget.model
+
+import android.graphics.Bitmap
+import androidx.datastore.preferences.core.*
+
+// MARK: Immich Entities
+
+enum class AssetType {
+  IMAGE, VIDEO, AUDIO, OTHER
+}
+
+data class Asset(
+  val id: String,
+  val type: AssetType,
+)
+
+data class SearchFilters(
+  var type: AssetType = AssetType.IMAGE,
+  val size: Int = 1,
+  var albumIds: List<String> = listOf(),
+  var isFavorite: Boolean? = null
+)
+
+data class MemoryResult(
+  val id: String,
+  var assets: List<Asset>,
+  val type: String,
+  val data: MemoryData
+) {
+  data class MemoryData(val year: Int)
+}
+
+data class Album(
+  val id: String,
+  val albumName: String
+)
+
+// MARK: Widget Specific
+
+enum class WidgetType {
+  RANDOM, MEMORIES;
+}
+
+enum class WidgetState {
+  LOADING, SUCCESS, LOG_IN;
+}
+
+enum class WidgetConfigState {
+  LOADING, SUCCESS, LOG_IN, NO_CONNECTION
+}
+
+data class WidgetEntry (
+  val image: Bitmap,
+  val subtitle: String?,
+  val deeplink: String?
+)
+
+data class ServerConfig(
+  val serverEndpoint: String,
+  val sessionKey: String,
+  val customHeaders: Map<String, String>
+)
+
+// MARK: Widget State Keys
+val kImageUUID = stringPreferencesKey("uuid")
+val kSubtitleText = stringPreferencesKey("subtitle")
+val kNow = longPreferencesKey("now")
+val kWidgetState = stringPreferencesKey("state")
+val kSelectedAlbum = stringPreferencesKey("albumID")
+val kSelectedAlbumName = stringPreferencesKey("albumName")
+val kShowAlbumName = booleanPreferencesKey("showAlbumName")
+val kDeeplinkURL = stringPreferencesKey("deeplink")
+
+const val kWorkerWidgetType = "widgetType"
+const val kWorkerWidgetID = "widgetId"
+const val kTriggeredFromApp = "triggeredFromApp"
+
+fun imageFilename(id: String): String {
+  return "widget_image_$id.jpg"
+}
+
+fun assetDeeplink(asset: Asset): String {
+  return "immich://asset?id=${asset.id}"
+}

mobile/android/app/src/main/res/drawable-night-v21/launch_background.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item>
+        <bitmap android:gravity="fill" android:src="@drawable/background"/>
+    </item>
+    <item>
+        <bitmap android:gravity="center" android:src="@drawable/splash"/>
+    </item>
+</layer-list>

mobile/android/app/src/main/res/drawable-night/launch_background.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item>
+        <bitmap android:gravity="fill" android:src="@drawable/background"/>
+    </item>
+    <item>
+        <bitmap android:gravity="center" android:src="@drawable/splash"/>
+    </item>
+</layer-list>

mobile/android/app/src/main/res/drawable-v21/launch_background.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item>
+        <bitmap android:gravity="fill" android:src="@drawable/background"/>
+    </item>
+    <item>
+        <bitmap android:gravity="center" android:src="@drawable/splash"/>
+    </item>
+</layer-list>

mobile/android/app/src/main/res/drawable/ic_launcher_foreground.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+  android:width="108dp"
+  android:height="108dp"
+  android:viewportWidth="108"
+  android:viewportHeight="108">
+  <path
+    android:fillColor="#FA2921"
+    android:fillType="nonZero"
+    android:pathData="m52.25,43.55c3.4,3.08 6.15,6.39 7.91,9.5 3.03,-5.55 5.06,-12.14 5.08,-16.34 0,-0.03 0,-0.06 0,-0.08 0,-6.21 -6.06,-8.63 -11.28,-8.63 -5.22,0 -11.28,2.42 -11.28,8.63 0,0.08 0,0.2 0,0.34 2.91,1.32 6.36,3.69 9.56,6.59z" />
+  <path
+    android:fillColor="#ED79B5"
+    android:fillType="nonZero"
+    android:pathData="m33.68,60.5c2.13,-2.42 5.39,-5.05 9.08,-7.27 3.92,-2.36 7.84,-4.01 11.28,-4.76 -4.22,-4.67 -9.72,-8.67 -13.62,-10 -0.03,-0.01 -0.05,-0.02 -0.08,-0.03 -5.78,-1.92 -9.9,3.23 -11.51,8.31 -1.61,5.08 -1.24,11.72 4.54,13.64 0.08,0.03 0.18,0.06 0.31,0.1z" />
+  <path
+    android:fillColor="#FFB400"
+    android:fillType="nonZero"
+    android:pathData="M79.17,46.67C77.56,41.59 73.44,36.44 67.66,38.36c-0.08,0.03 -0.19,0.06 -0.31,0.1 -0.33,3.24 -1.46,7.33 -3.17,11.34 -1.81,4.27 -4.04,7.96 -6.39,10.64 6.1,1.24 12.85,1.17 16.76,-0.1 0.03,-0.01 0.05,-0.02 0.08,-0.03 5.78,-1.92 6.15,-8.56 4.54,-13.64z" />
+  <path
+    android:fillColor="#1E83F7"
+    android:fillType="nonZero"
+    android:pathData="m48.82,65.46c-0.98,-4.54 -1.3,-8.87 -0.94,-12.45 -5.64,2.67 -11.07,6.78 -13.5,10.16 -0.02,0.02 -0.03,0.05 -0.05,0.07 -3.57,5.03 -0.06,10.63 4.16,13.77 4.22,3.14 10.51,4.83 14.09,-0.2 0.05,-0.07 0.11,-0.16 0.19,-0.27 -1.59,-2.82 -3.03,-6.81 -3.95,-11.08z" />
+  <path
+    android:fillColor="#18C249"
+    android:fillType="nonZero"
+    android:pathData="m73.58,62.92c-3.11,0.68 -7.26,0.84 -11.52,0.42 -4.53,-0.45 -8.64,-1.47 -11.86,-2.93 0.73,6.31 2.88,12.87 5.28,16.28 0.02,0.02 0.03,0.05 0.05,0.07 3.57,5.03 9.86,3.34 14.09,0.2 4.22,-3.14 7.74,-8.74 4.16,-13.77 -0.05,-0.07 -0.11,-0.16 -0.19,-0.27z" />
+</vector>

mobile/android/app/src/main/res/drawable/ic_launcher_monochrome.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+  android:width="108dp"
+  android:height="108dp"
+  android:viewportWidth="108"
+  android:viewportHeight="108">
+  <path
+    android:fillColor="#fff"
+    android:fillType="nonZero"
+    android:pathData="m52.25,43.55c3.4,3.08 6.15,6.39 7.91,9.5 3.03,-5.55 5.06,-12.14 5.08,-16.34 0,-0.03 0,-0.06 0,-0.08 0,-6.21 -6.06,-8.63 -11.28,-8.63 -5.22,0 -11.28,2.42 -11.28,8.63 0,0.08 0,0.2 0,0.34 2.91,1.32 6.36,3.69 9.56,6.59z" />
+  <path
+    android:fillColor="#fff"
+    android:fillType="nonZero"
+    android:pathData="m33.68,60.5c2.13,-2.42 5.39,-5.05 9.08,-7.27 3.92,-2.36 7.84,-4.01 11.28,-4.76 -4.22,-4.67 -9.72,-8.67 -13.62,-10 -0.03,-0.01 -0.05,-0.02 -0.08,-0.03 -5.78,-1.92 -9.9,3.23 -11.51,8.31 -1.61,5.08 -1.24,11.72 4.54,13.64 0.08,0.03 0.18,0.06 0.31,0.1z" />
+  <path
+    android:fillColor="#fff"
+    android:fillType="nonZero"
+    android:pathData="M79.17,46.67C77.56,41.59 73.44,36.44 67.66,38.36c-0.08,0.03 -0.19,0.06 -0.31,0.1 -0.33,3.24 -1.46,7.33 -3.17,11.34 -1.81,4.27 -4.04,7.96 -6.39,10.64 6.1,1.24 12.85,1.17 16.76,-0.1 0.03,-0.01 0.05,-0.02 0.08,-0.03 5.78,-1.92 6.15,-8.56 4.54,-13.64z" />
+  <path
+    android:fillColor="#fff"
+    android:fillType="nonZero"
+    android:pathData="m48.82,65.46c-0.98,-4.54 -1.3,-8.87 -0.94,-12.45 -5.64,2.67 -11.07,6.78 -13.5,10.16 -0.02,0.02 -0.03,0.05 -0.05,0.07 -3.57,5.03 -0.06,10.63 4.16,13.77 4.22,3.14 10.51,4.83 14.09,-0.2 0.05,-0.07 0.11,-0.16 0.19,-0.27 -1.59,-2.82 -3.03,-6.81 -3.95,-11.08z" />
+  <path
+    android:fillColor="#fff"
+    android:fillType="nonZero"
+    android:pathData="m73.58,62.92c-3.11,0.68 -7.26,0.84 -11.52,0.42 -4.53,-0.45 -8.64,-1.47 -11.86,-2.93 0.73,6.31 2.88,12.87 5.28,16.28 0.02,0.02 0.03,0.05 0.05,0.07 3.57,5.03 9.86,3.34 14.09,0.2 4.22,-3.14 7.74,-8.74 4.16,-13.77 -0.05,-0.07 -0.11,-0.16 -0.19,-0.27z" />
+</vector>

mobile/android/app/src/main/res/drawable/launch_background.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item>
+        <bitmap android:gravity="fill" android:src="@drawable/background"/>
+    </item>
+    <item>
+        <bitmap android:gravity="center" android:src="@drawable/splash"/>
+    </item>
+</layer-list>

mobile/android/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+  <background android:drawable="@color/ic_launcher_background"/>
+  <foreground android:drawable="@drawable/ic_launcher_foreground"/>
+  <monochrome android:drawable="@drawable/ic_launcher_monochrome"/>
+</adaptive-icon>

mobile/android/app/src/main/res/values-night-v31/styles.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!-- Theme applied to the Android Window while the process is starting when the OS's Dark Mode setting is off -->
+    <style name="LaunchTheme" parent="@android:style/Theme.Black.NoTitleBar">
+        <item name="android:forceDarkAllowed">false</item>
+        <item name="android:windowFullscreen">false</item>
+        <item name="android:windowDrawsSystemBarBackgrounds">false</item>
+        <item name="android:windowLayoutInDisplayCutoutMode">shortEdges</item>
+        <item name="android:windowSplashScreenBackground">#000000</item>
+        <item name="android:windowSplashScreenAnimatedIcon">@drawable/android12splash</item>
+    </style>
+    <!-- Theme applied to the Android Window as soon as the process has started.
+         This theme determines the color of the Android Window while your
+         Flutter UI initializes, as well as behind your Flutter UI while its
+         running.
+         
+         This Theme is only used starting with V2 of Flutter's Android embedding. -->
+    <style name="NormalTheme" parent="@android:style/Theme.Black.NoTitleBar">
+        <item name="android:windowBackground">?android:colorBackground</item>
+    </style>
+</resources>

mobile/android/app/src/main/res/values-night/styles.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!-- Theme applied to the Android Window while the process is starting when the OS's Dark Mode setting is on -->
+    <style name="LaunchTheme" parent="@android:style/Theme.Black.NoTitleBar">
+        <!-- Show a splash screen on the activity. Automatically removed when
+             Flutter draws its first frame -->
+        <item name="android:windowBackground">@drawable/launch_background</item>
+        <item name="android:forceDarkAllowed">false</item>
+        <item name="android:windowFullscreen">false</item>
+        <item name="android:windowDrawsSystemBarBackgrounds">false</item>
+        <item name="android:windowLayoutInDisplayCutoutMode">shortEdges</item>
+    </style>
+    <!-- Theme applied to the Android Window as soon as the process has started.
+         This theme determines the color of the Android Window while your
+         Flutter UI initializes, as well as behind your Flutter UI while its
+         running.
+
+         This Theme is only used starting with V2 of Flutter's Android embedding. -->
+    <style name="NormalTheme" parent="@android:style/Theme.Black.NoTitleBar">
+        <item name="android:windowBackground">?android:colorBackground</item>
+    </style>
+</resources>

mobile/android/app/src/main/res/values-v31/styles.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!-- Theme applied to the Android Window while the process is starting when the OS's Dark Mode setting is off -->
+    <style name="LaunchTheme" parent="@android:style/Theme.Light.NoTitleBar">
+        <item name="android:forceDarkAllowed">false</item>
+        <item name="android:windowFullscreen">false</item>
+        <item name="android:windowDrawsSystemBarBackgrounds">false</item>
+        <item name="android:windowLayoutInDisplayCutoutMode">shortEdges</item>
+        <item name="android:windowSplashScreenBackground">#f6f8fe</item>
+        <item name="android:windowSplashScreenAnimatedIcon">@drawable/android12splash</item>
+    </style>
+    <!-- Theme applied to the Android Window as soon as the process has started.
+         This theme determines the color of the Android Window while your
+         Flutter UI initializes, as well as behind your Flutter UI while its
+         running.
+         
+         This Theme is only used starting with V2 of Flutter's Android embedding. -->
+    <style name="NormalTheme" parent="@android:style/Theme.Light.NoTitleBar">
+        <item name="android:windowBackground">?android:colorBackground</item>
+    </style>
+</resources>

mobile/android/app/src/main/res/values/colors.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="ic_launcher_background">#ffffff</color>
+</resources>

mobile/android/app/src/main/res/values/strings.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <string name="memory_widget_title">Memories</string>
+  <string name="random_widget_title">Random</string>
+
+  <string name="memory_widget_description">See memories from Immich.</string>
+  <string name="random_widget_description">View a random image from your library or a specific album.</string>
+</resources>

mobile/android/app/src/main/res/values/styles.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <!-- Theme applied to the Android Window while the process is starting when the OS's Dark Mode
+  setting is off -->
+  <style name="LaunchTheme" parent="Theme.AppCompat.DayNight">
+    <!-- Show a splash screen on the activity. Automatically removed when
+             Flutter draws its first frame -->
+    <item name="android:windowBackground">@drawable/launch_background</item>
+    <item name="android:forceDarkAllowed">false</item>
+    <item name="android:windowFullscreen">false</item>
+    <item name="android:windowDrawsSystemBarBackgrounds">false</item>
+    <item name="android:windowLayoutInDisplayCutoutMode">shortEdges</item>
+  </style>
+  <!-- Theme applied to the Android Window as soon as the process has started.
+         This theme determines the color of the Android Window while your
+         Flutter UI initializes, as well as behind your Flutter UI while its
+         running.
+
+         This Theme is only used starting with V2 of Flutter's Android embedding. -->
+  <style name="NormalTheme" parent="@android:style/Theme.Light.NoTitleBar">
+    <item name="android:windowBackground">?android:colorBackground</item>
+  </style>
+</resources>

mobile/android/app/src/main/res/xml/memory_widget.xml

@@ -0,0 +1,9 @@
+<appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
+  android:initialLayout="@layout/glance_default_loading_layout"
+  android:minWidth="110dp"
+  android:minHeight="110dp"
+  android:resizeMode="horizontal|vertical"
+  android:updatePeriodMillis="1200000"
+  android:description="@string/memory_widget_description"
+  android:previewImage="@drawable/memory_preview"
+  />

mobile/android/app/src/main/res/xml/random_widget.xml

@@ -0,0 +1,13 @@
+<appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:tools="http://schemas.android.com/tools"
+  android:initialLayout="@layout/glance_default_loading_layout"
+  android:minWidth="110dp"
+  android:minHeight="110dp"
+  android:resizeMode="horizontal|vertical"
+  android:updatePeriodMillis="1200000"
+  android:configure="app.alextran.immich.widget.configure.RandomConfigure"
+  android:widgetFeatures="reconfigurable|configuration_optional"
+  tools:targetApi="28"
+  android:description="@string/random_widget_description"
+  android:previewImage="@drawable/random_preview"
+  />

mobile/android/app/src/profile/AndroidManifest.xml

@@ -0,0 +1,6 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <!-- Flutter needs it to communicate with the running application
+         to allow setting breakpoints, to provide hot reload, etc.
+    -->
+  <uses-permission android:name="android.permission.INTERNET" />
+</manifest>

mobile/android/build.gradle

@@ -0,0 +1,39 @@
+allprojects {
+    ext.kotlin_version = '2.2.20'
+
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+rootProject.buildDir = '../build'
+
+subprojects {
+  //  fix for verifyReleaseResources
+  // ============
+  afterEvaluate { project ->
+        if (project.plugins.hasPlugin("com.android.application") ||
+                project.plugins.hasPlugin("com.android.library")) {
+            project.android {
+                compileSdkVersion 36
+                buildToolsVersion "36.0.0"
+            }
+        }
+    }
+    // ============
+    project.buildDir = "${rootProject.buildDir}/${project.name}"
+}
+
+subprojects {
+    project.evaluationDependsOn(':app')
+}
+
+tasks.register("clean", Delete) {
+    delete rootProject.buildDir
+}
+
+tasks.named('wrapper') {
+    distributionType = Wrapper.DistributionType.ALL
+}
+

mobile/android/fastlane/Appfile

@@ -0,0 +1,2 @@
+json_key_file("/Users/alex/Documents/immich-play-store-key.json")
+package_name("app.alextran.immich")

mobile/android/fastlane/Fastfile

@@ -0,0 +1,45 @@
+# This file contains the fastlane.tools configuration
+# You can find the documentation at https://docs.fastlane.tools
+#
+# For a list of all available actions, check out
+#
+#     https://docs.fastlane.tools/actions
+#
+# For a list of all available plugins, check out
+#
+#     https://docs.fastlane.tools/plugins/available-plugins
+#
+
+# Uncomment the line if you want fastlane to automatically update itself
+# update_fastlane
+
+default_platform(:android)
+
+platform :android do
+  desc "Build Android and Release Testing"
+  lane :beta do
+    gradle(
+      task: 'bundle', 
+      build_type: 'Release',
+      properties: {
+        "android.injected.version.code" => 47,
+        "android.injected.version.name" => "1.30.2",
+      }
+    )
+    upload_to_play_store(skip_upload_apk: true, skip_upload_images: true, skip_upload_screenshots: true, aab: '../build/app/outputs/bundle/release/app-release.aab', track: 'beta')
+  end
+
+  desc "Build and Release Android"
+  lane :release do
+    gradle(
+      task: 'bundle', 
+      build_type: 'Release',
+      properties: {
+        "android.injected.version.code" => 3033,
+        "android.injected.version.name" => "2.5.2",
+      }
+    )
+    upload_to_play_store(skip_upload_apk: true, skip_upload_images: true, skip_upload_screenshots: true, aab: '../build/app/outputs/bundle/release/app-release.aab')
+  end
+
+end

mobile/android/fastlane/README.md

@@ -0,0 +1,40 @@
+fastlane documentation
+----
+
+# Installation
+
+Make sure you have the latest version of the Xcode command line tools installed:
+
+```sh
+xcode-select --install
+```
+
+For _fastlane_ installation instructions, see [Installing _fastlane_](https://docs.fastlane.tools/#installing-fastlane)
+
+# Available Actions
+
+## Android
+
+### android beta
+
+```sh
+[bundle exec] fastlane android beta
+```
+
+Build Android and Release Testing
+
+### android release
+
+```sh
+[bundle exec] fastlane android release
+```
+
+Build and Release Android
+
+----
+
+This README.md is auto-generated and will be re-generated every time [_fastlane_](https://fastlane.tools) is run.
+
+More information about _fastlane_ can be found on [fastlane.tools](https://fastlane.tools).
+
+The documentation of _fastlane_ can be found on [docs.fastlane.tools](https://docs.fastlane.tools).

mobile/android/fastlane/metadata/android/en-US/changelogs/10.txt

@@ -0,0 +1,2 @@
+* Accepting webp file format
+* Fixed backup stop when an asset is of wrong file type. The app will now skip that asset and try its best to perform the backup operation on the rest of the assets.

mobile/android/fastlane/metadata/android/en-US/changelogs/11.txt

@@ -0,0 +1,7 @@
+* New features 
+  - Share album. Users can now create albums to share with existing people on the network.
+  - Owner can delete the album.
+  - Owner can invite the additional users to the album.
+  - Shared users and the owner can add additional assets to the album.
+* In the asset viewer, the user can swipe up to see detailed information and swip down to dismiss.
+* Several UI enhancements.