DEV Community: amekusa03

Building a 5.1ch Surround Upmixer GUI with Python & FFmpeg

amekusa03 — Tue, 01 Sep 2026 07:03:29 +0000

Building a 5.1ch Surround Upmixer GUI with Python & FFmpeg

Ever wanted to watch a movie or listen to live music with true surround sound, but only had a stereo MP3 file? I built a desktop GUI application that upmixes 2-channel stereo audio into 6-channel AC-3 (Dolby Digital 5.1) — fully customizable with slider controls and one-click presets.

🔗 GitHub: https://github.com/amekusa03/mp3-to-ac3-converter

What it does

Fully adjustable surround parameters via sliders:
- Center Mix Level (0× – 2×) — controls vocal/dialogue presence
- Rear/Surround Level (0× – 2×) — controls ambient depth
- Surround Delay (0–100 ms) — enhances spatial feel
- LFE Subwoofer Cutoff (50–200 Hz) & Gain — deep bass extraction
3 one-click presets: 🎥 Cinema, 🎵 Music/Live, 🗣️ Voice/Dialogue
Batch conversion — drop a whole folder of files
Dark / Light theme toggle
Live FFmpeg log monitor with progress bar

Built with Python, CustomTkinter (modern Tk GUI), and FFmpeg under the hood.

How the upmix works

The core idea is converting stereo (L, R) into 5.1 (FL, FR, FC, LFE, SL, SR) using FFmpeg's filter_complex. Here's the math:

Channel	Formula	Purpose
FL / FR	L, R directly	Front left/right
FC (Center)	`(L + R) × 0.707 × center_gain`	Vocals, dialogue
LFE (Sub)	`lowpass((L + R) × 0.5, cutoff_hz)`	Deep bass
SL (Surround L)	`(L − R) × 0.707 × rear_gain + delay`	Ambient / effects
SR (Surround R)	`(R − L) × 0.707 × rear_gain + delay`	Ambient / effects

The phase difference (L − R) is what makes surround sound "come from behind" — it extracts stereo-only information that would be mixed out in mono, and sends it to the rear speakers.

Here's what the generated FFmpeg filter looks like:

[0:a]asplit=5[in_flfr][in_c][in_lfe][in_sl][in_sr];
[in_flfr]pan=stereo|c0=c0|c1=c1[flfr];
[in_c]pan=1c|c0=0.707*c0+0.707*c1,volume=1.000[c];
[in_lfe]pan=1c|c0=0.5*c0+0.5*c1,lowpass=f=120,volume=1.000[lfe];
[in_sl]pan=1c|c0=0.707*c0-0.707*c1,adelay=20|20,volume=0.700[sl];
[in_sr]pan=1c|c0=-0.707*c0+0.707*c1,adelay=20|20,volume=0.700[sr];
[flfr][c][lfe][sl][sr]amerge=inputs=5,pan=5.1|FL=c0|FR=c1|FC=c2|LFE=c3|BL=c4|BR=c5[out]

Code highlights

Thread-safe UI updates with a queue

Tkinter is single-threaded. Calling UI methods from a background FFmpeg worker thread will crash the app. The solution is a queue.Queue polled by after() on the main thread:

def _process_queue(self):
    """Called every 50ms on main thread — safely drains worker messages."""
    try:
        while True:
            msg_type, data = self.msg_queue.get_nowait()
            if msg_type == "log":
                self.append_log(data)
            elif msg_type == "progress":
                self.progress_bar.set(data)
            elif msg_type == "batch_complete":
                # ... handle completion
    except queue.Empty:
        pass
    finally:
        self.after(50, self._process_queue)  # reschedule

The background worker puts messages into the queue; the main thread processes them. No locks, no crashes.

Fixing Python's late-binding closure trap

A subtle bug lurks when defining closures inside a for loop — the variable idx gets bound by reference, so all closures end up using the last loop value:

# ❌ Bug: idx is always the final loop value
def _on_progress(p):
    overall_p = ((idx - 1) + p) / total_files

# ✅ Fix: capture current value via default argument
def _on_progress(p, _idx=idx, _total=total_files):
    overall_p = ((_idx - 1) + p) / _total

Default argument values are evaluated at definition time, so each closure gets the correct snapshot of idx.

Clean preset system with dataclasses

@dataclass
class AudioPreset:
    name: str
    description: str
    icon: str
    center_gain: float   # 0.0 to 2.0
    rear_gain: float
    rear_delay: int      # ms
    lfe_cutoff: int      # Hz
    lfe_gain: float
    bitrate: str         # '448k', '640k', etc.
    sample_rate: int     # 48000 / 44100

Presets are just dictionaries of AudioPreset objects — trivial to add new ones, and the UI automatically reflects the values when clicked.

Quick start

# Requirements: Python 3.8+, FFmpeg in PATH

git clone https://github.com/[YourUsername]/mp3-to-ac3-converter
cd mp3-to-ac3-converter
./run.sh   # auto-creates venv, installs deps, launches app

Works on Linux and macOS. Windows users can run venv\Scripts\activate + python main.py manually.

What I learned

FFmpeg's filter_complex is incredibly powerful — you can split, transform, recombine audio streams in one pipeline with no intermediate files.
CustomTkinter makes modern-looking Tk GUIs much easier — dark mode, rounded corners, and consistent theming out of the box.
The queue.Queue + after() pattern is the right way to drive Tkinter updates from worker threads — cleaner than after lambdas scattered everywhere.
Python closure late binding is a real gotcha — always use default argument capture when building callbacks inside loops.

Feel free to open issues, submit PRs, or fork it for your own surround mix experiments. Contributions welcome!

