Android
Modernizacja 2

Wprowadzenie

Uwagi

dependencies {
    ...
    compile 'com.squareup.retrofit2:converter-gson:2.3.0'    
    compile 'com.squareup.retrofit2:retrofit:2.3.0'
    ...
}

<dependency>
  <groupId>com.squareup.retrofit2</groupId>
  <artifactId>retrofit</artifactId>
  <version>2.3.0</version>
</dependency>

Proste żądanie GET

Pokażemy, jak wykonać żądanie GET do interfejsu API, który odpowiada obiektem JSON lub tablicą JSON . Pierwszą rzeczą, którą musimy zrobić, to dodać zależności Retrofit i GSON Converter do pliku stopni naszego modułu.

Dodaj zależności dla biblioteki modernizacji zgodnie z opisem w sekcji Uwagi.

Przykład oczekiwanego obiektu JSON:

{
    "deviceId": "56V56C14SF5B4SF",
    "name": "Steven",
    "eventCount": 0
}

Przykład tablicy JSON:

[
    {
        "deviceId": "56V56C14SF5B4SF",
        "name": "Steven",
        "eventCount": 0
    },
    {
        "deviceId": "35A80SF3QDV7M9F",
        "name": "John",
        "eventCount": 2
    }
]

Przykład odpowiedniej klasy modelu:

public class Device
{
    @SerializedName("deviceId")
    public String id;

    @SerializedName("name")
    public String name;

    @SerializedName("eventCount")
    public int eventCount;
}

Adnotacje @SerializedName tutaj pochodzą z biblioteki GSON i pozwalają nam serialize i deserialize tę klasę do JSON używając nazwy szeregowej jako kluczy. Teraz możemy zbudować interfejs API, który faktycznie pobierze dane z serwera.

public interface DeviceAPI
{
    @GET("device/{deviceId}")
    Call<Device> getDevice (@Path("deviceId") String deviceID);

    @GET("devices")
    Call<List<Device>> getDevices();
}

Wiele dzieje się tutaj w dość zwartej przestrzeni, więc podzielmy to:

• Adnotacja @GET pochodzi z Retrofit i informuje bibliotekę, że definiujemy żądanie GET.
• Ścieżka w nawiasach to punkt końcowy, do którego powinno trafić nasze żądanie GET (podstawowy adres URL ustawimy nieco później).
• Nawiasy klamrowe pozwalają nam zamieniać części ścieżki w czasie wykonywania, abyśmy mogli przekazywać argumenty.
• Definiowana przez nas funkcja nazywa się getDevice i przyjmuje jako argument identyfikator urządzenia, który chcemy.
• Adnotacja @PATH informuje, że ten argument powinien zastąpić symbol zastępczy „deviceId” na ścieżce.
• Funkcja zwraca obiekt Call typu Device .

Tworzenie klasy opakowania:

Teraz stworzymy małą klasę otoki dla naszego API, aby ładnie opakować kod inicjalizacyjny Retrofit.

public class DeviceAPIHelper
{
    public final DeviceAPI api;

    private DeviceAPIHelper ()
    {

        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("http://example.com/")
                .addConverterFactory(GsonConverterFactory.create())
                .build();

        api = retrofit.create(DeviceAPI.class);
    }
}

Ta klasa tworzy instancję GSON, aby móc przeanalizować odpowiedź JSON, tworzy instancję Retrofit z naszym podstawowym adresem URL i GSONConverter, a następnie tworzy instancję naszego API.

Wywoływanie interfejsu API:

// Getting a JSON object
Call<Device> callObject = api.getDevice(deviceID);
callObject.enqueue(new Callback<Response<Device>>()
{
    @Override
    public void onResponse (Call<Device> call, Response<Device> response)
    {
        if (response.isSuccessful()) 
        {
           Device device = response.body();
        }
    }

    @Override
    public void onFailure (Call<Device> call, Throwable t)
    {
        Log.e(TAG, t.getLocalizedMessage());
    }
});

