ci(release): add HealthChat Play Store release pipeline

.claude/skills/releasing-healthchat/SKILL.md

@@ -0,0 +1,240 @@
+---
+name: releasing-healthchat
+description: Cut a HealthChat Google Play release of element-x-android by tagging release/healthchat. Use when the user asks to release, publish, tag, deploy, ship, or cut a new HealthChat Android version, asks about the Play Store release process, asks about rotating the Android release keystore, or asks about the required GitHub Actions secrets for the release pipeline.
+---
+
+# Releasing HealthChat (element-x-android)
+
+Releases are driven by git tags of the form `healthchat-v<version>` pushed to
+`origin`. The tag triggers `.github/workflows/healthchat-release-playstore.yml`,
+which runs on `ubuntu-latest`, builds a signed AAB, and uploads it to the Play
+Store **internal** track. No GitHub Release is created.
+
+**Promotion to production is always a manual step** in Play Console after an
+internal build has been validated — see "Promoting to production" below.
+
+## Preflight checklist
+
+Verify each item before tagging. If any fail, fix and commit first.
+
+- [ ] On branch `release/healthchat` with a clean working tree (`git status`).
+- [ ] `HEALTHCHAT_CHANGES.md` has a section `## Changes in <new-version> (<date>)`
+      at the top of the file. The pipeline's awk extractor matches this exact
+      heading format; no match means a fallback placeholder ships as the Play
+      Store "What's new" text.
+- [ ] `plugins/src/main/kotlin/Versions.kt` `versionYear`, `versionMonth`, and
+      `versionReleaseNumber` produce the tag's core version (format
+      `<year>.<month zero-padded to 2>.<releaseNumber>`, e.g. `26.07.1`).
+      **The workflow hard-fails** if they don't match — this is load-bearing,
+      not cosmetic.
+- [ ] If you edited `HEALTHCHAT_CHANGES.md` or `Versions.kt`, both commits are
+      pushed to `release/healthchat` **before** you push the tag.
+
+## Cutting the release (normal path)
+
+```bash
+# from release/healthchat, fully committed:
+git tag healthchat-v<YEAR>.<MONTH>.<RELEASE>
+git push origin healthchat-v<YEAR>.<MONTH>.<RELEASE>
+```
+
+Examples:
+
+- `git tag healthchat-v26.07.1`        (next release in July 2026)
+- `git tag healthchat-v26.08.0`        (first release in August 2026)
+- `git tag healthchat-v26.07.2-rc1`    (release candidate)
+
+Watch the workflow with `gh run watch` or in the GitHub Actions UI. When it
+finishes, the build appears in Play Console → Internal testing within a few
+minutes (Play Store's processing queue).
+
+## Manual / retry path (workflow_dispatch)
+
+Use when retrying a failed run or rebuilding without moving tags.
+
+1. GitHub → Actions → "HealthChat Release to Google Play Store" → **Run workflow**.
+2. Fill in:
+   - **version** (required): e.g. `26.07.1`. Same regex validation as tag path.
+     Must still match `Versions.kt`.
+   - **track**: default `internal`; pick `alpha`/`beta`/`production` to promote
+     an already-uploaded build to a higher track without rebuilding (note:
+     Play Console is usually a better UX for promotion).
+   - **release_status**: default `completed`; use `draft` for dry-runs that
+     land in Play Console but stay unpublished.
+   - **release_notes_override** (optional): replaces the
+     `HEALTHCHAT_CHANGES.md` lookup. Useful for ad-hoc test builds.
+3. Run. The AAB is built and uploaded exactly as the tag path would.
+
+## Versioning (calendar scheme — differs from the old Classic repo)
+
+Element X uses calendar versioning, defined in
+`plugins/src/main/kotlin/Versions.kt`:
+
+```
+versionName = <versionYear>.<versionMonth padded to 2>.<versionReleaseNumber>   // e.g. 26.07.1
+versionCode = ((2000 + versionYear) * 10_000 + versionMonth * 100 + versionReleaseNumber) * 10
+```
+
+The trailing `* 10` is the ABI multiplier applied per output APK
+(`app/build.gradle.kts` androidComponents block); the AAB gets ABI code `0`.
+Example: `26.07.1` → versionCode `202607010`.
+
+To bump: edit `versionYear`/`versionMonth`/`versionReleaseNumber` in
+`Versions.kt` (increment `versionReleaseNumber` within a month; reset it to 0
+when the month changes). `versionCode` must be strictly monotonic in Play
+Store across all uploads — the calendar scheme guarantees this as long as you
+never decrease the triple. All HealthChat codes (≥ 202,607,000) supersede the
+old Classic app's last code (40,154,100).
+
+**Keep the same version as the upstream Element X release the branch is based
+on unless HealthChat ships an intermediate build** — then bump
+`versionReleaseNumber` past upstream's. When merging a newer upstream release
+into `release/healthchat`, take upstream's `Versions.kt` if its version is
+higher.
+
+## Release notes
+
+`HEALTHCHAT_CHANGES.md` is the single source. The workflow extracts the
+section matching the version being released, then writes it to
+`fastlane/metadata/android/en-US/changelogs/<versionCode>.txt` and
+`fastlane/metadata/android/de-DE/changelogs/<versionCode>.txt`, which
+`r0adkll/upload-google-play` picks up via its `whatsNewDirectory` input.
+
+Format:
+
+```markdown
+## Changes in 26.07.1 (2026-07-20)
+
+🙌 Improvements
+
+- Bullet one.
+- Bullet two.
+```
+
+Keep the entire section under **500 characters** — Play Store's "What's new"
+hard cap per locale. The workflow emits a warning if you exceed it; Play Store
+will truncate.
+
+Never hand-edit the generated `fastlane/metadata/android/*/changelogs/<N>.txt`
+files for this branch — they'll be overwritten on the next run. Only edit
+`HEALTHCHAT_CHANGES.md`. (Older checked-in files from upstream are harmless.)
+
+If no matching section exists, the pipeline emits a workflow warning and
+falls back to `HealthChat <version> — automated build from <ref>.`. Prefer
+fixing the changelog over relying on the fallback.
+
+## After the release
+
+- [ ] Workflow run is green in GitHub Actions.
+- [ ] Build appears under Play Console → Internal testing within ~10 minutes.
+- [ ] Internal testers get the update automatically if they're enrolled.
+- [ ] AAB + `mapping.txt` are attached to the workflow run, retained 90 days.
+
+## Required GitHub Actions secrets
+
+The pipeline depends on these repository secrets. Missing any causes the
+workflow to fail at the corresponding step. The values are identical to the
+ones configured on the old `Novaloop-AG/element-android` repository (same
+upload keystore, same Play listing) — except `GOOGLE_SERVICES_JSON_BASE64`,
+which element-x-android does **not** use (Firebase config is compiled in via
+`libraries/pushproviders/firebase/src/main/res/values/firebase.xml`).
+
+| Secret | Source |
+|---|---|
+| `RELEASE_KEYSTORE_BASE64` | `base64 -w0 release.keystore` (the HealthChat upload keystore, alias `healthchat-upload`) |
+| `RELEASE_KEYSTORE_PASSWORD` | Keystore password |
+| `RELEASE_KEY_ALIAS` | Key alias inside the keystore |
+| `RELEASE_KEY_PASSWORD` | Key password |
+| `GOOGLE_PLAY_SERVICE_ACCOUNT_JSON` | Play Console → Users and permissions → invite a service account → download JSON. Needs "Release manager" permissions scoped to `ch.healthchat.element`. |
+
+## Keystore rotation (rare, high-risk)
+
+Unlike Apple Distribution certificates, **Android upload keystores do not
+expire** and should not be rotated casually. The upload key is tied to the
+app's identity in Play Console (Play App Signing is enabled; the repo key is
+the upload key); rotating it is a one-way process that uses Play App
+Signing's "Upload key reset" flow.
+
+If the keystore is lost or believed to be compromised:
+
+1. Play Console → Release → Setup → App integrity → Upload key → **Request
+   upload key reset**. Instructions follow, requiring you to upload a new
+   keystore and wait for Google to rotate.
+2. Generate a fresh keystore on the operator's machine:
+   ```bash
+   keytool -genkey -v -keystore healthchat-upload-new.jks \
+     -keyalg RSA -keysize 2048 -validity 10000 -alias healthchat
+   ```
+3. Once Google confirms the rotation, re-encode and update secrets:
+   `base64 -w0 healthchat-upload-new.jks | pbcopy`, then replace
+   `RELEASE_KEYSTORE_BASE64`, `RELEASE_KEYSTORE_PASSWORD`, `RELEASE_KEY_ALIAS`,
+   `RELEASE_KEY_PASSWORD` in repo settings.
+4. Run the release workflow via `workflow_dispatch` with a throwaway version
+   bump and `release_status: draft` to verify end-to-end. Discard the draft.
+
+**Do not attempt rotation without reading Play App Signing docs end-to-end**
+and coordinating a maintenance window. A botched rotation means users can't
+receive updates until Google completes the reset.
+
+## Promoting internal → production
+
+Internal builds and production builds are the same AAB. To release a
+validated internal build:
+
+1. Play Console → HealthChat → Testing → **Internal testing** → find the
+   release.
+2. Confirm it passed internal testing.
+3. **Promote release** → Production → **Release details** → fill in "What's
+   new" (Play Console copies it from the internal release — verify) →
+   **Review release** → **Start rollout to Production**.
+4. Choose staged rollout % if desired.
+
+**This step is deliberately not automated.** Production releases require
+human judgment on rollout percentage, Play Store listing changes, and
+compliance metadata review.
+
+## Rollback
+
+- **Bad build, release notes fine** → fix the cause, bump
+  `versionReleaseNumber`, commit, tag `healthchat-v<ver>`. The new build
+  supersedes the bad one on the internal track.
+- **Bad release notes only** → edit `HEALTHCHAT_CHANGES.md` on
+  `release/healthchat`, then update the "What's new" text in the Play Console
+  release manually (the pipeline only writes it at upload time).
+- **Completely wrong version number** → treat as burned. Bump
+  `versionReleaseNumber` further, tag a higher `healthchat-v<ver>`. Play
+  Store's `versionCode` rule means the next run naturally supersedes.
+- **Production rollout gone wrong** → Play Console → Production → **Halt
+  rollout** (works during staged rollout), then ship a hotfix as above.
+
+## Known branch divergence when merging upstream
+
+When merging a newer upstream Element X release tag into `release/healthchat`
+(temporarily add `https://github.com/element-hq/element-x-android` as a
+remote, fetch, merge, remove the remote — never keep a permanent upstream
+remote):
+
+- **`.github/workflows/healthchat-release-playstore.yml`**,
+  **`HEALTHCHAT_CHANGES.md`**, and
+  **`.claude/skills/releasing-healthchat/SKILL.md`** are HealthChat-only —
+  any merge conflict here means something upstream accidentally overlaps;
+  keep `--ours`.
+- **`plugins/src/main/kotlin/config/BuildTimeConfig.kt`** —
+  `APPLICATION_ID = "ch.healthchat.element"`, `APPLICATION_NAME = "HealthChat"`,
+  `METADATA_HOST_REVERSED`, and the healthchat.ch URLs must survive merges.
+  Upstream uses `io.element.android.x` / `Element X` / nulls.
+- **`appconfig/.../ApplicationConfig.kt`** — `PRODUCTION_APPLICATION_NAME` /
+  `DESKTOP_APPLICATION_NAME = "HealthChat"` must survive. Upstream: `Element`.
+- **`features/enterprise/impl-foss/.../DefaultEnterpriseService.kt`** —
+  `defaultHomeserverList() = listOf("matrix.healthchat.ch")` must survive.
+  Upstream returns an empty list.
+- **`app/build.gradle.kts`** — the `healthchat` signing config and the
+  `appicon/healthchat` dependency must survive; upstream signs release with
+  the debug keystore and depends on `appicon/element`.
+- **`plugins/src/main/kotlin/Versions.kt`** — take upstream's version when
+  higher (see Versioning above).
+- **`fastlane/metadata/android/`** — HealthChat listing texts (en-US, de-DE)
+  must survive; upstream ships Element X texts. The per-versionCode changelog
+  files generated by this pipeline carry HealthChat text; conflicts there
+  mean a versionCode collided — regenerate from `HEALTHCHAT_CHANGES.md` on
+  the next release run rather than hand-merging.

