Repository pattern with SqlBrite/SqlDelight(Offline database) and Retrofit(Http request)

Repository Pattern: A Foundation for Data Access

What is the Repository Pattern?

The repository pattern acts as an intermediary between your application logic and data access. It provides a consistent interface for retrieving, persisting, and managing data, regardless of the underlying data source (database, network, etc.).

Benefits of using Repository Pattern:

• Decoupling: Separates data access logic from business logic, making the codebase cleaner and easier to maintain.
• Testability: Allows for easy testing of data access code by mocking the repository interface.
• Data Source Abstraction: Provides a uniform way to interact with various data sources (database, API, etc.)
• Centralized Logic: All data access logic is encapsulated within the repository, ensuring consistency.

Implementing Offline Database with SqlBrite/SqlDelight

Choosing the Right Library: SqlBrite vs SqlDelight

SqlBrite (Reactive Database Access)

SqlBrite is a library that wraps SQLiteOpenHelper and provides reactive observables for database operations. It offers:

• Reactive data access: Allows for seamless integration with RxJava/Kotlin Coroutines.
• Simple API: Provides easy-to-use methods for database interactions.

// Code Example (SqlBrite)
import com.squareup.sqlbrite2.BriteDatabase
import com.squareup.sqlbrite2.SqlBrite
import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
import io.reactivex.rxjava3.core.Flowable
import io.reactivex.rxjava3.disposables.CompositeDisposable
import io.reactivex.rxjava3.schedulers.Schedulers

// Database helper class
class DatabaseHelper(context: Context) {
    private val db: BriteDatabase
    private val disposables = CompositeDisposable()

    init {
        val sqlBrite = SqlBrite.Builder().build()
        db = sqlBrite.wrapDatabaseHelper(SQLiteOpenHelper.getInstance(context))
    }

    fun getAllUsers(): Flowable> {
        return db.createQuery("users", "SELECT * FROM users")
            .mapToList { cursor ->
                User(cursor.getLong(0), cursor.getString(1))
            }
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
    }

    // Other database operations...

    fun dispose() {
        disposables.dispose()
    }
}

SqlDelight (Type-Safe Database Access)

SqlDelight offers:

• Type safety: Eliminates the need for manual SQL strings and reduces errors.
• Code generation: Generates Kotlin interfaces and types for your database schema.

// Code Example (SqlDelight)
// Database schema (users.sq)
CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    name TEXT
);

// Generated code (Users.kt)
interface Users {
    fun selectAll(): Flowable>
}

// Using generated interface
val db: Users = ...
db.selectAll().subscribe { users ->
    // Do something with users
}

Retrofit for Network Requests

Retrofit: Simplifying HTTP Communication

Retrofit is a powerful REST client library for Android that makes working with APIs a breeze. It provides:

• Type safety: Enforces type-safe API interactions with interfaces and annotations.
• JSON parsing: Automatically serializes and deserializes data using Gson or other converters.
• Request and response handling: Makes it easy to handle different request methods, headers, and errors.

// Code Example (Retrofit)
interface ApiService {
    @GET("users")
    fun getUsers(): Call>
}

// Create Retrofit instance
val retrofit = Retrofit.Builder()
    .baseUrl("https://api.example.com/")
    .addConverterFactory(GsonConverterFactory.create())
    .build()

// Create API service interface
val apiService = retrofit.create(ApiService::class.java)

// Make network request
apiService.getUsers().enqueue(object : Callback> {
    override fun onResponse(call: Call>, response: Response>) {
        if (response.isSuccessful) {
            val users = response.body()
            // Handle response
        }
    }

    override fun onFailure(call: Call>, t: Throwable) {
        // Handle error
    }
})

Combining Repository Pattern with SqlBrite/SqlDelight and Retrofit

Repository Interface

interface UserRepository {
    fun getUsers(): Flowable>
    fun saveUser(user: User): Completable
}

Repository Implementation

class UserRepositoryImpl(
    private val db: Users, // SqlDelight database
    private val apiService: ApiService // Retrofit service
) : UserRepository {
    override fun getUsers(): Flowable> {
        return db.selectAll()
            .switchMap { cachedUsers ->
                // Check if cache is fresh enough
                if (shouldRefreshCache()) {
                    apiService.getUsers()
                        .flatMap { apiUsers ->
                            // Save new data to cache
                            db.transaction {
                                db.insertOrReplace(apiUsers) // SqlDelight transaction
                            }
                            Flowable.just(apiUsers)
                        }
                } else {
                    Flowable.just(cachedUsers)
                }
            }
    }

    override fun saveUser(user: User): Completable {
        return Completable.fromAction {
            db.insertOrReplace(user)
        }
    }
}

Conclusion

By combining the power of the Repository Pattern, offline database libraries like SqlBrite/SqlDelight, and a network library like Retrofit, you can build robust, maintainable, and highly performant Android applications with seamless offline capabilities. This approach allows for efficient data management, easy testing, and a clean separation of concerns in your application architecture.