// Getting a JSON array
Call<List<Device>> callArray = api.getDevices();
callArray.enqueue(new Callback<Response<List<Device>>()
{
    @Override
    public void onResponse (Call<List<Device>> call, Response<List<Device>> response)
    {
        if (response.isSuccessful()) 
        {
           List<Device> devices = response.body();
        }
    }

    @Override
    public void onFailure (Call<List<Device>> call, Throwable t)
    {
        Log.e(TAG, t.getLocalizedMessage());
    }
});

Korzysta z naszego interfejsu API, aby utworzyć obiekt Call<Device> i odpowiednio Call<List<Device>> . Wywołanie w enqueue informuje Retrofit, aby wykonał to wywołanie w wątku w tle i zwrócił wynik do wywołania zwrotnego, które tutaj tworzymy.

Uwaga: Analiza składni prymitywnych obiektów JSON (takich jak String, Integer, Boolean i Double ) jest podobna do analizowania tablicy JSON. Nie potrzebujesz jednak własnej klasy modeli. Możesz uzyskać tablicę ciągów znaków, na przykład zwracając typ połączenia jako Call<List<String>> .

Dodaj logowanie do Retrofit2

Żądania modernizacji można rejestrować za pomocą narzędzia przechwytującego. Dostępnych jest kilka poziomów szczegółowości: BRAK, PODSTAWOWY, NAGŁÓWKI, CIAŁO. Zobacz projekt Github tutaj .

1. Dodaj zależność do build.gradle:

compile 'com.squareup.okhttp3:logging-interceptor:3.8.1'

2. Dodaj przechwytywanie rejestrowania podczas tworzenia modernizacji:

  HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
  loggingInterceptor.setLevel(LoggingInterceptor.Level.BODY);
  OkHttpClient okHttpClient = new OkHttpClient().newBuilder()
          .addInterceptor(loggingInterceptor)
          .build();
  Retrofit retrofit = new Retrofit.Builder()
          .baseUrl("http://example.com/")
          .client(okHttpClient)
          .addConverterFactory(GsonConverterFactory.create(gson))
          .build();

Ujawnianie dzienników w terminalu (Android Monitor) jest czymś, czego należy unikać w wersji wydania, ponieważ może to prowadzić do niechcianego ujawnienia krytycznych informacji, takich jak tokeny uwierzytelniania itp.

Aby uniknąć ujawnienia dzienników w czasie wykonywania, sprawdź następujący warunek

if(BuildConfig.DEBUG){
     //your interfector code here   
    }

Na przykład:

HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
if(BuildConfig.DEBUG){
     //print the logs in this case   
    loggingInterceptor.setLevel(LoggingInterceptor.Level.BODY);
}else{
    loggingInterceptor.setLevel(LoggingInterceptor.Level.NONE);
}

OkHttpClient okHttpClient = new OkHttpClient().newBuilder()
      .addInterceptor(loggingInterceptor)
      .build();

Retrofit retrofit = new Retrofit.Builder()
      .baseUrl("http://example.com/")
      .client(okHttpClient)
      .addConverterFactory(GsonConverterFactory.create(gson))
      .build();

Przesyłanie pliku przez Multipart

Zadeklaruj swój interfejs za pomocą adnotacji Retrofit2:

public interface BackendApiClient {
    @Multipart
    @POST("/uploadFile")
    Call<RestApiDefaultResponse> uploadPhoto(@Part("file\"; filename=\"photo.jpg\" ") RequestBody photo);
}

Gdzie RestApiDefaultResponse to klasa niestandardowa zawierająca odpowiedź.

Budowanie implementacji interfejsu API i kolejkowanie połączenia:

Retrofit retrofit = new Retrofit.Builder()
                                .addConverterFactory(GsonConverterFactory.create())
                                .baseUrl("http://<yourhost>/")
                                .client(okHttpClient)
                                .build();