🔗 GitHub: https://github.com/amekusa03/mp3-to-ac3-converter
📘 日本語版記事 (Qiita): https://qiita.com/amekusa03/items/c425d0870f462bfb7645

Building FocusCycle: A Non-Intrusive Qt5/C++ Pomodoro Timer for Linux

amekusa03 — Fri, 21 Aug 2026 05:01:14 +0000

I have a bad habit with traditional Pomodoro apps: when the 25-minute timer finishes, a loud bell rings or a massive popup interrupts me mid-thought. That's the opposite of focus.

I also work in an office with fixed break times (lunch at 12:00, afternoon break at 15:00).

That’s why I developed FocusCycle—a Qt5/C++ Pomodoro timer for Linux.

What FocusCycle Does Differently

1. 🖱 Smart Idle Detection (Wayland & X11)

The most important feature: FocusCycle won't interrupt you until you stop typing.

When the work timer reaches 0:00, instead of immediately popping up a break dialog, it keeps counting negative into overtime (-00:01, -00:02...) while monitoring your keyboard/mouse activity in the background. Only once you've been idle for a configurable number of seconds (0–30) does the break prompt appear.

On Wayland (GNOME), this uses the org.gnome.Mutter.IdleMonitor D-Bus API:

// IdleMonitor.cpp — cached D-Bus interface, queried every second
IdleMonitor::IdleMonitor(QObject* parent) : QObject(parent)
{
    QString waylandDisplay =
        QProcessEnvironment::systemEnvironment().value("WAYLAND_DISPLAY");
    m_waylandMode = !waylandDisplay.isEmpty();

    if (m_waylandMode) {
        m_dbusIface = new QDBusInterface(
            "org.gnome.Mutter.IdleMonitor",
            "/org/gnome/Mutter/IdleMonitor/Core",
            "org.gnome.Mutter.IdleMonitor",
            QDBusConnection::sessionBus(),
            this);
    }
    m_timer.setInterval(1000);
    connect(&m_timer, &QTimer::timeout, this, &IdleMonitor::poll);
}

qint64 IdleMonitor::getIdleTimeWayland() const
{
    if (!m_dbusIface || !m_dbusIface->isValid()) return -1;
    QDBusReply<qulonglong> reply = m_dbusIface->call("GetIdletime");
    if (!reply.isValid()) return -1;
    return static_cast<qint64>(reply.value()); // milliseconds
}

On X11, it falls back to the XScreenSaver extension (libxscrnsaver). The .pro file detects it automatically:

unix:!macx {
    packagesExist(xscrnsaver) {
        DEFINES += HAVE_X11SS
        CONFIG  += link_pkgconfig
        PKGCONFIG += xscrnsaver
        QT += x11extras
    }
}

Note: The D-Bus interface is created once in the constructor and cached — not reconstructed every polling tick. This was a bug I caught in code review and fixed before shipping.

2. 🔕 Zero-Distraction UI & System Color Palette

Focus is about eliminating distractions. When you click "Start Work", the window completely closes and hides (hide()). There are no floating timers, badges, or widgets on your screen to pull your eyes away from your work.

