App Lifecycle and Background Tasks

You've just polished the perfect screen, and your app performs flawlessly — until the user switches to another app, locks the screen, or a call interrupts. Suddenly the UI freezes, your background work stalls mid-download, and the OS kills your process. This is the brutal reality of mobile development: your app does not control when it runs — the OS does. Understanding and mastering the app lifecycle and background tasks is not optional; it's the difference between an app that feels professional and one that crumbles under real-world interruptions. In this lesson, you'll learn how to handle app lifecycle and background tasks in Python mobile development, using frameworks like Kivy and BeeWare, to build robust, user-respecting apps.

The problem this lesson solves

Mobile operating systems — Android and iOS — manage apps with a strict lifecycle. An app isn't just "running" or "closed"; it transitions through states like active, paused, stopped, and killed. These state changes happen constantly: the user receives a text, swipes to the home screen, or simply turns off the screen for a moment.

If you ignore the lifecycle, you'll face a cascade of issues:

• Lost user data: A user is typing a form, the phone locks, and the OS reclaims memory — all input lost.
• Battery drain: Your app keeps running a network loop in the background, silently draining the battery and making users uninstall.
• Crashes on resume: When the app returns to the foreground, it might try to resume work that was never paused, causing a NoneType error.
• Failed background operations: A file upload starts, the app is backgrounded, and the OS suspends it — the upload never finishes.

The core problem is that background work doesn't run just because your code asks for it. The OS has its own rules, and if you don't play by them, your app will appear unresponsive, unreliable, or power-hungry.

Core concept / mental model

Think of your app's lifecycle as a conversation between your app and the operating system. The OS is a polite but firm host: it tells you, "You're about to be hidden," "You're in the background now," "You're being killed." Your app's job is to listen and react appropriately.

Imagine you're a chef in a busy kitchen. When the host (OS) tells you the lunch rush is over and the dining room is empty, you wouldn't keep boiling pots on the stove. You'd pause long tasks, save your prep, and keep only critical things ready. That's the essence of lifecycle handling: you don't control when you're open, but you can control how gracefully you respond.

In Python mobile development, frameworks like Kivy and BeeWare abstract but mirror these platform concepts:

• Foreground: Your app is visible and interacting with the user.
• Paused/Background: The app is no longer visible but its process is still alive.
• Stopped/Suspended: The app is in memory but not executing code.
• Terminated: The process is killed, and you need to restore state from saved data.

Background tasks are pieces of work that need to run even when the app is not visible — like syncing data, downloading a file, or sending a notification. The OS limits these to prevent abuse; you must use platform-specific facilities like Android's JobScheduler or WorkManager (via Buildozer or Kiwi) or iOS's background fetch, or simply respect the suspension window.

Pro tip: Always assume your app can be killed at any moment. Save state on every pause, not just on exit.

How it works step by step

Let's examine a typical lifecycle flow and see what your app should do at each step.

1. Your app launches

• The OS creates your app's process and loads the main window.
• In Kivy, you call App.run() which starts the event loop.
• You'll want to initialize resources, load saved state, and set up UI.

2. The app becomes active

• It's in the foreground, receiving user input.
• You might start network streams or animations here.

3. The user presses Home or switches apps

• The OS calls the pause event.
• In Kivy, you can bind to the on_pause event.
• You should: save in-memory state, stop heavy animations, and release exclusive resources like camera.
• If your app doesn't handle on_pause and return True, on Android the app may be killed.

4. The app stays in background

• It may be fully suspended — code stops executing.
• Background tasks should be handed off to the OS (like a job scheduler) or queued.

5. The user returns

• The resume event fires.
• You re-load state, restart UI, and refresh data.

6. The app is killed

• If the OS reclaims memory, no callback runs. You must have saved everything earlier.

For background tasks specifically, you have a few options:

• Miniature background work during a short pause: just run a fast thread and hope it finishes before suspension (not reliable).
• System-managed tasks: schedule them with the OS to run when conditions allow (e.g., network available, device charging).
• Push notifications: the OS wakes your app to show a message.

Hands-on walkthrough

Let's implement a practical example with Kivy, the most popular Python mobile GUI framework.

Example 1: Handling the lifecycle events in Kivy

Create a main.py that logs lifecycle events and saves state.

from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.label import Label
from kivy.storage.jsonstore import JsonStore

store = JsonStore('state.json')