BackendApiClient apiClient = retrofit.create(BackendApiClient.class);
RequestBody reqBody = RequestBody.create(MediaType.parse("image/jpeg"), photoFile);
Call<RestApiDefaultResponse> call = apiClient.uploadPhoto(reqBody);
call.enqueue(<your callback function>);

Zmodernizuj za pomocą przechwytywacza OkHttp

Ten przykład pokazuje, jak używać przechwytywacza żądań z OkHttp. Ma to wiele zastosowań, takich jak:

• Dodanie header uniwersalnego do żądania. Np. Uwierzytelnienie wniosku
• Debugowanie aplikacji sieciowych
• Odzyskiwanie surowej response
• Rejestrowanie transakcji sieciowych itp.
• Ustaw niestandardowego agenta użytkownika

Retrofit.Builder builder = new Retrofit.Builder()
        .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
        .addConverterFactory(GsonConverterFactory.create())
        .baseUrl("https://api.github.com/");

if (!TextUtils.isEmpty(githubToken)) {
    // `githubToken`: Access token for GitHub
    OkHttpClient client = new OkHttpClient.Builder().addInterceptor(new Interceptor() {
        @Override public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            Request newReq = request.newBuilder()
                    .addHeader("Authorization", format("token %s", githubToken))
                    .build();
            return chain.proceed(newReq);
        }
    }).build();

    builder.client(client);
}

return builder.build().create(GithubApi.class);

Aby uzyskać więcej informacji, zobacz temat OkHttp .

Nagłówek i treść: przykład uwierzytelnienia

@Header i @Body można umieścić w podpisach metod, a funkcja Retrofit automatycznie utworzy je na podstawie modeli.

public interface MyService {
     @POST("authentication/user")
     Call<AuthenticationResponse> authenticateUser(@Body AuthenticationRequest request, @Header("Authorization") String basicToken);
}

AuthenticaionRequest to nasz model, POJO, zawierający informacje wymagane przez serwer. W tym przykładzie nasz serwer chce klucza klienta i klucza tajnego.

public class AuthenticationRequest {
     String clientKey;
     String clientSecret;
}

Zauważ, że w @Header("Authorization") określamy, że @Header("Authorization") nagłówek Autoryzacji. Pozostałe nagłówki zostaną wypełnione automatycznie, ponieważ Retrofit może wywnioskować, jakie są na podstawie typu obiektów, które wysyłamy i oczekujemy w zamian.

Gdzieś tworzymy naszą usługę modernizacji. Zapewniamy użycie HTTPS.

Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("https:// some example site")
            .client(client)
            .build();
MyService myService = retrofit.create(MyService.class)

Następnie możemy skorzystać z naszych usług.

AuthenticationRequest request = new AuthenticationRequest();
request.setClientKey(getClientKey());
request.setClientSecret(getClientSecret());
String basicToken = "Basic " + token;
myService.authenticateUser(request, basicToken);

Prześlij wiele plików, używając opcji Modernizacja jako części

Po skonfigurowaniu środowiska Retrofit w projekcie możesz użyć następującego przykładu, który pokazuje, jak przesłać wiele plików przy użyciu Retrofit:

private void mulipleFileUploadFile(Uri[] fileUri) {
    OkHttpClient okHttpClient = new OkHttpClient();
    OkHttpClient clientWith30sTimeout = okHttpClient.newBuilder()
            .readTimeout(30, TimeUnit.SECONDS)
            .build();

    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl(API_URL_BASE)
            .addConverterFactory(new MultiPartConverter())
            .client(clientWith30sTimeout)
            .build();

    WebAPIService service = retrofit.create(WebAPIService.class); //here is the interface which you have created for the call service
    Map<String, okhttp3.RequestBody> maps = new HashMap<>();

    if (fileUri!=null && fileUri.length>0) {
        for (int i = 0; i < fileUri.length; i++) {
            String filePath = getRealPathFromUri(fileUri[i]);
            File file1 = new File(filePath);

            if (filePath != null && filePath.length() > 0) {
                if (file1.exists()) {
                    okhttp3.RequestBody requestFile = okhttp3.RequestBody.create(okhttp3.MediaType.parse("multipart/form-data"), file1);
                    String filename = "imagePath" + i; //key for upload file like : imagePath0
                    maps.put(filename + "\"; filename=\"" + file1.getName(), requestFile);
                }
            }
        }
    }

    String descriptionString = " string request";//
    //hear is the your json request
    Call<String> call = service.postFile(maps, descriptionString);
    call.enqueue(new Callback<String>() {
        @Override
        public void onResponse(Call<String> call,
                               Response<String> response) {
            Log.i(LOG_TAG, "success");
            Log.d("body==>", response.body().toString() + "");
            Log.d("isSuccessful==>", response.isSuccessful() + "");
            Log.d("message==>", response.message() + "");
            Log.d("raw==>", response.raw().toString() + "");
            Log.d("raw().networkResponse()", response.raw().networkResponse().toString() + "");
        }

        @Override
        public void onFailure(Call<String> call, Throwable t) {
            Log.e(LOG_TAG, t.getMessage());
        }
    });
}
    
public String getRealPathFromUri(final Uri uri) { // function for file path from uri,
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT && DocumentsContract.isDocumentUri(mContext, uri)) {
        // ExternalStorageProvider
        if (isExternalStorageDocument(uri)) {
            final String docId = DocumentsContract.getDocumentId(uri);
            final String[] split = docId.split(":");
            final String type = split[0];

            if ("primary".equalsIgnoreCase(type)) {
                return Environment.getExternalStorageDirectory() + "/" + split[1];
            }
        }
        // DownloadsProvider
        else if (isDownloadsDocument(uri)) {

            final String id = DocumentsContract.getDocumentId(uri);
            final Uri contentUri = ContentUris.withAppendedId(
                    Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));

            return getDataColumn(mContext, contentUri, null, null);
        }
        // MediaProvider
        else if (isMediaDocument(uri)) {
            final String docId = DocumentsContract.getDocumentId(uri);
            final String[] split = docId.split(":");
            final String type = split[0];

            Uri contentUri = null;
            if ("image".equals(type)) {
                contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
            } else if ("video".equals(type)) {
                contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
            } else if ("audio".equals(type)) {
                contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
            }

            final String selection = "_id=?";
            final String[] selectionArgs = new String[]{
                    split[1]
            };

            return getDataColumn(mContext, contentUri, selection, selectionArgs);
        }
    }
    // MediaStore (and general)
    else if ("content".equalsIgnoreCase(uri.getScheme())) {

        // Return the remote address
        if (isGooglePhotosUri(uri))
            return uri.getLastPathSegment();

        return getDataColumn(mContext, uri, null, null);
    }
    // File
    else if ("file".equalsIgnoreCase(uri.getScheme())) {
        return uri.getPath();
    }

    return null;
}

Poniżej znajduje się interfejs

public interface WebAPIService {
    @Multipart
    @POST("main.php")
    Call<String> postFile(@PartMap Map<String,RequestBody> Files, @Part("json") String description);
}

Pobierz plik z serwera za pomocą Retrofit2

Deklaracja interfejsu do pobierania pliku

public interface ApiInterface {
    @GET("movie/now_playing")
    Call<MovieResponse> getNowPlayingMovies(@Query("api_key") String apiKey, @Query("page") int page);

    // option 1: a resource relative to your base URL
    @GET("resource/example.zip")
    Call<ResponseBody> downloadFileWithFixedUrl();

    // option 2: using a dynamic URL
    @GET
    Call<ResponseBody> downloadFileWithDynamicUrl(@Url String fileUrl);
}