System Tray Tooltip: Status and time (FocusCycle | Working 24:59) are accessible via hover tooltip.
Monochrome System Colors: The tray icon uses standard system palette colors (QPalette::WindowText) during work so it blends in with OS panel icons (Wi-Fi, sound) without bright distracting colors.
No Red Accent Colors: All red font and button highlights have been removed in favor of white (#FFFFFF) and system blue (#4a90e2), creating a calm, focused environment.

3. 🏢 Scheduled Company Breaks

You can configure up to 10 daily break slots with both a start time and an optional end time:

Break 1  [12:00]  ☑ End  [13:00]
Break 2  [15:00]  □ End

When the clock hits 12:00, the company break dialog appears and work stops.
At 13:00, the app automatically resumes the previous state — no manual action needed.
Break 2 has no end time, so it stays up until you dismiss it manually.

The data is stored in INI format:

[CompanyBreaks]
Count=2
Break0=12:00-13:00
Break1=15:00

Reading it back handles both old (start-only) and new (start-end) formats for backward compatibility:

if (val.contains('-')) {
    QStringList parts = val.split('-');
    cb.startTime = QTime::fromString(parts[0].trimmed(), "HH:mm");
    cb.endTime   = QTime::fromString(parts[1].trimmed(), "HH:mm");
} else {
    cb.startTime = QTime::fromString(val.trimmed(), "HH:mm");
}

4. 🎯 The State Machine

The core of FocusCycle is CycleController — a clean state machine with 5 explicit states:

WorkWait → Working (Counts 25:00 → 0:00 → -00:01...) → BreakWait → Break → WorkWait (loop)
   ↓                                                      ↑
   └────────────────── CompanyBreak ──────────────────────┘

WorkWait: Waiting for user to start work (WorkStartWindow popped up).
Working: Timer counting down, continuing into negative seconds during idle detection (-00:01, -00:02...).
BreakWait: Idle threshold reached; BreakDialog popped up with options to Continue (reset timer) or Complete Work (take break).
Break: Break timer counting down.
CompanyBreak: Scheduled company break active.

Each state transition emits a stateChanged(AppState) signal. The UI layer (Application) connects to these to show/hide windows and send desktop notifications. The state machine itself has zero UI dependencies — it only knows about timers and signals.

// CycleController.h
signals:
    void stateChanged(AppState state);
    void workTick(int remainingSeconds);
    void breakTick(int remainingSeconds);
    void workTimeFinished();
    void breakTimeFinished();
    void showBreakDialog();
    void showCompanyBreakDialog();
    void showWorkStartWindow();

5. 📊 CSV Session Logging & Quick Task Dropdown

Every session gets logged automatically to ~/.local/share/FocusCycle/history.csv:

Start Time,End Time,Task Name,Status
2025-08-21T09:00:00,2025-08-21T09:25:00,Write blog post,Completed
2025-08-21T09:30:00,2025-08-21T09:45:00,Code review,Incomplete

Task Dropdown: WorkStartWindow reads the top 5 recent unique task names from SessionLogger and populates the task QComboBox, defaulting to your last worked task for 1-click startup.
Commas in Task Names: Task names containing commas are safely parsed by reading from both ends of each line:

int first  = line.indexOf(',');
int second = line.indexOf(',', first + 1);
int last   = line.lastIndexOf(',');
// Middle section between second and last comma = task name (may contain commas)
r.taskName = line.mid(second + 1, last - second - 1);

6. 🌐 English / Japanese UI

The app ships with English as default and Japanese as an option, switchable at runtime without restarting. Every widget implements retranslateUi() which Application calls whenever the language setting changes:

void Application::updateAllUiTranslations()
{
    m_workStartWindow->retranslateUi();
    m_breakDialog->retranslateUi();
    m_companyBreakDialog->retranslateUi();
    m_logWindow->retranslateUi();
    m_settingsDialog->retranslateUi();
    m_tray->retranslateUi();
}

Architecture Overview

src/
├── app/
│   └── Application       # Orchestrator: connects signals, owns all windows
├── core/
│   ├── Settings          # Singleton, INI persistence
│   ├── SessionLogger     # Singleton, CSV read/write
│   ├── IdleMonitor       # Wayland D-Bus / X11 XScreenSaver
│   └── AppState.h        # State enum (WorkWait, Working, BreakWait, Break, CompanyBreak)
├── timer/
│   └── CycleController   # State machine, QTimer management, stopAll() cleanup
└── ui/
    ├── WorkStartWindow   # Start window with 5-task dropdown
    ├── BreakDialog       # Break prompt (Continue / Complete Work)
    ├── CompanyBreakDialog
    ├── SettingsDialog
    ├── LogWindow
    └── TrayIcon          # Monochrome system tray icon

The separation is intentional: CycleController never touches Qt UI classes. Application bridges the core and UI layers through signals and slots.

Building It

sudo apt install qtbase5-dev libqt5dbus5 libnotify-bin build-essential

git clone https://github.com/YOUR_USERNAME/FocusCycle.git
cd FocusCycle
qmake FocusCycle.pro
make -j$(nproc)
./FocusCycle

Build outputs (*.o, moc_*.cpp, etc.) go to build/obj, build/moc, and build/rcc to keep the source tree clean.

What I Learned

Wayland is tricky for idle detection. There's no direct equivalent of XScreenSaverQueryInfo on Wayland. The org.gnome.Mutter.IdleMonitor D-Bus API works well on GNOME/Mutter, but it's GNOME-specific. KDE Plasma has org.kde.KIdleTime, which would need a separate implementation. For now, this app targets Ubuntu with GNOME.

Frameless windows need careful event filter design. Making a draggable frameless window in Qt requires handling QEvent::MouseButtonPress and QEvent::MouseMove — either via event filters or by overriding mousePressEvent/mouseMoveEvent. I ended up doing both (event filter on child widgets + override on the dialog itself) to catch drags initiated anywhere on the card.

Clean Application Quit & Timer Cleanup. Qt singletons created with bare new and background QTimer instances won't stop automatically on exit if not handled. Connecting QCoreApplication::aboutToQuit to stopAll() in CycleController ensures all timers (m_workTimer, m_breakTimer, m_companyCheckTimer, IdleMonitor) stop cleanly and the process exits without thread leaks.

qAddPostRoutine for singleton cleanup. Adding qAddPostRoutine([]{ delete m_instance; m_instance = nullptr; }) on first creation ensures proper singleton cleanup on exit.

Building GXBackup: A Smart, Load-Aware Linux Backup Utility in C++17 and Qt 6

amekusa03 — Tue, 18 Aug 2026 23:39:56 +0000

🚀 Building GXBackup: A Smart, Load-Aware Linux Backup Utility in C++17 and Qt 6

When working on Linux desktops or development workstations, backups are essential. However, many existing GUI backup utilities suffer from common drawbacks:

They are heavy Electron wrappers that consume hundreds of megabytes of RAM.
They hog system resources during background backup tasks, causing stuttering while compiling code or rendering assets.
They lack granular control over resource usage and desktop integration.

To solve this, I created GXBackup — a fast, lightweight, native C++17 and Qt 6/Qt 5 application for Linux. It combines the bulletproof reliability of rsync with a modern UI, system tray integration, and smart CPU/load-aware auto-pausing.

Here is an overview of how GXBackup works, its key features, and some of the technical design decisions behind it.

🌟 Key Features at a Glance

📸 Time Machine Style Snapshots: Uses rsync's --link-dest option to create incremental point-in-time snapshots using hardlinks, saving significant disk space.
⚡ Smart Load Throttling: Monitors /proc/stat and /proc/loadavg in real time. If CPU usage or load average exceeds configured thresholds, GXBackup automatically pauses the backup job and resumes it once the system cools down.
⏰ Automated Scheduling & Catch-Up: Set daily or weekly backup schedules. If your machine was powered off during a scheduled run, GXBackup detects the missed run at boot and executes a "catch-up" backup automatically.
🔔 System Tray & Desktop Integration: Operates quietly in the background with minimal memory footprint and native notification support.
🌐 Dynamic Runtime i18n: Ships in English by default with dynamic runtime language switching (e.g., Japanese/English) without requiring an app restart.

🛠 Tech Stack & Architecture

Language: C++17
Framework: Qt 6 / Qt 5 (Core, Gui, Widgets, Concurrent)
Backend Engine: rsync
Build System: CMake (3.16+)

Project Structure

GXBackup/
├── CMakeLists.txt         # Build configuration
├── resources/             # Icons & embedded Qt resources (.qrc)
├── translations/          # Translation files (.ts / .qm)
└── src/
    ├── main.cpp           # Entry point & CLI argument parsing
    ├── core/              # Core logic & backend
    │   ├── AutostartManager.cpp  # XDG desktop autostart manager
    │   ├── BackupController.cpp  # Backup workflow coordinator
    │   ├── HistoryManager.cpp   # Execution history persistence
    │   ├── LanguageManager.cpp  # Dynamic i18n & QTranslator manager
    │   ├── ProfileManager.cpp   # Profile configuration (JSON)
    │   ├── RsyncProcess.cpp     # rsync process lifecycle & progress parser
    │   ├── ScheduleManager.cpp  # Cron-like timer & missed run detector
    │   └── SystemMonitor.cpp    # Real-time /proc resource reader
    └── ui/                # Qt GUI & dialogs
        ├── HistoryDialog.cpp    # History table view
        ├── LogViewer.cpp        # Console log output window
        ├── MainWindow.cpp       # Main dashboard & tray icon
        └── ProfileDialog.cpp    # Profile configuration editor

💡 Deep-Dive: What Makes GXBackup Unique?

1. Smart Resource Throttling (`SystemMonitor`)

One of the biggest pain points of background backups on developer machines is resource contention. If rsync starts indexing thousands of files while you are running cmake --build or docker build, your PC can lock up.

GXBackup addresses this by inspecting system metrics directly from /proc:

// Reading CPU & Load Average from Linux pseudo-filesystems
void SystemMonitor::checkMetrics()
{
    double cpuUsage = readCpuUsagePercent();
    double loadAvg = readLoadAverage1Min();

    emit metricsUpdated(cpuUsage, loadAvg);

    bool highLoad = (cpuUsage >= m_cpuThreshold) || (loadAvg >= m_loadAvgThreshold);
    if (highLoad != m_isHighLoadState) {
        m_isHighLoadState = highLoad;
        emit loadStateChanged(m_isHighLoadState);
    }
}

When high load is detected, BackupController intercepts the event and signals RsyncProcess to pause execution, ensuring your desktop stays responsive.

2. Native rsync Execution & Real-Time Progress Parsing

Rather than wrapping rsync blindly, GXBackup launches rsync asynchronously via QProcess and parses its output stream (--progress format) in real time to calculate:

Transfer percentage
Current transfer speed (MB/s)
Transferred data size
Estimated time remaining (ETA)

void RsyncProcess::parseProgress(const QString &line)
{
    // Regular expression parsing of rsync --progress output lines:
    // "  1,234,567  45%  12.34MB/s  0:00:15"
    static QRegularExpression re(R"(\s*([\d,]+)\s+(\d+)%\s+([\d\.]+\w+/s)\s+([\d:]+))");
    QRegularExpressionMatch match = re.match(line);

    if (match.hasMatch()) {
        int percent = match.captured(2).toInt();
        QString speed = match.captured(3);
        QString transferred = formatBytes(match.captured(1).remove(',').toULongLong());
        QString eta = match.captured(4);

        emit progressUpdated(percent, speed, transferred, eta);
    }
}

3. Dynamic i18n & Instant Language Switcher

In Qt applications, switching languages usually requires restarting the app. GXBackup uses a custom LanguageManager singleton that loads .qm binary translation files from Qt's resource system (:/translations/gxbackup_ja.qm) and broadcasts dynamic QEvent::LanguageChange events.

All UI windows override changeEvent:

void MainWindow::changeEvent(QEvent *event)
{
    if (event->type() == QEvent::LanguageChange) {
        retranslateUi();
    }
    QMainWindow::changeEvent(event);
}

This allows users to switch between English and Japanese on the fly from the Settings -> Language menu with zero restart downtime!

💻 Getting Started

Prerequisites

For Ubuntu / Debian:

sudo apt update
sudo apt install build-essential cmake qt6-base-dev rsync

Build & Run

# Clone repository
git clone https://github.com/amekusa03/GXBackup.git
cd GXBackup

# Build project
mkdir build && cd build
cmake ..
make -j$(nproc)

# Run GUI
./GXBackup

👥 Open Source & Feedback

GXBackup is open source under the MIT License.

🐙 GitHub Repository: github.com/amekusa03/GXBackup
🐞 Issues & Feature Requests: Contributions and feedback are welcome!

If you are looking for a fast, responsive backup tool for your Linux desktop or home server, give GXBackup a try!

Tags: #linux #cpp #qt #opensource

Never Forget What You Ordered: Building 'Lunch Memo' with Jetpack Compose, Room, and AlarmManager

amekusa03 — Wed, 01 Jul 2026 09:50:02 +0000

Never Forget What You Ordered: Building "Lunch Memo" with Jetpack Compose, Room, and AlarmManager

Have you ever stood in line at a cafeteria or ticket machine, thinking: "Did I order the Lunch Special A or B today?"

For many developers working at companies with pre-ordered lunch systems, this is a daily micro-friction. You reserve a lunch days in advance, only to stand in front of the cashier trying to recall what you picked.

To solve this, I built Lunch Memo—a sleek, lightweight Android application designed to keep track of daily lunch plans and send a notification right before lunch.

In this article, I’ll walk through the implementation highlights, showcasing:

Interactive UI: Creating a fluid calendar card swiping animation with Jetpack Compose HorizontalPager and graphicsLayer.
Modular Architecture: A customizable 3-component input form (Selection, Numeric, Text) backed by Room and serialized JSON.
Exact Alarms: Scheduling reliable daily notifications using AlarmManager, BroadcastReceiver.goAsync(), and Kotlin Coroutines.
Data Stewardship: Auto-cleaning database records to keep the app's footprint tiny.

🛠️ The Tech Stack

Language: Kotlin
UI: Jetpack Compose (Material 3)
Database: Room (SQLite)
Scheduling: AlarmManager + BroadcastReceiver
Asynchronous: Coroutines & Flow
Architecture: MVVM
Dependency Management: Gradle Version Catalog

🎨 1. Fluid Card Swipe Animation with Jetpack Compose

To make navigating dates feel premium, the app displays lunch memos as cards in a horizontal calendar. Swiping left or right changes the day.

Instead of a static list, I used HorizontalPager and manipulated the cards dynamically via graphicsLayer. The active card stands out, while adjacent cards are scaled down and made translucent based on their scroll offset.

Here is the implementation:

@Composable
fun LunchMemoContent(
    memos: Map<LocalDate, String>,
    settings: AppSettingsEntity?,
    onMemoChange: (LocalDate, String) -> Unit
) {
    val pageCount = 2000
    val initialPage = pageCount / 2
    val pagerState = rememberPagerState(pageCount = { pageCount }, initialPage = initialPage)
    val today = LocalDate.now()

    HorizontalPager(
        state = pagerState,
        contentPadding = PaddingValues(horizontal = 44.dp),
        pageSpacing = 16.dp,
        modifier = Modifier.fillMaxSize(),
        verticalAlignment = Alignment.CenterVertically
    ) { page ->
        val date = today.plusDays((page - initialPage).toLong())
        val isSelected = pagerState.currentPage == page

        // Calculate scroll offset fraction
        val pageOffset = (
            (pagerState.currentPage - page) + pagerState.currentPageOffsetFraction
        ).absoluteValue

        LunchMemoCard(
            date = date,
            memo = memos[date] ?: "",
            isEditable = isSelected,
            settings = settings,
            onMemoChange = { onMemoChange(date, it) },
            modifier = Modifier.graphicsLayer {
                // Scale and fade cards based on offset fraction
                val fraction = 1f - pageOffset.coerceIn(0f, 1f)
                alpha = lerp(start = 0.5f, stop = 1f, fraction = fraction)
                scaleX = lerp(start = 0.85f, stop = 1f, fraction = fraction)
                scaleY = lerp(start = 0.85f, stop = 1f, fraction = fraction)
            }
        )
    }
}

Why this works:

graphicsLayer applies changes (like scale and alpha) on the GPU level without triggering recomposition. This keeps animations running at a locked 60/120 FPS.
The lerp (linear interpolation) function smoothly maps scroll offsets to visual properties.

⚙️ 2. Dynamic 3-Component Input Form

Users need different types of memos. For example, you might want to:

Select a pre-configured lunch package (e.g., "A Lunch", "B Lunch").
Type in a table or reservation number (Numeric).
Write custom notes (Text).

To support this without over-complicating the schema, the app represents the memo as a single string composed of three space-separated parts ("Part1 Part2 Part3"). In the UI, these are rendered as three configurable components:

@Composable
fun LunchMemoCard(
    date: LocalDate,
    memo: String,
    isEditable: Boolean,
    settings: AppSettingsEntity?,
    onMemoChange: (String) -> Unit,
    modifier: Modifier = Modifier
) {
    // Parse the space-separated parts
    val parts = remember(memo) { 
        val p = memo.split(" ")
        mutableStateListOf(
            if (p.isNotEmpty()) p[0] else "",
            if (p.size > 1) p[1] else "",
            if (p.size > 2) p.subList(2, p.size).joinToString(" ") else ""
        )
    }

    fun updateMemo() {
        onMemoChange(parts.joinToString(" ").trim())
    }

    // ... Layout and Header ...
    Column(modifier = Modifier.weight(1f).fillMaxWidth()) {
        if (isEditable) {
            ComponentInput(1, config1, parts[0]) { parts[0] = it; updateMemo() }
            Spacer(modifier = Modifier.height(12.dp))
            ComponentInput(2, config2, parts[1]) { parts[1] = it; updateMemo() }
            Spacer(modifier = Modifier.height(12.dp))
            ComponentInput(3, config3, parts[2]) { parts[2] = it; updateMemo() }
        } else {
            // Display consolidated text view
        }
    }
}

Each ComponentInput displays a different UI depending on its active configuration:

SELECTION renders custom tags as a flow of FilterChips.
NUMERIC restricts input to a specified number of digits.
TEXT displays a simple text input.

@Composable
fun ComponentInput(
    index: Int,
    config: ComponentConfig,
    value: String,
    onValueChange: (String) -> Unit
) {
    Column(modifier = Modifier.fillMaxWidth()) {
        Text("Component $index", style = MaterialTheme.typography.labelSmall)

        when (config.type) {
            ComponentType.SELECTION -> {
                FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                    config.options.forEach { option ->
                        FilterChip(
                            selected = value == option,
                            onClick = { onValueChange(option) },
                            label = { Text(option) }
                        )
                    }
                }
            }
            ComponentType.NUMERIC -> {
                OutlinedTextField(
                    value = value,
                    onValueChange = { 
                        if (it.length <= config.digitLimit && it.all { it.isDigit() }) {
                            onValueChange(it)
                        }
                    },
                    keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
                    placeholder = { Text("${config.digitLimit}-digit number") }
                )
            }
            ComponentType.TEXT -> {
                OutlinedTextField(value = value, onValueChange = onValueChange)
            }
        }
    }
}

