Uploading Images to tumblr API from Android

Uploading Images to Tumblr API from Android

Introduction

This article will guide you through the process of uploading images to Tumblr using the Tumblr API from an Android application. We’ll cover the necessary steps, including setting up the environment, making API requests, and handling responses.

Prerequisites

• Android Studio installed
• Basic knowledge of Android development
• A Tumblr account with API access

Setting up the Environment

1. Create a New Android Project

Open Android Studio and create a new Android project. Choose an Empty Activity template.

2. Add Dependencies

Add the necessary dependencies to your project’s `build.gradle (Module: app)` file:

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

These dependencies are for:

• Retrofit: A type-safe REST client for Android
• Gson: A Java library for serializing and deserializing Java objects to/from JSON
• OkHttp: A powerful HTTP client for Android

3. Obtain Tumblr API Credentials

Sign in to your Tumblr account and go to https://www.tumblr.com/docs/en/api/v2 to create a new application. Get your API key and secret. Save these securely, as they will be used for authentication.

Creating the API Service

1. Define the Interface

Create an interface defining the API endpoint for uploading images:

public interface TumblrApiService {

    @Multipart
    @POST("/v2/blog/{blogName}/post")
    Call<TumblrResponse> uploadImage(@Path("blogName") String blogName,
                                        @Part("type") RequestBody type,
                                        @Part("data") RequestBody image,
                                        @Part("caption") RequestBody caption,
                                        @Query("api_key") String apiKey);

}

This interface specifies the HTTP method (POST), the endpoint URL, and the request parameters.

2. Create the Retrofit Instance

Create a Retrofit instance to interact with the API:

public class TumblrApi {

    private static TumblrApiService tumblrApiService;

    public static TumblrApiService getApiService(String apiKey) {
        if (tumblrApiService == null) {
            Retrofit retrofit = new Retrofit.Builder()
                    .baseUrl("https://api.tumblr.com")
                    .addConverterFactory(GsonConverterFactory.create())
                    .client(new OkHttpClient.Builder()
                            .addInterceptor(new HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BODY))
                            .build())
                    .build();
            tumblrApiService = retrofit.create(TumblrApiService.class);
        }
        return tumblrApiService;
    }

}

This code creates a Retrofit instance with the base URL, adds the Gson converter for JSON parsing, and sets up an HTTP logging interceptor for debugging purposes.

Uploading Images

1. Prepare Request Body

Create a request body with the image data and other necessary parameters:

File imageFile = new File(...); // Get the image file
RequestBody imageBody = RequestBody.create(MediaType.parse("image/jpeg"), imageFile); // Assuming JPEG image
RequestBody typeBody = RequestBody.create(MediaType.parse("text/plain"), "photo");
RequestBody captionBody = RequestBody.create(MediaType.parse("text/plain"), "My Image Caption"); // Optional caption

2. Make the API Request

Use the Retrofit instance to make the API request:

TumblrApiService tumblrApiService = TumblrApi.getApiService(YOUR_API_KEY);
Call<TumblrResponse> call = tumblrApiService.uploadImage(YOUR_BLOG_NAME, typeBody, imageBody, captionBody, YOUR_API_KEY);

call.enqueue(new Callback<TumblrResponse>() {
    @Override
    public void onResponse(Call<TumblrResponse> call, Response<TumblrResponse> response) {
        if (response.isSuccessful()) {
            // Image uploaded successfully
            TumblrResponse tumblrResponse = response.body();
            // Handle the response as needed (e.g., get the image URL)
        } else {
            // Handle error
            // You can access the error response details using response.errorBody()
        }
    }

    @Override
    public void onFailure(Call<TumblrResponse> call, Throwable t) {
        // Handle network failure
    }
});

This code makes the API request with the prepared request body and handles the response, either success or failure.

Handling the Response

Once the API request is completed, you’ll receive a response containing information about the upload. You can use this response to access the image URL, post ID, or any other relevant data.

1. Parse the Response

Parse the JSON response using the `TumblrResponse` object:

public class TumblrResponse {

    // ... other fields

    public String getPostUrl() {
        return post.get(0).getUrl();
    }

}

This class defines the structure of the API response, including the URL of the uploaded image.

2. Display Image

Display the image URL in your app. For example, use an `ImageView` and set its source to the image URL obtained from the response.

Error Handling

Implement error handling in the `onFailure()` callback or by checking the response status code in `onResponse()`.

• Network errors
• API errors (e.g., invalid API key, incorrect blog name)

Table Comparison

Conclusion

By following these steps, you can successfully integrate Tumblr API image uploads into your Android app. Remember to handle errors and secure your API credentials properly.