takeloom 0.5.0__tar.gz

takeloom-0.5.0/.github/workflows/daily.yml

@@ -0,0 +1,90 @@
+# Daily build: once a day, if anything was committed since the last build
+# (daily or release), build takeloom and publish it as a GitHub pre-release
+# tagged daily-YYYY-MM-DD. Never sent to PyPI/Homebrew/apt — that's
+# release.yml. See docs/releasing.md.
+name: Daily build
+
+on:
+  schedule:
+    # 07:00 UTC: midnight in Denver in winter (MST), 1am in summer (MDT) —
+    # always after the day being built has ended.
+    - cron: "0 7 * * *"
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+concurrency: daily-build
+
+jobs:
+  daily:
+    runs-on: ubuntu-latest
+    env:
+      GH_TOKEN: ${{ github.token }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0  # tags + history: the version comes from them
+
+      - name: Anything new since the last build?
+        id: check
+        run: |
+          if [ -n "$(git tag --points-at HEAD --list 'daily-*' 'v[0-9]*')" ]; then
+            echo "Nothing committed since the last build — no daily build today."
+            echo "skip=true" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+          # Named for the (Denver) day the newest commit was made.
+          day=$(TZ=America/Denver git log -1 --format=%cd --date=format-local:%Y-%m-%d)
+          previous=$(git describe --tags --abbrev=0 --match 'daily-*' --match 'v[0-9]*' 2>/dev/null || true)
+          echo "skip=false" >> "$GITHUB_OUTPUT"
+          echo "tag=daily-$day" >> "$GITHUB_OUTPUT"
+          echo "day=$day" >> "$GITHUB_OUTPUT"
+          echo "previous=$previous" >> "$GITHUB_OUTPUT"
+
+      - uses: actions/setup-python@v5
+        if: steps.check.outputs.skip == 'false'
+        with:
+          python-version: "3.12"
+
+      - name: Build
+        if: steps.check.outputs.skip == 'false'
+        run: |
+          python -m pip install --quiet build
+          python -m build
+          ls dist
+
+      - name: Smoke test
+        if: steps.check.outputs.skip == 'false'
+        run: |
+          sudo apt-get update -qq && sudo apt-get install -y -qq libportaudio2 libsndfile1
+          python -m pip install --quiet dist/*.whl
+          takeloom --help
+
+      - name: Publish pre-release
+        if: steps.check.outputs.skip == 'false'
+        run: |
+          tag="${{ steps.check.outputs.tag }}"
+          previous="${{ steps.check.outputs.previous }}"
+          version=$(ls dist/*.whl | sed -E 's/.*takeloom-([^-]+)-.*/\1/')
+          {
+            echo "Daily build of \`main\` for ${{ steps.check.outputs.day }} — version $version."
+            echo
+            echo "Not a release: for testing. Install the wheel with \`pipx install <url of the .whl>\`."
+            echo
+            echo "### Changes since ${previous:-the beginning}"
+            git log --format='- %s (%h)' ${previous:+$previous..}HEAD
+          } > notes.md
+          # A second build on the same day (manual run) replaces the first.
+          gh release delete "$tag" --cleanup-tag --yes 2>/dev/null || true
+          gh release create "$tag" dist/* --prerelease --target "$GITHUB_SHA" \
+            --title "Daily build ${{ steps.check.outputs.day }} ($version)" --notes-file notes.md
+
+      - name: Keep only the last 14 daily builds
+        if: steps.check.outputs.skip == 'false'
+        run: |
+          gh release list --limit 200 --json tagName,createdAt \
+            -q '[.[] | select(.tagName | startswith("daily-"))] | sort_by(.createdAt) | reverse | .[14:] | .[].tagName' |
+          while read -r old; do
+            gh release delete "$old" --cleanup-tag --yes
+          done

takeloom-0.5.0/.github/workflows/release.yml

@@ -0,0 +1,107 @@
+# Release: run by hand (Actions tab -> Release -> Run workflow, or
+# `gh workflow run release.yml -f bump=minor`). Tags the current main as
+# the next version, builds it, and publishes it as a GitHub release. The
+# package-manager channels (PyPI, Homebrew, apt, ...) hang off the end of
+# this as they're added. See docs/releasing.md.
+name: Release
+
+on:
+  workflow_dispatch:
+    inputs:
+      bump:
+        description: Which part of the version to bump
+        type: choice
+        options: [minor, patch, major]
+        default: minor
+
+permissions:
+  contents: write
+
+concurrency: release
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    env:
+      GH_TOKEN: ${{ github.token }}
+    outputs:
+      version: ${{ steps.version.outputs.version }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Next version
+        id: version
+        run: |
+          previous=$(git describe --tags --abbrev=0 --match 'v[0-9]*')
+          if [ -n "$(git tag --points-at HEAD --list 'v[0-9]*')" ]; then
+            echo "::error::main is already released as $previous — nothing new to release."
+            exit 1
+          fi
+          IFS=. read -r major minor patch <<< "${previous#v}"
+          case "${{ inputs.bump }}" in
+            major) version="$((major + 1)).0.0" ;;
+            minor) version="$major.$((minor + 1)).0" ;;
+            patch) version="$major.$minor.$((patch + 1))" ;;
+          esac
+          echo "Releasing $version (previous: $previous)"
+          echo "version=$version" >> "$GITHUB_OUTPUT"
+          echo "previous=$previous" >> "$GITHUB_OUTPUT"
+
+      - name: Tag
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git tag -a "v${{ steps.version.outputs.version }}" -m "takeloom ${{ steps.version.outputs.version }}"
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Build
+        run: |
+          python -m pip install --quiet build
+          python -m build
+          ls dist
+          # The tag must have produced exactly this version, not a .dev one.
+          test -f "dist/takeloom-${{ steps.version.outputs.version }}-py3-none-any.whl"
+
+      - name: Smoke test
+        run: |
+          sudo apt-get update -qq && sudo apt-get install -y -qq libportaudio2 libsndfile1
+          python -m pip install --quiet dist/*.whl
+          takeloom --help
+
+      - name: Push tag and publish release
+        run: |
+          version="${{ steps.version.outputs.version }}"
+          previous="${{ steps.version.outputs.previous }}"
+          git push origin "v$version"
+          {
+            echo "### Changes since $previous"
+            git log --format='- %s (%h)' "$previous..HEAD"
+          } > notes.md
+          gh release create "v$version" dist/* --latest --title "takeloom $version" --notes-file notes.md
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  pypi:
+    # Trusted publishing: PyPI's takeloom project trusts this repo's
+    # release.yml in the "pypi" environment, so no token is stored anywhere.
+    needs: release
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/takeloom/${{ needs.release.outputs.version }}/
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

takeloom-0.5.0/.gitignore

@@ -0,0 +1,20 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+*.egg
+.eggs/
+*.flac
+*.wav
+!takeloom/data/measure_latency.wav
+*.mp3
+*.m4a
+.env
+
+# Takeloom Camera app build output (camera_app/)
+camera_app/ios/TakeloomCamera.xcodeproj/
+camera_app/android/.gradle/
+camera_app/android/local.properties
+camera_app/android/app/build/
+.DS_Store

takeloom-0.5.0/CLAUDE.md

@@ -0,0 +1,24 @@
+# Deployment
+
+Always push every commit to `origin` (`main`) right after making it — no need to ask first. This is a standing authorization for `git push` specifically in this repo; it doesn't extend to other destructive/shared-state git operations (force-push, reset --hard, etc.), which still need confirmation as usual.
+
+There are two machines running `takeloom`, installed differently:
+
+- The laptop ("Framework"), reachable via `ssh framework` (non-interactive/key-auth works). Installed via `pipx` directly from this GitHub repo (`takeloom @ git+https://github.com/priestc/takeloom.git`) — not an editable clone, so picking up new code requires a reinstall, not a `git pull`.
+- The Mac Mini — the studio hub machine with the Scarlett 4i4 attached (see `studio_hardware_scarlett_4i4` memory), and normally the machine Claude Code itself is already running on (`hostname` reports `Mac.local`). Installed via `pipx install --editable ~/Documents/GitHub/takeloom` — an editable install pointing straight at this working copy (confirm with `cat ~/.local/pipx/venvs/takeloom/lib/python*/site-packages/takeloom*.dist-info/direct_url.json`, should show `"editable": true`). Any commit — or even an uncommitted local edit — takes effect the next time `takeloom` is launched there; no reinstall step needed. (If a dependency is ever added/changed in `pyproject.toml`, that *does* still need `pipx install --editable --force ~/Documents/GitHub/takeloom` to pick up the new package.)
+
+Any change **except code that only affects server mode** (i.e. changes confined to the headless `takeloom server` path — see `takeloom/__main__.py`'s `server_command` and anything only reachable from it) should be automatically deployed once committed:
+
+1. Push to `origin` (`main`). That's the only step to take here — do not `ssh framework` to reinstall.
+2. The laptop no longer gets deployed to manually. `takeloom ui` checks GitHub's `main` on launch and self-updates (reinstalls + restarts) if it's behind — see `takeloom/update_check.py`. The user's habit is to close and reopen the app on the laptop before testing, which is what actually picks up the new commit; nothing needs to happen on the laptop from this side beyond the push.
+3. Nothing further needed for the Mac Mini — just make sure `takeloom` (or `takeloom server`) is restarted there to pick up the change.
+
+Manual laptop reinstall (reference only — for troubleshooting if auto-update ever fails or misbehaves, not part of the normal flow above):
+`ssh framework "pipx install --force git+https://github.com/priestc/takeloom.git"`
+
+# Testing setup
+
+- All actual hardware — audio interfaces (the Scarlett 4i4) and the Stream Deck — is attached to the **Mac Mini**, and only the Mac Mini ever runs `takeloom server` or performs an actual recording. Nothing is ever plugged into the laptop.
+- The **laptop ("Framework")** only ever runs `takeloom` in remote mode — connecting to the Mac Mini's `takeloom server` via the Remote tab / `--remote=IP` — to control a session running on the Mac Mini. It never has a device attached and a recording is never started or written locally on it, so the CLI recording paths (`start-session`, `inspiration`) are effectively unused/untested there in practice; treat bugs reported "on the laptop" as remote-mode bugs first.
+- The laptop sleeps whenever it's unplugged, which is its normal state (it's rarely plugged in). Keep this in mind for anything that assumes it stays awake/reachable — e.g. it can drop off the network mid-session, and any "don't sleep while recording" behavior only matters there for the remote-viewing UI, not a local recording session.
+- On the Mac Mini, the Scarlett 4i4 and Stream Deck are usually powered off between sessions. You're allowed to launch `takeloom ui` there to visually verify pure-UI changes (screenshot it, check it looks right, close it) — no need to ask first. It's expected and fine for audio devices/instrument meters/the Stream Deck connection to show empty or disconnected in that state; that's not a bug, just means the hardware happens to be off right now. Don't read anything into it unless the change you're testing is specifically about device detection/connection.

takeloom-0.5.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Chris Priest
+
+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.

takeloom-0.5.0/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.5
+Name: takeloom
+Version: 0.5.0
+Summary: Music Recording Session Manager
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.9
+Requires-Dist: click>=8.0
+Requires-Dist: mido>=1.3.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: opencv-python>=4.8.0
+Requires-Dist: pillow>=9.0.0
+Requires-Dist: pyfluidsynth>=1.3.2
+Requires-Dist: python-rtmidi>=1.5.0; sys_platform == 'darwin'
+Requires-Dist: pyusb>=1.2.1
+Requires-Dist: sounddevice>=0.4.6
+Requires-Dist: soundfile>=0.12.1
+Requires-Dist: static-ffmpeg>=2.5
+Requires-Dist: streamdeck>=0.9.0
+Requires-Dist: tkinterdnd2>=0.3.0
+Requires-Dist: wakepy>=0.7.0

takeloom-0.5.0/README.md

@@ -0,0 +1,201 @@
+# Takeloom
+
+A CLI application for musicians to record instruments over backing tracks, manage songs/albums, and track completed takes.
+
+Takeloom handles continuous audio recording, playback mixing, session logging, and per-take file management. Record one instrument at a time — each new session plays back your previous takes alongside the backing track so you can layer parts.
+
+## Requirements
+
+- Python 3.9+
+- PortAudio, libsndfile, ffmpeg (system libraries)
+- yt-dlp (optional, system binary) — only needed to add YouTube URLs as backing tracks from the New Project dialog
+
+See [Prerequisites](docs/prerequisites.md) for install instructions for each operating system.
+
+## Install
+
+```bash
+pipx install takeloom
+takeloom install-launcher
+```
+
+That's the latest release from PyPI. To follow every commit on `main`
+instead (and auto-update to it on each launch):
+`pipx install git+https://github.com/priestc/takeloom.git`
+
+`takeloom install-launcher` adds Takeloom to the Applications folder
+(macOS) or to the applications menu and desktop (Linux), so the UI opens
+like any other app. Updates still go through pipx, automatically, each
+time the UI opens.
+
+**macOS, drag-to-install:** `python3 scripts/build_macos_dmg.py` builds
+`dist/Takeloom.dmg`. Drag Takeloom into Applications. On first open the app
+installs takeloom with pipx (Homebrew's `pipx` and `python-tk` must already
+be installed). An app that came from a download is blocked the first time,
+since it isn't signed by Apple: right-click it and choose Open.
+
+## Usage
+
+### Studio Setup
+
+Configure your studio in three steps. Each command reads and updates `~/studio_config.json` independently, so you can re-run one without redoing the others.
+
+```bash
+takeloom setup-studio              # studio name, location, musician, remote vault server
+takeloom setup-recording-devices   # sample rate, buffer size, output device, input labels, camera
+takeloom setup-instruments         # assign instruments to input channels
+```
+
+`setup-recording-devices` also lets you pick a camera. If one is configured, every session
+records video alongside the audio (see [Recording Session](#recording-session)).
+
+`setup-studio` also configures the **Studio Session Vault** — shared storage for everything
+a project used to keep to itself: recorded sessions, backing tracks, and completed takes
+(see [Project Structure](#project-structure)). A project is just a setlist file now. Three
+vault modes: local only (default, under `~/Documents`), remote only (uploaded to the remote
+vault server and removed locally once every file's checksum is verified), or both (uploaded
+but also kept locally). Starting a session downloads whatever that project's setlist needs
+from the remote first, in remote-only mode.
+
+The remote vault is a separate small server, `takeloom-vault` (this repo's
+[`vault_server/`](vault_server/README.md) folder), running on the storage machine. It also
+serves a web page for browsing sessions and watching their videos. Takeloom pairs with it
+the same way Remote mode pairs: click **Pair...** next to "Remote vault server" in Studio
+Setup (or run `takeloom vault pair tank2`), then approve the code shown on the vault's web
+page. `takeloom vault status` checks the connection. If you have projects from before the vault existed, run
+`takeloom migrate-sessions-to-vault` once to move everything in — safe to re-run,
+already-migrated projects are skipped.
+
+### Graphical Interface
+
+```bash
+takeloom ui
+```
+
+Opens a desktop window (built with tkinter). Currently implements the Studio Setup screen —
+the same fields as `takeloom setup-studio` — with more screens to follow.
+
+### Creating a Project
+
+```bash
+takeloom new-project
+```
+
+Enter a project name (e.g. "My Album"). Creates `~/Takeloom Projects/My Album.json` — an
+empty setlist.
+
+### Updating the Setlist
+
+Copy audio files (FLAC, WAV, MP3, M4A) into the vault's `backing_tracks/` directory, then:
+
+```bash
+takeloom update-setlist "My Album"
+```
+
+Adds any of the vault's backing tracks not yet in this project's setlist (omit the project
+name to use the last-used project). Each track in the setlist includes a `volume` field
+(default 100%) that you can edit manually to adjust backing track playback level.
+
+### Recording Session
+
+```bash
+takeloom start-session guitar "My Album"
+```
+
+The session plays the backing track through your speakers, monitors your instrument input in real-time, and records your take. Controls:
+
+| Key | Action | When |
+|-----|--------|------|
+| `r` | Start recording (plays backing track) | Waiting |
+| `b` | Back to start (restart the take) | Playing |
+| `e` | Mark song end (complete the take) | Playing |
+| `n` | Move to next track (auto-starts recording) | Between tracks |
+| `l` | Lower backing track volume by 5% | Any time |
+| `u` | Raise backing track volume by 5% | Any time |
+| `q` | End session | Any time |
+
+**Completing a take:** Press `r` to start, then `e` when the song finishes. The take is saved to the vault's `completed_takes/` and set as the preferred take in the setlist.
+
+**Restarting a take:** Press `b` to loop back to the beginning. The backing track restarts and a new take file begins.
+
+**Volume adjustments** are saved back to the setlist file at the end of the session.
+
+**Video:** if a camera is configured (`takeloom setup-recording-devices`), the whole session is
+also recorded on video, saved as `session_video.mp4` alongside `session.flac` once the session
+ends. The video has two audio tracks: a compressed (AAC) mix of the backing track + your
+instrument for easy playback, and a lossless (FLAC) track of just your instrument alone.
+
+### Multi-Instrument Layering
+
+Start a new session with a different instrument (e.g. "bass"). The backing track plays mixed with your previously recorded preferred takes, so you hear everything together while recording the new part.
+
+### Desktop Audio Capture
+
+To record virtual instruments, software synths, or system audio, you need a virtual audio loopback device. See [Desktop Audio Capture Setup](docs/desktop-audio-capture.md) for instructions.
+
+### Live Streaming
+
+The GUI's Streaming tab can push every session live to YouTube over RTMP — just paste a
+stream key from YouTube Studio and enable it. Connecting a YouTube account is optional
+and only needed if you also want each session's stream auto-titled with the studio,
+musician, project, and date; that requires creating your own free Google Cloud OAuth
+credentials. See [YouTube Streaming Setup](docs/youtube-streaming-setup.md) for the
+steps, and why it can't just be a one-click sign-in.
+
+## Project Structure
+
+A project is just a setlist file — `<projects_dir>/My Album.json`. Everything else lives in
+the shared Studio Session Vault (see [Studio Setup](#studio-setup)) instead of belonging to
+one project, so two different projects can reference the same backing track or completed
+take (most commonly a song pulled in from the Inspiration library — see
+[Cross-Project Take Reuse](#cross-project-take-reuse)) without either downloading or
+recording it twice:
+
+```
+<projects_dir>/
+├── My Album.json
+└── Side Project.json
+
+<vault>/
+├── backing_tracks/
+│   ├── song1.mp3
+│   └── a1b2c3d4_song2.flac
+├── completed_takes/
+│   ├── song1 - guitar - take1 [upload:a1b2c3d4].flac
+│   ├── song1 - bass - take1 [upload:a1b2c3d4].flac
+│   └── song2 - guitar - take2 [youtube:dQw4w9WgXcQ].flac
+├── inspiration_takes.json
+└── sessions/
+    └── 2025-01-15_14-30-00_guitar_My Album/
+        ├── session.flac
+        ├── session_video.mp4
+        └── session_log.json
+```
+
+- `backing_tracks/` and `completed_takes/` are shared across every project. A locally
+  uploaded file gets a short random prefix added only if its plain name would otherwise
+  collide with an unrelated project's file; a file that already has a globally unique name
+  (a YouTube download, or one pulled from the Inspiration library) keeps it as-is.
+- A completed take's filename tags the exact backing track it was recorded against —
+  `[upload:<id>]`, `[youtube:<video id>]`, or `[inspiration:<track id>]` — since backing
+  tracks are shared vault-wide now and two entries can share a display name while pointing
+  at different audio.
+- Existing take files are never deleted. New takes increment the take number and replace the preferred take in the setlist.
+- `inspiration_takes.json` — the cross-project take index (see below).
+- `session.flac` — the continuous raw recording spanning the full session
+- `session_log.json` — musician, studio, and event data; what post-session processing replays to find completed takes and copy them into the vault's `completed_takes/`
+- `session_video.mp4` is only present when a camera is configured
+
+### Cross-Project Take Reuse
+
+A song pulled from the Inspiration library carries a stable ID from that library, so a take
+recorded on it from *any* project is recorded into `inspiration_takes.json` too, keyed by
+that ID. This is what lets an "inspiration filter" setlist slot (a standing "draw a random
+song from this filter each session" entry — added from the GUI's Streaming/Setlist screens)
+prefer redrawing a song other instruments already have a take on, and what lets
+`ensure_setlist_files_local` (session start, in remote vault mode) pull down another
+project's take on a shared song before it's needed.
+
+## License
+
+MIT — see [LICENSE](LICENSE). Builds and releases: [docs/releasing.md](docs/releasing.md).

takeloom-0.5.0/camera_app/android/app/build.gradle.kts

@@ -0,0 +1,32 @@
+plugins {
+    id("com.android.application")
+    id("org.jetbrains.kotlin.android")
+}
+
+android {
+    namespace = "com.priestc.takeloomcamera"
+    compileSdk = 34
+
+    defaultConfig {
+        applicationId = "com.priestc.takeloomcamera"
+        // 29: MediaFormat.KEY_MAX_B_FRAMES, and AudioRecord timestamps on
+        // the boot-time clock camera sensors often use.
+        minSdk = 29
+        targetSdk = 34
+        versionCode = 1
+        versionName = "1.0"
+    }
+
+    buildTypes {
+        release {
+            isMinifyEnabled = false
+        }
+    }
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+}

takeloom-0.5.0/camera_app/android/app/src/main/AndroidManifest.xml

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-feature android:name="android.hardware.camera.any" android:required="true" />
+    <uses-permission android:name="android.permission.CAMERA" />
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+
+    <application
+        android:allowBackup="false"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:theme="@android:style/Theme.Material.NoActionBar.Fullscreen">
+        <activity
+            android:name=".MainActivity"
+            android:configChanges="orientation|screenSize|screenLayout|keyboardHidden"
+            android:exported="true"
+            android:screenOrientation="sensorLandscape">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>