⏰ 3. Precision Local Notifications via AlarmManager & Coroutines

Using WorkManager for a daily alarm is standard practice, but WorkManager is built for deferrable background work. It operates on a sliding window and cannot guarantee execution at an exact minute (like exactly 12:00 PM).

To wake the device and post the notification at the exact minute, Lunch Memo uses AlarmManager combined with a BroadcastReceiver.

Triggering the Alarm

We calculate the delay until the user's configured notification time (adjusting to the next day if that time has already passed) and schedule the alarm using setExactAndAllowWhileIdle:

object NotificationScheduler {
    private const val REQUEST_CODE = 1001

    fun scheduleDailyNotification(context: Context, hour: Int, minute: Int) {
        val alarmManager = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
        val intent = Intent(context, NotificationReceiver::class.java).apply {
            action = "com.kusa.lunchmemo.NOTIFICATION_ALARM"
        }
        val pendingIntent = PendingIntent.getBroadcast(
            context, REQUEST_CODE, intent,
            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
        )

        val calendar = Calendar.getInstance().apply {
            set(Calendar.HOUR_OF_DAY, hour)
            set(Calendar.MINUTE, minute)
            set(Calendar.SECOND, 0)
            set(Calendar.MILLISECOND, 0)
            if (timeInMillis <= System.currentTimeMillis() + 1000) {
                add(Calendar.DATE, 1)
            }
        }

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
            if (alarmManager.canScheduleExactAlarms()) {
                alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, calendar.timeInMillis, pendingIntent)
            } else {
                alarmManager.setAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, calendar.timeInMillis, pendingIntent)
            }
        } else {
            alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, calendar.timeInMillis, pendingIntent)
        }
    }
}

