MineSkin.org client to easily upload and retrieve skins from URLs, image files, or current Player Unique IDs.

README.md

You Unirest to use this!

It's pretty easy, though. Instructions are here: http://unirest.io/java.html.

Once you have Unirest, just copy this into your project.

Then you're done.

<3

MineSkinClient.java

import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.JsonNode;
import com.mashape.unirest.http.Unirest;
import com.mashape.unirest.http.async.Callback;
import com.mashape.unirest.http.exceptions.UnirestException;

import java.io.File;
import java.util.UUID;
import java.util.concurrent.Future;

/**
 * MineSkin client to easily upload and retrieve skins from URLs, image files, or current Player Unique IDs.
 * 
 * @author @simpleauthority
 * @version 1.0.0
 */
public final class MineSkinClient {
    private static final String USER_AGENT_STRING               =   "MineSkinClient/1.0.0 (PROJECT_NAME/VERSION_NUMBER)";
    private static final String GENERATE_VIA_URL_ENDPOINT       =   "https://api.mineskin.org/generate/url";
    private static final String GENERATE_VIA_FILE_ENDPOINT      =   "https://api.mineskin.org/generate/upload";
    private static final String GENERATE_VIA_UUID_ENDPOINT      =   "https://api.mineskin.org/generate/user";

    /*
     ============================
     # Generate Skin via URL    #
     ============================
     */
    public final HttpResponse<JsonNode> generateSkinViaUrlSyncSync(String skinImageUrl) {
        return generateSkinViaUrlSync(skinImageUrl, SkinModel.STEVE, true, "");
    }
    
    public final HttpResponse<JsonNode> generateSkinViaUrlSync(String skinImageUrl, SkinModel model) {
        return generateSkinViaUrlSync(skinImageUrl, model, true, "");
    }
    
    public final HttpResponse<JsonNode> generateSkinViaUrlSync(String skinImageUrl, boolean visible) {
        return generateSkinViaUrlSync(skinImageUrl, SkinModel.STEVE, visible, "");
    }

    public final HttpResponse<JsonNode> generateSkinViaUrlSync(String skinImageUrl, String name) {
        return generateSkinViaUrlSync(skinImageUrl, SkinModel.STEVE, true, name);
    }

    public final HttpResponse<JsonNode> generateSkinViaUrlSync(String skinImageUrl, SkinModel model, boolean visible, String name) {
        try {
            return Unirest.post(GENERATE_VIA_URL_ENDPOINT)
                    .header("User-Agent", USER_AGENT_STRING)
                    .field("url", skinImageUrl)
                    .field("model", model.getModel())
                    .field("visibility", visible ? 0 : 1)
                    .field("name", name)
                    .asJson();
        } catch (UnirestException e) {
            e.printStackTrace();
        }
        
        return null;
    }

    @SuppressWarnings("unchecked")
    public final Future<HttpResponse<JsonNode>> generateSkinViaUrlAsync(String skinImageUrl) {
        return generateSkinViaUrlAsync(skinImageUrl, (Callback)null);
    }
    
    public final Future<HttpResponse<JsonNode>> generateSkinViaUrlAsync(String skinImageUrl, Callback<JsonNode> callback) {
        return generateSkinViaUrlAsync(skinImageUrl, SkinModel.STEVE, true, "", callback);
    }

    @SuppressWarnings("unchecked")
    public final Future<HttpResponse<JsonNode>> generateSkinViaUrlAsync(String skinImageUrl, SkinModel model) {
        return generateSkinViaUrlAsync(skinImageUrl, model, (Callback)null);
    }
    
    public final Future<HttpResponse<JsonNode>> generateSkinViaUrlAsync(String skinImageUrl, SkinModel model, Callback<JsonNode> callback) {
        return generateSkinViaUrlAsync(skinImageUrl, model, true, "", callback);
    }

    @SuppressWarnings("unchecked")
    public final Future<HttpResponse<JsonNode>> generateSkinViaUrlAsync(String skinImageUrl, boolean visible) {
        return generateSkinViaUrlAsync(skinImageUrl, visible, (Callback)null);
    }
    
    public final Future<HttpResponse<JsonNode>> generateSkinViaUrlAsync(String skinImageUrl, boolean visible, Callback<JsonNode> callback) {
        return generateSkinViaUrlAsync(skinImageUrl, SkinModel.STEVE, visible, "", callback);
    }

    @SuppressWarnings("unchecked")
    public final Future<HttpResponse<JsonNode>> generateSkinViaUrlAsync(String skinImageUrl, String name) {
        return generateSkinViaUrlAsync(skinImageUrl, name, (Callback)null);
    }
    
