Using Retrofit with XML UI for Network Calls

Retrofit is a popular type-safe HTTP client for Android and Java, making it easy to consume RESTful APIs. While it’s commonly used with JSON data, Retrofit also supports XML, providing a robust solution for applications that interact with XML-based web services. Combining Retrofit with XML-based UI in Android applications involves setting up the necessary dependencies, defining data models, configuring the Retrofit client for XML parsing, and integrating the network calls with the user interface.

Understanding Retrofit

Retrofit simplifies the process of making network requests by turning HTTP APIs into Java or Kotlin interfaces. Annotations are used to configure the HTTP requests, making the code clean and maintainable.

Why Use Retrofit with XML?

• Legacy Systems: Interacting with older systems that provide data in XML format.
• Interoperability: Some APIs still use XML due to its verbosity and support for complex schemas.
• Control: XML provides more explicit control over the structure and validation of data.

Setting up Retrofit for XML

To use Retrofit with XML, you’ll need to include additional dependencies for XML serialization/deserialization.

Step 1: Add Dependencies

Add the necessary dependencies in your app’s build.gradle file:

dependencies {
    implementation 'com.squareup.retrofit2:retrofit:2.9.0'
    implementation 'com.squareup.retrofit2:converter-simplexml:2.9.0'
    implementation 'com.squareup.okhttp3:logging-interceptor:4.9.1'
}

• com.squareup.retrofit2:retrofit: Core Retrofit library.
• com.squareup.retrofit2:converter-simplexml: Converter factory for XML serialization/deserialization using Simple XML.
• com.squareup.okhttp3:logging-interceptor: For logging network requests and responses, aiding in debugging.

Step 2: Define Data Model

Create data classes that correspond to the XML structure you’re working with. Use Simple XML annotations to map the XML elements to your class fields.

import org.simpleframework.xml.ElementList;
import org.simpleframework.xml.Root;

import java.util.List;

@Root(name = "employees")
public class Employees {

    @ElementList(inline = true, name = "employee")
    private List<Employee> employeeList;

    public List<Employee> getEmployeeList() {
        return employeeList;
    }

    public void setEmployeeList(List<Employee> employeeList) {
        this.employeeList = employeeList;
    }
}

import org.simpleframework.xml.Element;
import org.simpleframework.xml.Root;

@Root(name = "employee")
public class Employee {

    @Element(name = "id")
    private int id;

    @Element(name = "name")
    private String name;

    @Element(name = "role")
    private String role;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getRole() {
        return role;
    }

    public void setRole(String role) {
        this.role = role;
    }
}

Step 3: Define the API Interface

Create an interface to define your API endpoints using Retrofit annotations.

import retrofit2.Call;
import retrofit2.http.GET;

public interface EmployeeService {
    @GET("employees.xml")
    Call<Employees> getEmployees();
}

Step 4: Configure Retrofit

Create a Retrofit instance with the Simple XML converter and the base URL of the API.

import retrofit2.Retrofit;
import retrofit2.converter.simplexml.SimpleXmlConverterFactory;

public class RetrofitClient {

    private static Retrofit retrofit;
    private static final String BASE_URL = "http://your-api-base-url/"; // Replace with your API base URL

    public static Retrofit getRetrofitInstance() {
        if (retrofit == null) {
            retrofit = new Retrofit.Builder()
                    .baseUrl(BASE_URL)
                    .addConverterFactory(SimpleXmlConverterFactory.create())
                    .build();
        }
        return retrofit;
    }
}

Step 5: Make the API Call

Call the API and handle the response in your Activity or Fragment.

import android.os.Bundle;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;

public class MainActivity extends AppCompatActivity {

    private TextView employeeTextView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        employeeTextView = findViewById(R.id.employeeTextView);

        EmployeeService employeeService = RetrofitClient.getRetrofitInstance().create(EmployeeService.class);
        Call<Employees> call = employeeService.getEmployees();

        call.enqueue(new Callback<Employees>() {
            @Override
            public void onResponse(Call<Employees> call, Response<Employees> response) {
                if (response.isSuccessful()) {
                    Employees employees = response.body();
                    if (employees != null && employees.getEmployeeList() != null) {
                        StringBuilder employeeListText = new StringBuilder();
                        for (Employee employee : employees.getEmployeeList()) {
                            employeeListText.append("ID: ").append(employee.getId()).append("\\n");
                            employeeListText.append("Name: ").append(employee.getName()).append("\\n");
                            employeeListText.append("Role: ").append(employee.getRole()).append("\\n\\n");
                        }
                        employeeTextView.setText(employeeListText.toString());
                    } else {
                        employeeTextView.setText("No employees found");
                    }
                } else {
                    employeeTextView.setText("Error: " + response.message());
                }
            }

            @Override
            public void onFailure(Call<Employees> call, Throwable t) {
                employeeTextView.setText("Failure: " + t.getMessage());
            }
        });
    }
}

Handling UI Updates

Since network operations should not be performed on the main thread, you can use AsyncTask, Handler, or a library like RxJava or Coroutines to handle background tasks and update the UI.

Update UI Using AsyncTask (Example)

import android.os.AsyncTask;
import android.os.Bundle;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;
import retrofit2.Call;
import retrofit2.Response;

public class MainActivity extends AppCompatActivity {

    private TextView employeeTextView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        employeeTextView = findViewById(R.id.employeeTextView);

        new FetchEmployeesTask().execute();
    }

    private class FetchEmployeesTask extends AsyncTask<Void, Void, String> {

        @Override
        protected String doInBackground(Void... voids) {
            try {
                EmployeeService employeeService = RetrofitClient.getRetrofitInstance().create(EmployeeService.class);
                Call<Employees> call = employeeService.getEmployees();
                Response<Employees> response = call.execute();

                if (response.isSuccessful()) {
                    Employees employees = response.body();
                    if (employees != null && employees.getEmployeeList() != null) {
                        StringBuilder employeeListText = new StringBuilder();
                        for (Employee employee : employees.getEmployeeList()) {
                            employeeListText.append("ID: ").append(employee.getId()).append("\\n");
                            employeeListText.append("Name: ").append(employee.getName()).append("\\n");
                            employeeListText.append("Role: ").append(employee.getRole()).append("\\n\\n");
                        }
                        return employeeListText.toString();
                    } else {
                        return "No employees found";
                    }
                } else {
                    return "Error: " + response.message();
                }
            } catch (Exception e) {
                return "Failure: " + e.getMessage();
            }
        }

        @Override
        protected void onPostExecute(String result) {
            employeeTextView.setText(result);
        }
    }
}

Considerations

• Error Handling: Implement proper error handling to gracefully handle network errors, server errors, and parsing exceptions.
• Background Tasks: Always perform network calls in a background thread to prevent blocking the main thread and causing ANR (Application Not Responding) errors.
• XML Parsing Overhead: XML parsing can be more resource-intensive than JSON, so consider performance implications, especially when dealing with large XML documents.
• Security: Ensure that sensitive data is transmitted securely over HTTPS.

Conclusion

Using Retrofit with XML in Android applications offers a powerful way to interact with XML-based web services. By setting up Retrofit with the Simple XML converter, defining data models with annotations, and properly handling background tasks and UI updates, you can efficiently manage XML data in your Android apps. This approach is particularly useful when working with legacy systems or APIs that require XML format.