Performing Async Tasks in a BroadcastReceiver with `goAsync()`

Typically, a BroadcastReceiver lifecycle is extremely short; performing operations like database queries inside onReceive can cause an Application Not Responding (ANR) error.

However, by calling goAsync(), we can safely launch a Coroutine Scope to fetch today's memo asynchronously on a dispatcher thread and keep the receiver alive until our database lookup completes:

class NotificationReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        val action = intent.action
        if (action == Intent.ACTION_BOOT_COMPLETED || action == "com.kusa.lunchmemo.NOTIFICATION_ALARM") {
            // Keep BroadcastReceiver active during asynchronous execution
            val pendingResult = goAsync()

            CoroutineScope(Dispatchers.IO).launch {
                try {
                    val database = LunchMemoDatabase.getDatabase(context)
                    val dao = database.lunchMemoDao()
                    val settings = dao.getSettings().first()
                    val hour = settings?.notificationHour ?: 12
                    val minute = settings?.notificationMinute ?: 0

                    // Reschedule for tomorrow
                    NotificationScheduler.scheduleDailyNotification(context, hour, minute)

                    // Show notification if it's the alarm action
                    if (action == "com.kusa.lunchmemo.NOTIFICATION_ALARM") {
                        val today = LocalDate.now().format(DateTimeFormatter.ISO_LOCAL_DATE)
                        val memos = dao.getAllMemos().first()
                        val todayMemo = memos.find { it.date == today }?.memo
                        if (!todayMemo.isNullOrBlank()) {
                            showNotification(context, todayMemo)
                        }
                    }
                } finally {
                    // Inform the OS we're done
                    pendingResult.finish()
                }
            }
        }
    }
}

