Explore

GSON in Android

No, **GSON is not a wrapper around SQLite**.

GSON and SQLite serve very different purposes in Android development, and they operate independently of each other.

### Key Differences:

- **GSON**: - **Purpose**: GSON is a **JSON (de)serialization library**. It’s used for converting Kotlin or Java objects to JSON (serialization) and converting JSON back to objects (deserialization). This is especially useful when interacting with **web APIs** where data is often transferred in JSON format.

- **Use Case**: GSON is ideal for handling data exchanged between an Android app and an external API, particularly in **network operations** where JSON is the standard data format.

- **Storage**: GSON **does not provide any data storage** capabilities. It only helps with converting data to/from JSON strings, and you typically store those strings or objects elsewhere (e.g., in memory, shared preferences, or a database like SQLite).

- **SQLite**: - **Purpose**: SQLite is a **relational database engine** built into Android. It is used for storing structured data locally on the device in the form of tables (rows and columns). - **Use Case**: SQLite is ideal for long-term **data storage** on the device, such as saving user preferences, caching large datasets, or maintaining complex relationships between different data entities. - **Storage**: It stores data in a **structured, tabular format** and allows you to perform SQL queries to retrieve or manipulate the stored data.

How They Work Together: GSON and SQLite are complementary but not directly related. You might use **GSON** to convert objects into JSON for sending over the network, while you use **SQLite** (or its abstraction, **Room**) to store data locally on the device in a structured format.

For example, you could: 1. Fetch data from an API using GSON to parse the JSON response. 2. Store the parsed data in a local SQLite database for offline use or caching.

But **GSON itself has no direct connection to SQLite**. It doesn’t wrap or interact with SQLite in any way—it only focuses on working with JSON. SQLite, on the other hand, focuses on managing structured data in a relational database.

Introduction to GSON in Kotlin and Comparison with Room Persistence

⁠

Objective:

In this lecture, we’ll explore how to use GSON for JSON serialization and deserialization in Kotlin and compare it to the Room Persistence library, which is commonly used for local data storage.

By the end of this lecture, students will understand:

What GSON is and how it works in Kotlin.

The difference between GSON and Room in terms of use cases, structure, and data management.

⁠

1. What is GSON?

GSON is a Java library developed by Google for converting Java (and Kotlin) objects into JSON (serialization) and vice versa (deserialization). JSON is the most common format for data exchange in REST APIs.

Serialization: Convert Kotlin objects into JSON strings.

Deserialization: Convert JSON strings into Kotlin objects.

Why GSON in Kotlin?

Easy to use: Integrates seamlessly with Kotlin.

Lightweight: Simple dependency, no complex setup.

API-friendly: Ideal for sending and receiving JSON data from web services.

Kotlin compatibility: GSON works perfectly with Kotlin data classes.

Setup for GSON in Kotlin:

In your build.gradle (app-level), add the following dependency:

implementation 'com.google.code.gson:gson:2.8.9'

Basic GSON Example:

Let’s say you have a simple Kotlin data class:

data class User(val name: String, val age: Int, val email: String)

Serialization:

val user = User("Alice", 25, "alice@example.com")

val gson = Gson()

val json = gson.toJson(user) // Convert User object to JSON string

println(json) // Output: {"name":"Alice","age":25,"email":"alice@example.com"}

Deserialization:

val jsonString = """{"name":"Bob","age":30,"email":"bob@example.com"}"""

val userObj = gson.fromJson(jsonString, User::class.java) // Convert JSON string back to User object

println(userObj) // Output: User(name=Bob, age=30, email=bob@example.com)

⁠

2. What is Room Persistence Library?

Room is an abstraction layer over SQLite for local data persistence in Android. It allows you to manage local databases with ease, offering features like compile-time verification of SQL queries, strong type safety, and a simplified API for working with databases.

Why Room in Kotlin?

Local Data Storage: Ideal for storing large datasets or data that needs to persist across app sessions (e.g., user preferences, cached data).

Relational Databases: Supports complex queries, relationships, and structured data.

ORM (Object-Relational Mapping): It lets you directly map Kotlin data classes to database tables.

Setup for Room in Kotlin:

Add these dependencies to your build.gradle:

implementation "androidx.room:room-runtime:2.4.2"

kapt "androidx.room:room-compiler:2.4.2"

Basic Room Example:

Let’s say we need to store a list of User objects in the database.

Entity (Table):

@Entity

data class User(

@PrimaryKey(autoGenerate = true) val id: Int,

val name: String,

val age: Int,

val email: String

)

DAO (Data Access Object):

@Dao

interface UserDao {

@Insert

suspend fun insertUser(user: User)

@Query("SELECT * FROM User WHERE id = :userId")

suspend fun getUser(userId: Int): User

}