    public final Future<HttpResponse<JsonNode>> generateSkinViaUrlAsync(String skinImageUrl, String name, Callback<JsonNode> callback) {
        return generateSkinViaUrlAsync(skinImageUrl, SkinModel.STEVE, true, name, callback);
    }

    public final Future<HttpResponse<JsonNode>> generateSkinViaUrlAsync(String skinImageUrl, SkinModel model, boolean visible, String name, Callback<JsonNode> callback) {
        return Unirest.post(GENERATE_VIA_URL_ENDPOINT)
                .header("User-Agent", USER_AGENT_STRING)
                .field("url", skinImageUrl)
                .field("model", model.getModel())
                .field("visibility", visible ? 0 : 1)
                .field("name", name)
                .asJsonAsync(callback);
    }
    
    /*
     =============================
     # Generate Skin via File    #
     =============================
     */
    public final HttpResponse<JsonNode> generateSkinViaFileSync(File skinImageFile) {
        return generateSkinViaFileSync(skinImageFile);
    }
    
    public final HttpResponse<JsonNode> generateSkinViaFileSync(File skinImageFile, SkinModel model) {
        return generateSkinViaFileSync(skinImageFile, model);
    }
    
    public final HttpResponse<JsonNode> generateSkinViaFileSync(File skinImageFile, boolean visible) {
        return generateSkinViaFileSync(skinImageFile, visible);
    }
    
    public final HttpResponse<JsonNode> generateSkinViaFileSync(File skinImageFile, String name) {
        return generateSkinViaFileSync(skinImageFile, name);
    }

    public final HttpResponse<JsonNode> generateSkinViaFileSync(File skinImageFile, SkinModel model, boolean visible, String name) {
        try {
            return Unirest.post(GENERATE_VIA_FILE_ENDPOINT)
                    .header("User-Agent", USER_AGENT_STRING)
                    .field("file", skinImageFile)
                    .field("model", model.getModel())
                    .field("visibility", visible ? 0 : 1)
                    .field("name", name)
                    .asJson();
        } catch (UnirestException e) {
            e.printStackTrace();
        }
        
        return null;
    }
    
    @SuppressWarnings("unchecked")
    public final Future<HttpResponse<JsonNode>> generateSkinViaFileAsync(File skinImageFile) {
        return generateSkinViaFileAsync(skinImageFile, (Callback)null);
    }

    public final Future<HttpResponse<JsonNode>> generateSkinViaFileAsync(File skinImageFile, Callback<JsonNode> callback) {
        return generateSkinViaFileAsync(skinImageFile, SkinModel.STEVE, true, "", callback);
    }

    @SuppressWarnings("unchecked")
    public final Future<HttpResponse<JsonNode>> generateSkinViaFileAsync(File skinImageFile, SkinModel model) {
        return generateSkinViaFileAsync(skinImageFile, model, (Callback)null);
    }

    public final Future<HttpResponse<JsonNode>> generateSkinViaFileAsync(File skinImageFile, SkinModel model, Callback<JsonNode> callback) {
        return generateSkinViaFileAsync(skinImageFile, model, true, "", callback);
    }

    @SuppressWarnings("unchecked")
    public final Future<HttpResponse<JsonNode>> generateSkinViaFileAsync(File skinImageFile, boolean visible) {
        return generateSkinViaFileAsync(skinImageFile, visible, (Callback)null);
    }

    public final Future<HttpResponse<JsonNode>> generateSkinViaFileAsync(File skinImageFile, boolean visible, Callback<JsonNode> callback) {
        return generateSkinViaFileAsync(skinImageFile, SkinModel.STEVE, visible, "", callback);
    }

    @SuppressWarnings("unchecked")
    public final Future<HttpResponse<JsonNode>> generateSkinViaFileAsync(File skinImageFile, String name) {
        return generateSkinViaFileAsync(skinImageFile, name, (Callback)null);
    }

    public final Future<HttpResponse<JsonNode>> generateSkinViaFileAsync(File skinImageFile, String name, Callback<JsonNode> callback) {
        return generateSkinViaFileAsync(skinImageFile, SkinModel.STEVE, true, name, callback);
    }

    public final Future<HttpResponse<JsonNode>> generateSkinViaFileAsync(File skinImageFile, SkinModel model, boolean visible, String name, Callback<JsonNode> callback) {
        return Unirest.post(GENERATE_VIA_FILE_ENDPOINT)
                .header("User-Agent", USER_AGENT_STRING)
                .field("file", skinImageFile)
                .field("model", model.getModel())
                .field("visibility", visible ? 0 : 1)
                .field("name", name)
                .asJsonAsync(callback);
    }