🧹 4. Lightweight Storage & Auto-Cleanup

A good utility app shouldn't hoard local storage. Since past lunch memos are no longer relevant, Lunch Memo cleans them up automatically.

In the LunchMemoDao, I defined a simple query to delete memos older than a specified date:

@Query("DELETE FROM lunch_memos WHERE date < :date")
suspend fun deleteMemosOlderThan(date: String)

Inside the LunchMemoViewModel, this is invoked asynchronously on app launch:

fun cleanOldMemos() {
    viewModelScope.launch {
        val yesterday = LocalDate.now().minusDays(1).format(formatter)
        dao.deleteMemosOlderThan(yesterday)
    }
}

This keeps the local SQLite database extremely compact, containing only upcoming and today's memos.

🔄 5. Room Database Migrations

As the app grew, its schema evolved to accommodate customization settings. Handling migrations seamlessly is crucial so users do not lose their data.

Here is the migration trajectory of the app's database from Version 1 to 4:

v1: Basic daily notes.
v1 -> v2: Introduced app_settings for customized notification times.
v2 -> v3: Added alphanumericOnly setting.
v3 -> v4: Introduced serialization via GSON to store JSON strings representing custom layouts for the 3 input components.

private val MIGRATION_3_4 = object : Migration(3, 4) {
    override fun migrate(database: SupportSQLiteDatabase) {
        database.execSQL("ALTER TABLE `app_settings` ADD COLUMN `component1ConfigJson` TEXT NOT NULL DEFAULT ''")
        database.execSQL("ALTER TABLE `app_settings` ADD COLUMN `component2ConfigJson` TEXT NOT NULL DEFAULT ''")
        database.execSQL("ALTER TABLE `app_settings` ADD COLUMN `component3ConfigJson` TEXT NOT NULL DEFAULT ''")

        // Define default settings layouts
        val defaultConfig1 = ComponentConfig(ComponentType.SELECTION, listOf("A Lunch", "B Lunch", "C Lunch")).serialize()
        val defaultConfig2 = ComponentConfig(ComponentType.NUMERIC, digitLimit = 2).serialize()
        val defaultConfig3 = ComponentConfig(ComponentType.TEXT).serialize()

        database.execSQL("UPDATE `app_settings` SET `component1ConfigJson` = '$defaultConfig1'")
        database.execSQL("UPDATE `app_settings` SET `component2ConfigJson` = '$defaultConfig2'")
        database.execSQL("UPDATE `app_settings` SET `component3ConfigJson` = '$defaultConfig3'")
    }
}