Opcja 1 służy do pobierania pliku z serwera, który ma stały adres URL. a opcja 2 służy do przekazania wartości dynamicznej jako pełnego adresu URL w celu żądania połączenia. Może to być pomocne podczas pobierania plików, które zależą od parametrów takich jak użytkownik lub czas.

Zainstaluj modernizację do wykonywania połączeń API

public class ServiceGenerator {

    public static final String API_BASE_URL = "http://your.api-base.url/";

    private static OkHttpClient.Builder httpClient = new OkHttpClient.Builder();

    private static Retrofit.Builder builder =
            new Retrofit.Builder()
            .baseUrl(API_BASE_URL)
            .addConverterFactory(GsonConverterFactory.create());

    public static <S> S createService(Class<S> serviceClass){
        Retrofit retrofit = builder.client(httpClient.build()).build();
        return retrofit.create(serviceClass);
    }

}

Teraz wykonaj implementację interfejsu API do pobierania pliku z serwera

private void downloadFile(){
        ApiInterface apiInterface = ServiceGenerator.createService(ApiInterface.class);

        Call<ResponseBody> call = apiInterface.downloadFileWithFixedUrl();

        call.enqueue(new Callback<ResponseBody>() {
            @Override
            public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
                if (response.isSuccessful()){
                    boolean writtenToDisk = writeResponseBodyToDisk(response.body());

                    Log.d("File download was a success? ", String.valueOf(writtenToDisk));
                }
            }

            @Override
            public void onFailure(Call<ResponseBody> call, Throwable t) {

            }
        });
    }

Po otrzymaniu odpowiedzi w wywołaniu zwrotnym koduj jakieś standardowe IO do zapisywania plików na dysku. Oto kod:

private boolean writeResponseBodyToDisk(ResponseBody body) {
        try {
            // todo change the file location/name according to your needs
            File futureStudioIconFile = new File(getExternalFilesDir(null) + File.separator + "Future Studio Icon.png");

            InputStream inputStream = null;
            OutputStream outputStream = null;

            try {
                byte[] fileReader = new byte[4096];

                long fileSize = body.contentLength();
                long fileSizeDownloaded = 0;

                inputStream = body.byteStream();
                outputStream = new FileOutputStream(futureStudioIconFile);

                while (true) {
                    int read = inputStream.read(fileReader);

                    if (read == -1) {
                        break;
                    }

                    outputStream.write(fileReader, 0, read);

                    fileSizeDownloaded += read;

                    Log.d("File Download: " , fileSizeDownloaded + " of " + fileSize);
                }

                outputStream.flush();

                return true;
            } catch (IOException e) {
                return false;
            } finally {
                if (inputStream != null) {
                    inputStream.close();
                }

                if (outputStream != null) {
                    outputStream.close();
                }
            }
        } catch (IOException e) {
            return false;
        }
    }

Uwaga: jako typ zwracanego wpisu podaliśmy ResponseBody , w przeciwnym razie Modernizacja spróbuje go przeanalizować i przekonwertować, co nie ma sensu podczas pobierania pliku.

Jeśli chcesz uzyskać więcej informacji na temat modernizacji, skorzystaj z tego linku, ponieważ jest to bardzo przydatne. [1]: https://futurestud.io/blog/retrofit-getting-started-and-android-client

Debugowanie za pomocą Stetho

Dodaj następujące zależności do aplikacji.

compile 'com.facebook.stetho:stetho:1.5.0' 
compile 'com.facebook.stetho:stetho-okhttp3:1.5.0' 

W metodzie onCreate klasy aplikacji wywołaj następujące polecenie.

Stetho.initializeWithDefaults(this);

Podczas tworzenia instancji Retrofit utwórz niestandardową instancję OkHttp.

OkHttpClient.Builder clientBuilder = new OkHttpClient.Builder();
clientBuilder.addNetworkInterceptor(new StethoInterceptor());

Następnie ustaw tę niestandardową instancję OkHttp w instancji Retrofit.

