Persistent Load Workflow

Heads up... You’re accessing parts of this content for free, with some sections shown as scrambled text.

Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now

Heads up... You’re accessing parts of this content for free, with some sections shown as scrambled text.

Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now

In this segment, you’ll implement file-based persistence using JSON serialization. By the end, your task manager will load tasks from disk automatically on startup, proving that data survives app restarts. You’ll learn:

  • How Swift’s Codable protocol enables automatic JSON serialization
  • File I/O with FileManager across iOS and Android platforms
  • The Result type pattern for explicit, type-safe error handling
  • StateFlow synchronization between Swift and Kotlin

You’ll get started by understanding how JSON serialization works.

Understanding JSON Serialization with Codable

Before you can save tasks to disk, you need a way to convert Swift objects into a format that can be written to a file. That format is JSON (JavaScript Object Notation), a human-readable text format that’s widely supported across programming languages and platforms.

What is Codable?

Codable is actually a combination of two protocols:

Task Model Review

Your Task struct is already set up for JSON serialization. Open Task.swift and you’ll see:

How Encoding and Decoding Work

To convert objects to JSON, you use JSONEncoder:

Creating TaskStorage for Load Operations

The TaskStorage class is responsible for all file I/O operations. It handles reading tasks from disk, writing tasks to disk, and managing the file path across iOS and Android platforms.

Creating the StorageError Enum

First, you’ll define custom error types that describe what went wrong during file operations.

Creating the TaskStorage Class

Next, you’ll create the class structure and set up the file path.

Implementing the loadTasks() Method

Now for the core functionality: reading tasks from disk.

Using the Result Type Pattern

Notice the return type: Result<[Task], StorageError>. This is Swift’s built-in Result type, which represents either success or failure:

Integrating TaskStorage into TaskManager

Now that TaskStorage can load tasks from disk, you need to wire it up to TaskManager so tasks are loaded automatically when the app starts.

Adding the Storage Property

Open taskmanager-lib/Sources/TaskManagerKit/TaskManager.swift. Find the class declaration and add the storage property:

Loading Tasks on Initialization

Find the private init() method and modify it to load tasks:

Adding getAllTasksJSON() to TaskManager

For Kotlin to access the loaded tasks, you need to add a method that returns tasks as a JSON string. This method will be automatically exposed to Kotlin through swift-java.

Kotlin Repository Integration

The Swift side now loads tasks from disk, but your Kotlin app doesn’t know about them yet. In this section, you’ll connect the Kotlin TaskRepository to Swift’s TaskManager so tasks flow from the JSON file → Swift → Kotlin → UI.

Understanding the Architecture

Before diving into code, let’s clarify the data flow:

Implementing loadTasks() in Kotlin

Open app/src/main/java/com/kodeco/android/swiftsdkforandroid/taskmanager/repository/TaskRepository.kt. Add this method inside the TaskRepository object:

Adding the Init Block

Now you need to call loadTasks() automatically when the repository is initialized.

Verifying the Persistence Layer

Now that you’ve got the code wired up, you’ll go through and see it in action!

Yofubz Pejcacvorpo Limaj
Pebedy Pusmalzomwa Loxeb

Key Takeaways

You’ve built a robust persistence layer that loads tasks from disk automatically. Here’s what you learned:
See forum comments
Download course materials from Github
Previous: Introduction Next: CRUD Operations & Validation