    /*
     =============================
     # Generate Skin via UUID    #
     =============================
     */
    public final HttpResponse<JsonNode> generateSkinViaUuidSync(UUID skinImageUniqueId) {
        return generateSkinViaUuidSync(skinImageUniqueId);
    }
    
    public final HttpResponse<JsonNode> generateSkinViaUuidSync(UUID skinImageUniqueId, SkinModel model) {
        return generateSkinViaUuidSync(skinImageUniqueId, model);
    }
    
    public final HttpResponse<JsonNode> generateSkinViaUuidSync(UUID skinImageUniqueId, boolean visible) {
        return generateSkinViaUuidSync(skinImageUniqueId, visible);
    }
    
    public final HttpResponse<JsonNode> generateSkinViaUuidSync(UUID skinImageUniqueId, String name) {
        return generateSkinViaUuidSync(skinImageUniqueId, name);
    }

    public final HttpResponse<JsonNode> generateSkinViaUuidSync(UUID skinImageUniqueId, SkinModel model, boolean visible, String name) {
        try {
            return Unirest.post(GENERATE_VIA_UUID_ENDPOINT)
                    .header("User-Agent", USER_AGENT_STRING)
                    .field("uuid", skinImageUniqueId.toString())
                    .field("model", model.getModel())
                    .field("visibility", visible ? 0 : 1)
                    .field("name", name)
                    .asJson();
        } catch (UnirestException e) {
            e.printStackTrace();
        }
        
        return null;
    }
    
    @SuppressWarnings("unchecked")
    public final Future<HttpResponse<JsonNode>> generateSkinViaUuidAsync(UUID skinImageUniqueId) {
        return generateSkinViaUuidAsync(skinImageUniqueId, (Callback)null);
    }

    public final Future<HttpResponse<JsonNode>> generateSkinViaUuidAsync(UUID skinImageUniqueId, Callback<JsonNode> callback) {
        return generateSkinViaUuidAsync(skinImageUniqueId, SkinModel.STEVE, true, "", callback);
    }

    @SuppressWarnings("unchecked")
    public final Future<HttpResponse<JsonNode>> generateSkinViaUuidAsync(UUID skinImageUniqueId, SkinModel model) {
        return generateSkinViaUuidAsync(skinImageUniqueId, model, (Callback)null);
    }

    public final Future<HttpResponse<JsonNode>> generateSkinViaUuidAsync(UUID skinImageUniqueId, SkinModel model, Callback<JsonNode> callback) {
        return generateSkinViaUuidAsync(skinImageUniqueId, model, true, "", callback);
    }

    @SuppressWarnings("unchecked")
    public final Future<HttpResponse<JsonNode>> generateSkinViaUuidAsync(UUID skinImageUniqueId, boolean visible) {
        return generateSkinViaUuidAsync(skinImageUniqueId, visible, (Callback)null);
    }

    public final Future<HttpResponse<JsonNode>> generateSkinViaUuidAsync(UUID skinImageUniqueId, boolean visible, Callback<JsonNode> callback) {
        return generateSkinViaUuidAsync(skinImageUniqueId, SkinModel.STEVE, visible, "", callback);
    }

    @SuppressWarnings("unchecked")
    public final Future<HttpResponse<JsonNode>> generateSkinViaUuidAsync(UUID skinImageUniqueId, String name) {
        return generateSkinViaUuidAsync(skinImageUniqueId, name, (Callback)null);
    }

    public final Future<HttpResponse<JsonNode>> generateSkinViaUuidAsync(UUID skinImageUniqueId, String name, Callback<JsonNode> callback) {
        return generateSkinViaUuidAsync(skinImageUniqueId, SkinModel.STEVE, true, name, callback);
    }

    public final Future<HttpResponse<JsonNode>> generateSkinViaUuidAsync(UUID skinImageUniqueId, SkinModel model, boolean visible, String name, Callback<JsonNode> callback) {
        return Unirest.post(GENERATE_VIA_UUID_ENDPOINT)
                .header("User-Agent", USER_AGENT_STRING)
                .field("uuid", skinImageUniqueId.toString())
                .field("model", model.getModel())
                .field("visibility", visible ? 0 : 1)
                .field("name", name)
                .asJsonAsync(callback);
    }

    public enum SkinModel {
        STEVE   (""),
        ALEX    ("slim");

        private final String model;

        SkinModel(String model) {
            this.model = model;
        }

        public String getModel() {
            return model;
        }
    }
}