By adding these migration blocks to Room.databaseBuilder(...).addMigrations(...), updates are seamless and never crash the app for existing users.

🏆 Key Lessons Learned

Unidirectional Data Flow: Implementing the Room (Flow) ➔ ViewModel (StateFlow) ➔ Jetpack Compose state cycle made state updates incredibly clean and bug-free.
Choosing the Right Notification Tool: Using WorkManager is great for background syncing or analytics, but AlarmManager is the correct engineering choice when notifications must arrive at a precise local time.
Lightweight Serialized Configurations: Storing custom configurations inside the database as serialized JSON allowed adding flexible setting patterns without having to constantly spin up new Room tables.

📝 Conclusion

Building Lunch Memo was a fun project that solved a real everyday problem. It demonstrates how standard modern Android practices like Jetpack Compose, Room, and AlarmManager can create a tool that is clean, responsive, and incredibly useful.

If you struggle with remembering your cafeteria bookings, try building your own customized version!

Thanks for reading, and happy coding! 🍱

amekusa03 / androidLunchMemo

ランチ予定をシンプルに管理する Android アプリ

Lunch Memo 🍱

Lunch Memo は、日々のランチの予定や記録をシンプルかつスタイリッシュに管理できる Android アプリです。モダンな Material 3 デザインを採用し、スムーズな操作感でランチタイムを楽しく彩ります。

主な機能 🌟

スマートな記録: カレンダー形式のカードをスワイプして、ランチの内容を素早くメモ。
お昼の通知: 毎日12:00に、その日のランチメモを通知。今日何食べるんだっけ？を解消します。
モダンなデザイン:
- Material 3 フル対応。
- スムーズなカードアニメーションとグラデーション背景。
- Android 13 以上の通知権限に完全対応。
クリーンなデータ保持: 過去のメモは自動的に整理され、アプリを常に軽量に保ちます。

技術スタック 🛠️

Language: Kotlin
UI: Jetpack Compose (Material 3)
Database: Room (SQLite)
Background Tasks: WorkManager
Asynchronous: Coroutines & Flow
Architecture: MVVM
Dependency Management: Gradle Version Catalog (libs.versions.toml)
Annotation Processing: KSP (Kotlin Symbol Processing)

セットアップ 🚀

Android Studio (Ladybug 以降推奨) でプロジェクトを開きます。
プロジェクトを Gradle Sync します。
Android デバイスまたはエミュレータで実行します。

更新履歴 📅

[Lunch Memo 2.0] - 2026.07.01

選択式入力の導入: 自由入力に加え、あらかじめ登録したアイテムをタップして選択できる機能を追加。
3コンポーネント構成: メモを「選択」「数字」「文字」の3つの要素に分割。用途に合わせて自由にカスタマイズ可能に。
設定画面の強化: コンポーネントごとの入力モード切替や選択肢の編集機能を実装。
内部改善: データベースのマイグレーション(v4)と、設定保存のためのシリアライズ処理(GSON)を導入。

ライセンス 📝

このプロジェクトは MIT ライセンスの下で公開されています。

View on GitHub

Rescuing 216 Pages from the GeoCities Era: How I Built an HTML-to-Blogger Tool

amekusa03 — Fri, 03 Apr 2026 15:23:57 +0000

This is a submission for the 2026 WeCoded Challenge: Echoes of Experience

I want to transfer the HTML format to Google Blogger.

Introduction

The outdoor club's website (which was called a homepage back then) was archived when GeoCities shut down. The last update was in April 2014.
If it had become completely inaccessible, I could have accepted it, but it's just too sad that it's become an archive.