Retrofit retrofit = new Retrofit.Builder()
    // ...
    .client(clientBuilder.build())
    .build();

Teraz podłącz telefon do komputera, uruchom aplikację i wpisz chrome://inspect w przeglądarce Chrome. Modernizuj połączenia sieciowe powinny teraz pojawiać się w celu sprawdzenia.

Retrofit 2 Custom Converter Xml

Dodawanie zależności do pliku build.gradle.

dependencies {
    ....
    compile 'com.squareup.retrofit2:retrofit:2.1.0'
    compile ('com.thoughtworks.xstream:xstream:1.4.7') {
        exclude group: 'xmlpull', module: 'xmlpull'
    }
    ....
}

Następnie utwórz konwerter

public class XStreamXmlConverterFactory extends Converter.Factory {

    /** Create an instance using a default {@link com.thoughtworks.xstream.XStream} instance for conversion. */
    public static XStreamXmlConverterFactory create() {
        return create(new XStream());
    }

    /** Create an instance using {@code xStream} for conversion. */
    public static XStreamXmlConverterFactory create(XStream xStream) {
        return new XStreamXmlConverterFactory(xStream);
    }

    private final XStream xStream;

    private XStreamXmlConverterFactory(XStream xStream) {
        if (xStream == null) throw new NullPointerException("xStream == null");
        this.xStream = xStream;
    }

    @Override
    public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) {

        if (!(type instanceof Class)) {
            return null;
        }

        Class<?> cls = (Class<?>) type;

        return new XStreamXmlResponseBodyConverter<>(cls, xStream);
    }

    @Override
    public Converter<?, RequestBody> requestBodyConverter(Type type,
          Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {

        if (!(type instanceof Class)) {
            return null;
        }

        return new XStreamXmlRequestBodyConverter<>(xStream);
    }
}

utwórz klasę do obsługi żądania treści.

final class XStreamXmlResponseBodyConverter <T> implements Converter<ResponseBody, T> {

    private final Class<T> cls;
    private final XStream xStream;

    XStreamXmlResponseBodyConverter(Class<T> cls, XStream xStream) {
        this.cls = cls;
        this.xStream = xStream;
    }

    @Override
    public T convert(ResponseBody value) throws IOException {

        try {

            this.xStream.processAnnotations(cls);
            Object object =  this.xStream.fromXML(value.byteStream());
            return (T) object;

        }finally {
            value.close();
        }
    }
}

utwórz klasę do obsługi odpowiedzi ciała.

final class XStreamXmlRequestBodyConverter<T> implements Converter<T, RequestBody> {

    private static final MediaType MEDIA_TYPE = MediaType.parse("application/xml; charset=UTF-8");
    private static final String CHARSET = "UTF-8";

    private final XStream xStream;

    XStreamXmlRequestBodyConverter(XStream xStream) {
        this.xStream = xStream;
    }

    @Override
    public RequestBody convert(T value) throws IOException {

        Buffer buffer = new Buffer();

        try {
            OutputStreamWriter osw = new OutputStreamWriter(buffer.outputStream(), CHARSET);
            xStream.toXML(value, osw);
            osw.flush();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

        return RequestBody.create(MEDIA_TYPE, buffer.readByteString());
    }
}

Tak więc w tym punkcie możemy wysyłać i odbierać dowolne pliki XML. Potrzebujemy tylko utworzyć adnotacje XStream dla encji.

Następnie utwórz instancję Retrofit:

XStream xs = new XStream(new DomDriver());
xs.autodetectAnnotations(true);

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("http://example.com/")
    .addConverterFactory(XStreamXmlConverterFactory.create(xs))
    .client(client)
    .build();

Proste żądanie POST z GSON

Przykładowy JSON:

{ 
    "id": "12345",
    "type": "android"
}

Zdefiniuj swoją prośbę:

public class GetDeviceRequest {

    @SerializedName("deviceId")
    private String mDeviceId;