Database:

@Database(entities = [User::class], version = 1)

abstract class AppDatabase : RoomDatabase() {

abstract fun userDao(): UserDao

}

With Room, data persists locally, even when the app is closed, and can be queried with SQL-like queries.

⁠

3. Comparison: GSON vs Room Persistence

Now that we understand what GSON and Room are used for, let’s compare the two in terms of functionality and use cases:

⁠

4. When to Use GSON vs Room

GSON:

Use GSON when you’re dealing with data exchange over the network. It’s perfect for serializing/deserializing JSON responses from APIs. For example, when retrieving user data or product details from a web server, GSON is your go-to tool.

Room:

Use Room when you need to store data locally on the device. It’s the better option for persisting data across sessions, handling large datasets, and managing complex data structures like relationships between different entities.

⁠

5. Hybrid Use Case: Combining GSON and Room

In real-world applications, it’s common to use both GSON and Room together. For instance:

GSON: Fetch data from a REST API (e.g., a list of users).

Room: Cache this data locally for offline access, using Room to store the objects you retrieve.

Example Workflow:

API Call: Use GSON to parse the JSON response from the API.

kotlin

Copy code

val userList = gson.fromJson(apiResponse, Array<User>::class.java).toList()

Cache with Room: Store the fetched data in the local Room database for offline access.

kotlin

Copy code

userDao.insertUsers(userList)

⁠

6. Conclusion

GSON excels in handling JSON data, which is key when working with network-based APIs. It’s lightweight and easy to use for simple data exchange.

Room, on the other hand, is designed for robust, local data storage using a relational database model. It’s perfect for managing long-term, structured data.

In many Android applications, the combination of both libraries offers an optimal approach for working with both online and offline data.

## Objective By the end of this lesson, students will: - Understand GSON's role in JSON serialization and deserialization. - Be able to apply GSON to serialize and deserialize simple objects, lists, nested objects, and custom data types in Android. - Develop a basic Android app demonstrating these concepts.

---

## **Lesson Plan Overview** (Total: ~3 hours)

### **1. Introduction to GSON (15 minutes)** - **Topics covered**: - What is GSON? (A library for converting Java Objects to and from JSON). - Why GSON is essential in Android development (easier handling of JSON data). - Comparison with other libraries (e.g., Jackson, Moshi). - Use cases for JSON in Android apps (e.g., REST APIs, data persistence).

- **Demo**: Show a quick example of a JSON string and explain its structure.

2. Project Setup (10 minutes)** **Workflow**:

1. Create a new Android project in Android Studio. 2. Open `build.gradle` (app-level) and add the GSON dependency: ```gradle implementation 'com.google.code.gson:gson:2.8.9' ``` 3. Sync the project.

3. Basic GSON Usage (20 minutes)** - Explain how to create a `Gson` instance using the `GsonBuilder`. - Introduce the concepts of serialization (Java object → JSON) and deserialization (JSON → Java object).

The error is occurring in the GSON dependency line of your build.gradle file.

The syntax for specifying the GSON library is incorrect. Let's fix it:

Current problematic line: ```gradle implementation (com.google.code.gson:gson:2.8.9) ```

This line is causing several syntax errors because it's not properly formatted as a Gradle dependency string.

To fix this, change the line to:

```gradle implementation 'com.google.code.gson:gson:2.8.9' ```

The corrected version: 1. Uses single quotes to enclose the entire dependency string. 2. Removes the parentheses. 3. Ensures the dependency is specified as a single string.

After making this change, your dependencies block should look like this:

```gradle dependencies { implementation(libs.androidx.core.ktx) implementation(libs.androidx.appcompat) implementation(libs.material) implementation(libs.androidx.activity) implementation(libs.androidx.constraintlayout) implementation 'com.google.code.gson:gson:2.8.9' testImplementation(libs.junit) androidTestImplementation(libs.androidx.junit) androidTestImplementation(libs.androidx.espresso.core) } ```

After making this change: 1. Sync your Gradle files (you can do this by clicking the "Sync Now" link that appears in the editor, or by clicking the elephant icon in the toolbar). 2. If the sync is successful, try rebuilding your project.

This should resolve the syntax errors you're seeing and allow your project to properly include the GSON library.

The error is occurring because the GSON dependency is not correctly formatted in your build.gradle.kts file. In Kotlin DSL (which is used in .kts files), the syntax for adding dependencies is slightly different from the Groovy DSL used in regular .gradle files.

To fix this, you need to change the GSON dependency line from:

implementation 'com.google.code.gson:gson:2.8.9'

to:

implementation("com.google.code.gson:gson:2.8.9")

The key differences are:

Use parentheses () instead of single quotes ''

Keep the string inside double quotes ""