.github/workflows/healthchat-release-playstore.yml

@@ -0,0 +1,241 @@
+name: HealthChat Release to Google Play Store
+
+on:
+  push:
+    tags:
+      - 'healthchat-v*'
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Marketing version (e.g. 26.07.0). Required when running manually.'
+        required: true
+        type: string
+      track:
+        description: 'Play Store track'
+        required: true
+        default: 'internal'
+        type: choice
+        options:
+          - internal
+          - alpha
+          - beta
+          - production
+      release_status:
+        description: 'Release status'
+        required: true
+        default: 'completed'
+        type: choice
+        options:
+          - completed
+          - inProgress
+          - halted
+          - draft
+      release_notes_override:
+        description: 'Optional release notes. If empty, falls back to HEALTHCHAT_CHANGES.md section for the given version.'
+        required: false
+        type: string
+
+permissions:
+  # Only need read access to clone. Upload uses the Play Console service
+  # account JSON from secrets, not GITHUB_TOKEN.
+  contents: read
+
+concurrency:
+  group: healthchat-release-${{ github.event.inputs.version || github.ref_name }}
+  cancel-in-progress: true
+
+env:
+  # Upstream's workflows hardcode -Xmx8g / Kotlin daemon -Xmx4g, sized for the
+  # 4-core/16GB ubuntu-latest that public repos get. On this container the
+  # daemon keeps getting SIGKILLed mid-build (DaemonDisappearedException, no
+  # OutOfMemoryError, no heap dump), so stay well under upstream's ceiling and
+  # leave room for the Kotlin daemon and the parallel lint workers.
+  GRADLE_OPTS: -Dorg.gradle.jvmargs=-Xmx6g -XX:MaxMetaspaceSize=768m -Dfile.encoding=UTF-8 -XX:+HeapDumpOnOutOfMemoryError -XX:+UseG1GC -Dkotlin.daemon.jvm.options=-Xmx2g
+  CI_GRADLE_ARG_PROPERTIES: --stacktrace --no-daemon -Dsonar.gradle.skipCompile=true --no-configuration-cache
+
+jobs:
+  release:
+    name: Build and upload AAB to Play Store
+    runs-on: novaloop-incus-large
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+
+      # Tag pushes must originate from release/healthchat. Dispatch runs must be
+      # invoked from that branch too. Reject anything else up-front so we don't
+      # ship off main/develop.
+      - name: Verify ref is on release/healthchat
+        run: |
+          set -euo pipefail
+          # On tag pushes, GITHUB_REF_NAME is the tag, not the branch. Resolve
+          # the commit's branch membership instead.
+          if ! git branch -r --contains "$GITHUB_SHA" | grep -qE 'origin/release/healthchat$'; then
+            echo "::error::Commit $GITHUB_SHA is not on origin/release/healthchat. Refusing to release."
+            exit 1
+          fi
+
+      - name: Resolve marketing version
+        id: version
+        run: |
+          set -euo pipefail
+          if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
+            VERSION="${{ github.event.inputs.version }}"
+          else
+            VERSION="${GITHUB_REF_NAME#healthchat-v}"
+          fi
+          if ! [[ "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+([.-][0-9A-Za-z.-]+)?$ ]]; then
+            echo "::error::Invalid marketing version '$VERSION' — expected e.g. 26.07.0"
+            exit 1
+          fi
+          # Drop any pre-release/build suffix (e.g. -rc1, -hotfix1) for the Versions.kt comparison.
+          BASE_VERSION=$(echo "$VERSION" | sed -E 's/([0-9]+\.[0-9]+\.[0-9]+)([.-].*)?$/\1/')
+          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+          echo "base_version=$BASE_VERSION" >> "$GITHUB_OUTPUT"
+          echo "Resolved marketing version: $VERSION (base: $BASE_VERSION)"
+
+      - name: Verify Versions.kt matches tag
+        id: gradle_version
+        env:
+          BASE_VERSION: ${{ steps.version.outputs.base_version }}
+        run: |
+          set -euo pipefail
+          VERSIONS_FILE=plugins/src/main/kotlin/Versions.kt
+          YEAR=$(grep -E 'private const val versionYear' "$VERSIONS_FILE" | sed -E 's/.*=\s*([0-9]+).*/\1/')
+          MONTH=$(grep -E 'private const val versionMonth' "$VERSIONS_FILE" | sed -E 's/.*=\s*([0-9]+).*/\1/')
+          REL=$(grep -E 'private const val versionReleaseNumber' "$VERSIONS_FILE" | sed -E 's/.*=\s*([0-9]+).*/\1/')
+          if [[ -z "$YEAR" || -z "$MONTH" || -z "$REL" ]]; then
+            echo "::error::Could not parse versionYear/versionMonth/versionReleaseNumber from $VERSIONS_FILE"
+            exit 1
+          fi
+          # VERSION_NAME format (see Versions.kt): year on 2 digits, month zero-padded to 2, release number unpadded.
+          GRADLE_VERSION="${YEAR}.$(printf '%02d' "$MONTH").${REL}"
+          echo "Parsed $VERSIONS_FILE: $GRADLE_VERSION"
+          if [[ "$GRADLE_VERSION" != "$BASE_VERSION" ]]; then
+            echo "::error::Tag version $BASE_VERSION does not match Versions.kt ($GRADLE_VERSION). Bump versionYear/versionMonth/versionReleaseNumber and commit before tagging."
+            exit 1
+          fi
+          # Formula (see Versions.kt VERSION_CODE): (2000+year)*10_000 + month*100 + releaseNumber,
+          # then *10 for the AAB output (ABI code 0 — see app/build.gradle.kts androidComponents block).
+          BASE_CODE=$(( (2000 + YEAR) * 10000 + MONTH * 100 + REL ))
+          VERSION_CODE=$(( BASE_CODE * 10 ))
+          echo "version_code=$VERSION_CODE" >> "$GITHUB_OUTPUT"
+          echo "Computed versionCode: $VERSION_CODE"
+
+      - name: Extract release notes
+        id: notes
+        env:
+          VERSION: ${{ steps.version.outputs.base_version }}
+          OVERRIDE: ${{ github.event.inputs.release_notes_override }}
+        run: |
+          set -euo pipefail
+          if [[ -n "${OVERRIDE:-}" ]]; then
+            NOTES="$OVERRIDE"
+            echo "Using release notes from workflow input"
+          else
+            NOTES=$(awk -v ver="$VERSION" '
+              /^## Changes in / {
+                if (found) { exit }
+                if ($0 ~ "## Changes in " ver "( |$|\\()") { found = 1; next }
+              }
+              found { print }
+            ' HEALTHCHAT_CHANGES.md | sed '/^[[:space:]]*$/{N;/^\n$/D;}')
+            if [[ -z "$NOTES" ]]; then
+              NOTES="HealthChat ${VERSION} — automated build from ${GITHUB_REF_NAME}."
+              echo "::warning::No HEALTHCHAT_CHANGES.md section found for $VERSION — using fallback"
+            fi
+          fi
+          # Play Store "What's new" has a 500-character limit per locale.
+          CHAR_COUNT=$(printf '%s' "$NOTES" | wc -c)
+          if (( CHAR_COUNT > 500 )); then
+            echo "::warning::Release notes are $CHAR_COUNT chars; Play Store truncates at 500"
+          fi
+          {
+            echo 'notes<<NOTES_EOF'
+            echo "$NOTES"
+            echo 'NOTES_EOF'
+          } >> "$GITHUB_OUTPUT"
+
+      - name: Generate fastlane changelog files
+        env:
+          VERSION_CODE: ${{ steps.gradle_version.outputs.version_code }}
+          NOTES: ${{ steps.notes.outputs.notes }}
+        run: |
+          set -euo pipefail
+          for locale in en-US de-DE; do
+            dir="fastlane/metadata/android/${locale}/changelogs"
+            mkdir -p "$dir"
+            printf '%s\n' "$NOTES" > "${dir}/${VERSION_CODE}.txt"
+            echo "Wrote ${dir}/${VERSION_CODE}.txt"
+          done
+
+      - name: Use JDK 21
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '21'
+
+      # The self-hosted runner image has no Android SDK (unlike GitHub-hosted
+      # ubuntu-latest), so install it here.
+      # - platform: follows COMPILE_SDK in plugins/src/main/kotlin/Versions.kt.
+      #   Platform packages are minor-versioned, so compileSdk 37 is android-37.0.
+      # - build-tools: nothing sets buildToolsVersion, so AGP picks its own
+      #   default (SdkConstants.CURRENT_BUILD_TOOLS_VERSION). Bump it when AGP is
+      #   upgraded, not when Versions.kt changes.
+      - name: Set up Android SDK
+        uses: android-actions/setup-android@v3
+        with:
+          packages: 'platforms;android-37.0 build-tools;36.0.0'
+
+      - name: Configure gradle
+        uses: gradle/actions/setup-gradle@v4
+
+      - name: Decode keystore
+        run: |
+          echo "${{ secrets.RELEASE_KEYSTORE_BASE64 }}" | base64 -d > app/signature/release.keystore
+
+      # Recorded on every run so build failures can be read against the
+      # runner's actual capacity instead of guessed at.
+      - name: Report runner capacity
+        run: |
+          free -h
+          nproc
+          df -h .
+          # free reads /proc/meminfo, which in a container may report the host's
+          # total rather than the enforced limit. This is what the kernel enforces.
+          cat /sys/fs/cgroup/memory.max 2>/dev/null \
+            || cat /sys/fs/cgroup/memory/memory.limit_in_bytes 2>/dev/null \
+            || echo "no cgroup memory limit visible"
+
+      - name: Build Release AAB
+        run: |
+          ./gradlew bundleGplayRelease $CI_GRADLE_ARG_PROPERTIES
+        env:
+          RELEASE_STORE_FILE: signature/release.keystore
+          RELEASE_STORE_PASSWORD: ${{ secrets.RELEASE_KEYSTORE_PASSWORD }}
+          RELEASE_KEY_ALIAS: ${{ secrets.RELEASE_KEY_ALIAS }}
+          RELEASE_KEY_PASSWORD: ${{ secrets.RELEASE_KEY_PASSWORD }}
+
+      - name: Upload workflow artifacts
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: healthchat-${{ steps.version.outputs.version }}
+          path: |
+            app/build/outputs/bundle/gplayRelease/*.aab
+            app/build/outputs/mapping/gplayRelease/mapping.txt
+          retention-days: 90
+          if-no-files-found: warn
+
+      - name: Upload to Play Store
+        uses: r0adkll/upload-google-play@v1
+        with:
+          serviceAccountJsonPlainText: ${{ secrets.GOOGLE_PLAY_SERVICE_ACCOUNT_JSON }}
+          packageName: ch.healthchat.element
+          releaseFiles: app/build/outputs/bundle/gplayRelease/*.aab
+          tracks: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.track || 'internal' }}
+          status: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.release_status || 'completed' }}
+          whatsNewDirectory: fastlane/metadata/android
+          mappingFile: app/build/outputs/mapping/gplayRelease/mapping.txt
+          changesNotSentForReview: true

.gitignore

@@ -79,6 +79,9 @@ captures/
 #*.jks
 #*.keystore
 
+# HealthChat upload keystore, materialized from a CI secret — never commit it
+app/signature/release.keystore
+
 # External native build folder generated in Android Studio 2.2 and later
 .externalNativeBuild
 .cxx/

HEALTHCHAT_CHANGES.md

@@ -0,0 +1,15 @@
+# HealthChat Android changelog
+
+This file is the single source for Play Store "What's new" texts. The release
+pipeline (`.github/workflows/healthchat-release-playstore.yml`) extracts the
+top section matching the released version — the heading must have the exact
+form `## Changes in <version> (<date>)` and the whole section must stay under
+500 characters. See `.claude/skills/releasing-healthchat/SKILL.md`.
+
+## Changes in 26.07.0 (2026-07-16)
+
+🎉 Komplett neue App-Generation
+
+- HealthChat basiert neu auf Element X: schnellere Synchronisation, moderne Oberfläche und verbesserte Verschlüsselung.
+- Anmeldung neu über den sicheren HealthChat Login (SSO).
+- Hinweis: Nach dem Update ist eine einmalige Neuanmeldung erforderlich.

app/build.gradle.kts

@@ -98,6 +98,18 @@ android {
             )
             storePassword = environmentOrGradleValue("ELEMENT_ANDROID_NIGHTLY_STOREPASSWORD", "signing.element.nightly.storePassword")
         }
+        // HealthChat Play Store upload key. The keystore is not in the repo:
+        // CI decodes it from the RELEASE_KEYSTORE_BASE64 secret (see
+        // .github/workflows/healthchat-release-playstore.yml).
+        register("healthchat") {
+            keyAlias = System.getenv("RELEASE_KEY_ALIAS")
+                ?: project.property("signing.healthchat.keyId") as? String?
+            keyPassword = System.getenv("RELEASE_KEY_PASSWORD")
+                ?: project.property("signing.healthchat.keyPassword") as? String?
+            storeFile = file(System.getenv("RELEASE_STORE_FILE") ?: "./signature/release.keystore")
+            storePassword = System.getenv("RELEASE_STORE_PASSWORD")
+                ?: project.property("signing.healthchat.storePassword") as? String?
+        }
     }
 
     val baseAppName = BuildTimeConfig.APPLICATION_NAME
@@ -124,7 +136,13 @@ android {
                 "login_redirect_scheme",
                 oAuthRedirectSchemeBase,
             )
-            signingConfig = signingConfigs.getByName("debug")
+            // Sign with the HealthChat upload key when it is available (CI),
+            // fall back to the debug key for local release builds.
+            signingConfig = if (System.getenv("RELEASE_STORE_FILE") != null || file("./signature/release.keystore").exists()) {
+                signingConfigs.getByName("healthchat")
+            } else {
+                signingConfigs.getByName("debug")
+            }
 
             optimization {
                 enable = true

fastlane/metadata/android/de-DE/full_description.txt

@@ -0,0 +1,3 @@
+HealthChat ist die durchgehend verschlüsselte (Ende-zu-Ende-verschlüsselte, E2EE) Kommunikationslösung für HealthProfessionals – entwickelt in der Schweiz, für das Schweizer Gesundheitssystem.
+
+Ob Ärztinnen und Ärzte, Pflegefachpersonen, Medizinische Praxisassistentinnen, Spitex-Fachkräfte oder Therapeutinnen – HealthChat ermöglicht eine sichere, einfache und effiziente Kommunikation innerhalb und zwischen interprofessionellen Teams.

fastlane/metadata/android/de-DE/short_description.txt

@@ -0,0 +1 @@
+Sichere Kommunikation für Gesundheitsfachpersonen

fastlane/metadata/android/de-DE/title.txt

@@ -0,0 +1 @@
+HealthChat

fastlane/metadata/android/en-US/full_description.txt

@@ -1,29 +1,3 @@
-Freedom to communicate on your own terms
+HealthChat ist die durchgehend verschlüsselte (Ende-zu-Ende-verschlüsselte, E2EE) Kommunikationslösung für HealthProfessionals – entwickelt in der Schweiz, für das Schweizer Gesundheitssystem.
 
-For individuals and communities - private communication between family, friends, hobby groups, clubs, etc.
+Ob Ärztinnen und Ärzte, Pflegefachpersonen, Medizinische Praxisassistentinnen, Spitex-Fachkräfte oder Therapeutinnen – HealthChat ermöglicht eine sichere, einfache und effiziente Kommunikation innerhalb und zwischen interprofessionellen Teams.
-
-Element X gives you fast, secure and private instant messaging and video calls built on Matrix, the open standard for real-time communication. This is a free and open-source app maintained at https://github.com/element-hq/element-x-android.
-
-Stay in touch with friends, family and communities with:
- • Real time messaging & video calls
- • Public rooms for open group communication
- • Private rooms for closed group communication
- • Rich messaging features: emoji reactions, replies, polls, pinned messages and more.
- • Video calling while browsing messages.
- • Interoperability with other Matrix-based apps such as FluffyChat, Cinny and many more.
-
-<b>Privacy-first<b>
-Unlike some other messengers from Big Tech companies, we don’t mine your data or monitor your communications.
-
-<b>Own your conversations</b>
-Choose where to host your data - from any public server (the largest free server is matrix.org, but there are plenty of others to choose from) to creating your own personal server and hosting it on your own domain. This ability to choose a server is a large part of what differentiates us from other real time communication apps. However you host, you have ownership; it’s your data. You’re not the product. You’re in control.
-
-<b>Communicate in real time, all the time</b>
-Use Element everywhere. Stay in touch wherever you are with fully synchronised message history across all your devices, including on the web at https://app.element.io
-
-<b>Element X is our next-generation app</b>
-If you’re using the previous-generation Element Classic app, it’s time to try Element X! It’s faster, easier to use, and more powerful than the classic app. It’s better in every way and we’re adding new features all the time.
-
-The application requires the android.permission.REQUEST_INSTALL_PACKAGES permission to enable the installation of applications received as attachments, ensuring seamless and convenient access to new software within the app.
-
-The application requires the USE_FULL_SCREEN_INTENT permission to ensure our users can effectively receive call notifications even when their devices are locked.

fastlane/metadata/android/en-US/short_description.txt

@@ -1 +1 @@
-Sovereign. Seamless. On Matrix
+Sichere Kommunikation für Gesundheitsfachpersonen

fastlane/metadata/android/en-US/title.txt

@@ -1 +1 @@
-Element X - Secure Chat & Call
+HealthChat

gradle.properties

@@ -44,6 +44,12 @@ signing.element.nightly.storePassword=Secret
 signing.element.nightly.keyId=Secret
 signing.element.nightly.keyPassword=Secret
 
+# Dummy values for the HealthChat release signing secrets, overridden by env
+# vars in CI (see .github/workflows/healthchat-release-playstore.yml)
+signing.healthchat.storePassword=Secret
+signing.healthchat.keyId=Secret
+signing.healthchat.keyPassword=Secret
+
 # Customise the Lint version to use a more recent version than the one bundled with AGP
 # https://googlesamples.github.io/android-custom-lint-rules/usage/newer-lint.md.html
 # android.experimental.lint.version=8.12.2