    public GetDeviceRequest(String deviceId) {
        this.mDeviceId = deviceId;
    }

    public String getDeviceId() {
        return mDeviceId;
    }

}

Zdefiniuj swoją usługę (punkty końcowe do trafienia):

public interface Service {

    @POST("device")
    Call<Device> getDevice(@Body GetDeviceRequest getDeviceRequest);

}

Zdefiniuj swoją pojedynczą instancję klienta sieciowego:

public class RestClient {

    private static Service REST_CLIENT;

    static {
        setupRestClient();
    }

    private static void setupRestClient() {
        
        // Define gson 
        Gson gson = new Gson();

        // Define our client 
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("http://example.com/")
                .addConverterFactory(GsonConverterFactory.create(gson))
                .build();

        REST_CLIENT = retrofit.create(Service.class);
    }

    public static Retrofit getRestClient() {
        return REST_CLIENT;
    }

} 

Zdefiniuj prosty obiekt modelu dla urządzenia:

public class Device {

    @SerializedName("id")
    private String mId;

    @SerializedName("type")
    private String mType;

    public String getId() {
        return mId;
    }

    public String getType() {
        return mType;
    }

}

Zdefiniuj kontroler do obsługi żądań urządzenia

public class DeviceController {

    // Other initialization code here...

    public void getDeviceFromAPI() {

        // Define our request and enqueue 
        Call<Device> call = RestClient.getRestClient().getDevice(new GetDeviceRequest("12345"));

        // Go ahead and enqueue the request 
        call.enqueue(new Callback<Device>() {
            @Override
            public void onSuccess(Response<Device> deviceResponse) {
                // Take care of your device here 
                if (deviceResponse.isSuccess()) {
                    // Handle success
                    //delegate.passDeviceObject();
                }
            }

            @Override
            public void onFailure(Throwable t) {
                // Go ahead and handle the error here 
            } 

        });

Odczytywanie adresu URL formularza XML za pomocą Retrofit 2

Użyjemy retrofit 2 i SimpleXmlConverter, aby uzyskać dane xml z adresu URL i parsować do klasy Java.

Dodaj zależność do skryptu Gradle:

compile 'com.squareup.retrofit2:retrofit:2.1.0'
compile 'com.squareup.retrofit2:converter-simplexml:2.1.0'

Utwórz interfejs

Utwórz także opakowanie klasy xml w naszym przypadku klasa Rss

    public interface ApiDataInterface{
    
        // path to xml link on web site
    
        @GET (data/read.xml)
    
        Call<Rss> getData();

}

Funkcja odczytu XML

private void readXmlFeed() {
        try {

            // base url - url of web site
            Retrofit retrofit = new Retrofit.Builder()
                    .baseUrl(http://www.google.com/)
                    .client(new OkHttpClient())
                    .addConverterFactory(SimpleXmlConverterFactory.create())
                    .build();

            ApiDataInterface apiService = retrofit.create(ApiDataInterface.class);

            Call<Rss> call = apiService.getData();
            call.enqueue(new Callback<Rss>() {

                @Override
                public void onResponse(Call<Rss> call, Response<Rss> response) {

                    Log.e("Response success", response.message());
                    
                }

                @Override
                public void onFailure(Call<Rss> call, Throwable t) {
                    Log.e("Response fail", t.getMessage());
                }
            });

        } catch (Exception e) {
            Log.e("Exception", e.getMessage());
        }


    }

To jest przykład klasy Java z adnotacjami SimpleXML

Więcej informacji o adnotacjach SimpleXmlDocumentation

@Root (name = "rss")

public class Rss
{


    public Rss() {

    }



    public Rss(String title, String description, String link, List<Item> item, String language) {

        this.title = title;
        this.description = description;
        this.link = link;
        this.item = item;
        this.language = language;

    }

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

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

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

    @ElementList (entry="item", inline=true)
    private List<Item> item;

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