Okay, I'll do this!
I declared to the old site administrator (a friend) "It's okay, let me do it."
For now, I'll just go with Vercel's Hobby for the new site.
Then I checked the old site's HTML
. What? 216 pages.
Doing this by hand is impossible!
The old site was beautifully made by my friend while he was learning HTML.
I tried cleaning it with AI, but my instructions were bad and it just didn't work.
With the help of another friend, I aimed to create a stylish new site using React and other things in VS Code.
While doing all that, Windows started to become unstable and eventually crashed.
The data was still there, so I reinstalled Windows and DevStudio. I lost the product ID. It 's completely over .
So I installed Ubuntu, installed VS Code, and decided to develop with Python. (I've never used it before)
While the installation was in progress, I also changed the new site's operational policy.

Members can post
You can also upload videos. With two additional requirements, the site has also been changed to Google Blogger ♫

Getting Started with Python

I started with 'Hello python' and created a CLI for tag cleaning of HTML files.
Next, I tried posting to Blogger using the API, and I'm starting to get the hang of it.

Software Requirements Definition

Ruthless decision

HTML history management
Cleaning HTML
- I want to manage the design entirely in Blogger, so I'm removing font and color settings.
Keyword extraction and registration
- Blogger allows you to set keywords for each post, so I want to use words that match the text in the HTML as keywords (e.g., kayaking, Bouldering).
Location extraction and registration
- This is also a feature that can be added to each Blogger post (Akihabara, Mt. Fuji, etc.).
Remove Exif data from images and add watermarks.
Upload articles and images
GUI

implementation

Just as you all expected, I'm totally hooked.
I was struggling to get used to Ubuntu's IME, so I installed Fcitx5 and managed to work around the problem.
I discovered that the Blogger API doesn't have image-related features → I established and standardized a somewhat easier manual + automatic linking procedure for images.
I couldn't get used to Python nesting → I ended up checking the nesting with my finger.
Library version issue occurred → Misunderstood Python virtual environment (venv) → Fumbled around trying to create an environment with virtualBox → Realized it was in the terminal and almost went blank.
I accidentally sent about 200 Blogger API requests without using a timer → I received an account lock warning email → I sent an apology email to Google and my account was restored the next day.
I installed Wine and Excel (MS-Office) to aggregate regional data → got stuck in cell input mode and switched to LibreOffice → discovered nominatim geocoding and solved the problem.
Trying to run a virtual Windows using insurance → Too slow. Insufficient HDD space. Ultimately, the license is too expensive, so I gave up.
I asked the AI to do various things, but it didn't understand the language specifications and approved them haphazardly → I ended up having to rewrite almost everything.
To create a GUI with Tkinter, you write the code → The base is written by AI, and then you just stare at the source code.
Tracing Python arguments → Why isn't copy running? → Wait, even queue instances are referenced when you put them?! And so on, intense debugging.
I can't do it well, so I end up pressing the keys too hard → My family tells me it's too loud, and I almost cry.

Reaffirming established theories

When it comes to technology, you either invest time, money, or wisdom.
For me, someone who lacks wisdom, it seems it was time.
However, I think I gained a lot.
You can't know the taste of pudding until you try it.
Ubuntu is wonderful. I dabbled in it a little for work, but I didn't know about the community at that time. Ultimately, what's important is human connection.

I would appreciate your help with debugging.

I've tried to code it so that it should work on Windows and Mac as long as you're using a Python environment.
It requires Google API authentication credentials, which is a bit of a hassle, but I'd appreciate it if you could debug it.
Even just a review would be encouraging.
Please feel free to point out any issues with the Python coding!

Introduction:

Notes Archive | Raingrass Garden

Rainweed Garden — Full article archive. Technical essays, daily memos, cars, etc.

amekusa.vercel.app

Video:

code:

amekusa03 / html-blogger

Supports conversion and upload from HTML to Google Blogger

HTML to Blogger Ver0.98

A desktop application that automatically processes local HTML files and images and posts them to Blogger.
It performs HTML cleaning, adds watermarks to images, assigns keywords and location information, and uploads to Blogger.

Qiita Article

Explanation article for this tool (Qiita)

Introduction Video

Main Features

HTML Cleaning: Removes unnecessary tags and normalizes formatting for posts.
Image Processing: Removes EXIF data and adds watermarks.
Metadata Assignment: Automatically adds keywords (search tags) and location information (georss tags) by analyzing the article content.
Blogger Upload: Uploads image links and articles as drafts using the Blogger API.
GUI Operation: User-friendly GUI with progress visualization and error recovery features.

Processing Flow

Processing is executed in the following order:

import_file.py: Imports files from the source folder to the working folder.
serial_file.py: Converts file names into sequential numbering format.
clean_html.py: Cleans up HTML…

View on GitHub

DEV Community: amekusa03

Building a 5.1ch Surround Upmixer GUI with Python & FFmpeg

Building a 5.1ch Surround Upmixer GUI with Python & FFmpeg

What it does

How the upmix works

Code highlights

Thread-safe UI updates with a queue

Fixing Python's late-binding closure trap

Clean preset system with dataclasses

Quick start

What I learned

Building FocusCycle: A Non-Intrusive Qt5/C++ Pomodoro Timer for Linux

What FocusCycle Does Differently

1. 🖱 Smart Idle Detection (Wayland & X11)

2. 🔕 Zero-Distraction UI & System Color Palette

3. 🏢 Scheduled Company Breaks

4. 🎯 The State Machine

5. 📊 CSV Session Logging & Quick Task Dropdown

6. 🌐 English / Japanese UI

Architecture Overview

Building It

What I Learned

Links

Building GXBackup: A Smart, Load-Aware Linux Backup Utility in C++17 and Qt 6

🚀 Building GXBackup: A Smart, Load-Aware Linux Backup Utility in C++17 and Qt 6

🌟 Key Features at a Glance

🛠 Tech Stack & Architecture

Project Structure

💡 Deep-Dive: What Makes GXBackup Unique?

1. Smart Resource Throttling (SystemMonitor)

2. Native rsync Execution & Real-Time Progress Parsing

3. Dynamic i18n & Instant Language Switcher

💻 Getting Started

Prerequisites

Build & Run

👥 Open Source & Feedback

Never Forget What You Ordered: Building 'Lunch Memo' with Jetpack Compose, Room, and AlarmManager

Never Forget What You Ordered: Building "Lunch Memo" with Jetpack Compose, Room, and AlarmManager

🛠️ The Tech Stack

🎨 1. Fluid Card Swipe Animation with Jetpack Compose

Why this works:

⚙️ 2. Dynamic 3-Component Input Form

⏰ 3. Precision Local Notifications via AlarmManager & Coroutines

Triggering the Alarm

Performing Async Tasks in a BroadcastReceiver with goAsync()

🧹 4. Lightweight Storage & Auto-Cleanup

🔄 5. Room Database Migrations

🏆 Key Lessons Learned

📝 Conclusion

amekusa03 / androidLunchMemo

ランチ予定をシンプルに管理する Android アプリ

Lunch Memo 🍱

主な機能 🌟

技術スタック 🛠️

セットアップ 🚀

更新履歴 📅

[Lunch Memo 2.0] - 2026.07.01

ライセンス 📝

Rescuing 216 Pages from the GeoCities Era: How I Built an HTML-to-Blogger Tool

I want to transfer the HTML format to Google Blogger.

Introduction

Getting Started with Python

Software Requirements Definition

implementation

Reaffirming established theories

I would appreciate your help with debugging.

Notes Archive | Raingrass Garden

amekusa03 / html-blogger

Supports conversion and upload from HTML to Google Blogger

HTML to Blogger Ver0.98

Qiita Article

Introduction Video

Main Features

Processing Flow

1. Smart Resource Throttling (`SystemMonitor`)

Performing Async Tasks in a BroadcastReceiver with `goAsync()`