class LifecycleApp(App):
    def build(self):
        self.state = store.get('app', default={'count': 0})
        self.layout = BoxLayout(orientation='vertical')
        self.label = Label(text=f"Count: {self.state['count']}")
        self.layout.add_widget(self.label)
        return self.layout

    def on_start(self):
        print("App started")

    def on_pause(self):
        print("App paused - saving state")
        # Save critical state
        self.state['count'] += 1
        store.put('app', **self.state)
        # Return True to indicate we can be resumed
        return True

    def on_resume(self):
        print("App resumed")
        self.state = store.get('app')
        self.label.text = f"Count: {self.state['count']}"

    def on_stop(self):
        print("App stopped")
        store.put('app', **self.state)

if __name__ == '__main__':
    LifecycleApp().run()

When you run this on Android (via Buildozer) and press Home, you'll see logs on on_pause, and when returning, the count increments.

Example 2: A simple background task using a thread

Background work can be started when you need it, but you must avoid blocking the main thread. Here's a pattern for a short background download using a thread and signaling completion via a Clock callback.

import threading
from kivy.app import App
from kivy.uix.button import Button
from kivy.clock import Clock
from kivy.utils import platform

class BackgroundApp(App):
    def build(self):
        self.status = Button(text="Start Background Work")
        self.status.bind(on_press=self.start_background)
        return self.status

    def start_background(self, instance):
        self.status.text = "Working..."
        # Start a thread for non-UI work
        t = threading.Thread(target=self.heavy_work)
        t.daemon = True
        t.start()

    def heavy_work(self):
        # Simulate a long operation
        import time
        time.sleep(2)
        # Schedule UI update on main thread
        Clock.schedule_once(self.update_ui, 0)

    def update_ui(self, dt):
        self.status.text = "Done!"

if __name__ == '__main__':
    BackgroundApp().run()

Important: Never touch UI widgets from a background thread — always use Clock.schedule_once to update the UI on the main thread.

Example 3: Saving state and restoring after kill

This snippet shows how to save data not just on pause but also periodically, to survive a forced kill.

import json

class UserProgress:
    def __init__(self, filename):
        self.filename = filename
        self.data = self.load()

    def load(self):
        try:
            with open(self.filename, 'r') as f:
                return json.load(f)
        except FileNotFoundError:
            return {'score': 0}

    def save(self):
        with open(self.filename, 'w') as f:
            json.dump(self.data, f)

# In your app's on_pause:
# progress.save()

The key is to call save() on every pause and also after every significant change.

Compare options / when to choose what

When handling background tasks, you have several approaches. Choose based on your needs:

For most Python mobile apps, you'll use threads for short tasks and save state on lifecycle events. For serious background work, you'll need to wrap platform APIs — but that's advanced.

Troubleshooting & edge cases

1. App is killed even though you handled on_pause

• Cause: On Android, if on_pause doesn't return True, the app is considered OK to kill.
• Fix: Always return True from on_pause to allow resume. Also save state immediately.

2. Background thread causes crash when app resumes

• Cause: UI updated from a background thread.
• Fix: Use Clock.schedule_once to update UI on main thread.

3. File writing during pause fails

• Cause: OS might kill the process before on_stop is called, or file system is slow.
• Fix: Write frequently and atomically (write temp file, then rename).

4. on_pause blocks too long

• Cause: You're saving a huge state synchronously.
• Fix: Save incremental data or use a fast format like SQLite.

5. Background tasks don't run after a while

• Cause: OS restricts background execution to save battery.
• Fix: Use platform schedulers (JobScheduler) or respect that your task might run later.

What you learned & what's next

You now understand the app lifecycle and background tasks in mobile development. You can:

• Explain the core idea behind lifecycle events (on_pause, on_resume, etc.)
• Apply lifecycle patterns to save state and avoid data loss
• Run simple background tasks with threads and UI-safe updates
• Troubleshoot common issues like crashes on resume and battery drain

This critical skill sets the stage for the next lesson in the track, where you'll dive deeper into persistent storage and data security — you'll learn to use SQLite and encrypted storage to make your app's data survive even the most aggressive OS memory reclaim.

Keep building!

Practical exercise

Mini project: Modify the LifecycleApp example to include a user input field (a TextInput). Save the text to a JSON file on on_pause. On resume, restore the text into the field. Test by running the app, typing, pressing Home, and reopening. This will solidify your understanding of state persistence across lifecycle changes.