After making this change, your dependencies block should look like this:

dependencies {

implementation(libs.androidx.core.ktx)

implementation(libs.androidx.appcompat)

implementation(libs.material)

testImplementation(libs.junit)

androidTestImplementation(libs.androidx.junit)

androidTestImplementation(libs.androidx.espresso.core)

implementation("com.google.code.gson:gson:2.8.9")

}

After making this change:

Sync your Gradle files (you can do this by clicking the "Sync Now" link that appears in the editor, or by clicking the elephant icon in the toolbar).

If the sync is successful, try rebuilding your project.

This should resolve the syntax errors you're seeing and allow your project to properly include the GSON library. 4. Exercise Drills Each drill builds on the previous one, reinforcing learning through hands-on coding.

Drill 1: Simple Object Serialization (15 minutes)** **Objective**: Serialize a `User` object to JSON.

1. **Code Task**: - Create a `User` class: ```java public class User { private String name; private int age; private String email; public User(String name, int age, String email) { this.name = name; this.age = age; this.email = email; } // Getters, setters, toString()... }

Android application that implements the User class and demonstrates simple object serialization using GSON. This will include the MainActivity, layout file, and necessary modifications to the User class.

Here's the complete code:

User.java

import com.google.gson.annotations.SerializedName;

public class User {

@SerializedName("name")

private String name;

@SerializedName("age")

private int age;

@SerializedName("email")

private String email;

public User(String name, int age, String email) {

this.name = name;

this.age = age;

this.email = email;

}

// Getters

public String getName() { return name; }

public int getAge() { return age; }

public String getEmail() { return email; }

// Setters

public void setName(String name) { this.name = name; }

public void setAge(int age) { this.age = age; }

public void setEmail(String email) { this.email = email; }

@Override

public String toString() {

return "User{" +

"name='" + name + '\'' +

", age=" + age +

", email='" + email + '\'' +

'}';

}

MainActivity.java

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;

import android.view.View;

import android.widget.Button;

import android.widget.TextView;

import com.google.gson.Gson;

public class MainActivity extends AppCompatActivity {

private TextView resultTextView;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

resultTextView = findViewById(R.id.resultTextView);

Button serializeButton = findViewById(R.id.serializeButton);

serializeButton.setOnClickListener(new View.OnClickListener() {

@Override

public void onClick(View v) {

performSerialization();

}

});

}

private void performSerialization() {

User user = new User("John Doe", 30, "john.doe@example.com");

Gson gson = new Gson();

String json = gson.toJson(user);

String result = "User object: " + user.toString() + "\n\nSerialized JSON: " + json;

resultTextView.setText(result);

}

activity_main.xml

xml

Copy

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

android:layout_width="match_parent"

android:layout_height="match_parent"

android:orientation="vertical"

android:padding="16dp">

<Button

android:id="@+id/serializeButton"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="Serialize User" />

<ScrollView

android:layout_width="match_parent"

android:layout_height="match_parent"

android:layout_marginTop="16dp">

<TextView

android:id="@+id/resultTextView"

android:layout_width="match_parent"

android:layout_height="wrap_content" />

</ScrollView>

</LinearLayout>

build.gradle (app-level) Make sure you have the GSON dependency in your app-level build.gradle file:

gradle

Copy

dependencies {

// ... other dependencies

implementation 'com.google.gson:gson:2.8.9'

}

try :→ To run this application:

Create a new Android project in Android Studio.

Replace the content of your MainActivity.java with the provided code.

Create a new Java class called User and paste the provided User class code.

Replace your activity_main.xml content with the provided layout.

Add the GSON dependency to your app-level build.gradle file if it's not already there.

Sync your project with Gradle files.

Run the application on an emulator or physical device.

When you run the app, you'll see a "Serialize User" button. Clicking this button will create a User object, serialize it to JSON using GSON, and display both the original User object and the serialized JSON string on the screen.

This implementation completes the objective of Drill 1: Simple Object Serialization, demonstrating how to serialize a User object to JSON using GSON in an Android application.

2. **Serialize it** using GSON: ```java User user = new User("John Doe", 30, "john@example.com"); String json = gson.toJson(user); ```

3. **Discussion**: - Why serialization is important. - How JSON is used in mobile app networking.

---

#### **Drill 2: Simple Object Deserialization (15 minutes)** **Objective**: Deserialize a JSON string to a `User` object.

1. **Code Task**: Use the following JSON string: ```java String json = "{\"name\":\"Jane Doe\",\"age\":25,\"email\":\"jane@example.com\"}"; User user = gson.fromJson(json, User.class); ```

Want to print your doc?
This is not the way.

Try clicking the ⋯ next to your doc name or using a keyboard shortcut (

CtrlP

) instead.