In class. DataAuth Field private List<InfoClient> infoClients should be a regular object, that is, private InfoClient infoClients

Server sends JSONObject in which JSONArray, and you're trying to s as JSONArray. Must be like this:public class GroupList { ArrayList<Group> group; //setters, getters } public class Group { private String name; private String description; ... }

Added the Users class: public class Users { @SerializedName("user") List&lt;User&gt; user; //getters and setters } Changed the code in the API interface:@GET("users") Observable<Users> users(@Header("Authorization") String auth, @Header("Content-type") String contentType, @Header("Accept") String accept); After that, it worked.

Try it.public class User { @SerializedName("properties") private Properties properties; ... } public class Properties { @SerializedName("property") private Property property; ... } public class Property { @SerializedName("@key") private String key; @SerializedName("@value") private String value; ... }

It's called panic. Reference https://guides.codepath.com/android/Endless-Scrolling-with-AdapterViews-and-RecyclerView for implementation.

Don't forget the authorisation.@PUT("{username}") Observable<Response<Void>> updateUser(@Path("username") String username, @Body User user, @Header("Authorization") String auth); andprivate void updateUserInfo() { User user = new User("iryna", "Alala", "alala@gmail.com", "some properties" ); yourService.updateUser("bala", user ...) .(...) .subscribe(response -> { // use response.code, response.headers, etc. }, throwable -> { // handle failure }); }

The main advantage is (in fact, like any other library) that, in order to obtain the desired result, you can use the methods already available (from this library) rather than write your own.In general, the library &apos; s functionality is tested by many developers, and will therefore be more stable (not in general but in most) than self-written methods.I'll tell you, it's just convenient. Many of the tasks that you will face are already done for you. All you have to do is use the results.Pros (they're opportunities) to skew:Automatic conversion of JSON to facilities;There is no need to make requests for a separate flow - they are already being carried out there;Dynamic design of requests;Writing mistakes.Read more detail, for example. http://java-help.ru/retrofit-2-review/ or http://square.github.io/retrofit/ ♪But I firmly believe that before the library is used, trainingit's just necessary to invent your own bike to have a rough idea how it works inside.

What is your first copy?If basic, then use it as an example. "Basic " + Base64.encodeToString((username + ":" + password).getBytes("UTF-8"), Base64.NO_WRAP) and@GET("users") Observable<User> users(@Header("Authorization") String auth);

Judging by json YourResponse.java:public class YourResponse { private final Info info; public YourResponse(Info info) { this.info = info; } public class Info { private final boolean success; private final List<Resturant> object; public Info(boolean success, List&lt;YourObject&gt; object) { this.success = success; this.object = object; } } public class Resturant { private final String id; private final String pagetitle; private final String price; private final String titleCat; private final String map; private final String img; private final String halal; private final String isAks; private final String address; @SerializedName("work-day") private final String workDay; private final String rating; public Resturant(String id, String pagetitle, String price, String titleCat, String map, String img, String halal, String isAks, String address, String workDay, String rating) { this.id = id; this.pagetitle = pagetitle; this.price = price; this.titleCat = titleCat; this.map = map; this.img = img; this.halal = halal; this.isAks = isAks; this.address = address; this.workDay = workDay; this.rating = rating; } } } Yeah. get- for each field

Try this type of re-entry object: Response<ResponseBody> - from it, you can get the server's answer in the form of a line:String body = response.body().string(); Next, you'll only have to take any of the JSON'er and get what you need.

We could add a heder to the method. @GET() @Headers("@:auth") Call<String> login(String login, String pass); After that, interceptor Interceptor headerInterceptor = chain -> { Request original = chain.request(); Request.Builder builder = original.newBuilder(); List&lt;String&gt; annotations = original.headers().values("@"); if (annotations.contains("auth")) { //Добавить хэдеры нужные } //Удалить ненужный builder.removeHeader("@"); return chain.proceed(builder.build()); };

You want to transfer POST or GET? If POSTinstead @Query You should use it. @RequestBody♪ If still GETIf you'd like to put it in your face,It can be made as follows:RequestBody body = new FormBody.Builder() .add("email", email) .add("fullname", fullname) .add("password", password) .build();

variable annotated @Query is automatically inserted into the final reference, need not be written &email={email} etc.

Write your class. App Manifest:<application android:name=".App" ... </application>

You don't have one parameter to challenge the method. You've declared a method like void uploadVideo(@Path("id") String id, Callback<VideoUpload> callback); You're trying to make a call. uploadVideo(new Callback<VideoUpload>()); Don't. String id♪ Callback<VideoUpload> callback

Sort of. Fragment RecyclerView. You get the data from OkHtp or Retrofit on the basis of what's more comfortable. The data will most likely be in JSON, available in XML, but JSON will be forgiven.Values can be obtained through OkHttpIt's possible. Retrofit (laughs) OkHttp use it. The question is how API is written. If you have a fashionable one there. REST - without Retrofit. If you're bluntly running data down there, it's easier. OkHttp♪ Both have a synchronized type of request and an asynchronous one. There's no difference in the asynchrone. And there, and there's two collbacks for the successful outcome of the request and the prom.Basic data are most likely to come JsonArray♪ If you don't want to have noodles, it's best to turn them straight. ArrayList<YourObjectType>♪ It's easier to do through. GSON library. She's actually used in default. Retrofit♪ You can always do the same. OkHttp♪ You can evaporate standard tools, be a little longer, the result will be the same.Received ArrayList<YourObjectType> Transfer's to the caste aptter RecyclerViewcreating ViewHolder And that's all. http://www.androidhive.info/2016/01/android-working-with-recycler-view/ http://www.vogella.com/tutorials/JavaLibrary-OkHttp/article.html http://www.androidhive.info/2016/05/android-working-with-retrofit-http-library/ And now the most interesting thing. It's worth deciding how the app should know you've got some news. Options 3:(1) The user opens the application - the data are downloaded from the server post.(2) The application has a service that periodically receives data from the server post. Recurrently, either at some specific time or at some point in time. Plus, before the first option, you can throw a Push notice.(3) The application has a service that the skate receives the news. Pros are instant. Minus-- you're gonna have to create a server that's gonna get the data from the website and sew them to all clients involved. And from the minus, it's a hell of a user battery charge.Update Of all the options, I recommend that the first option be made, it still needs it, and it will still be useful. It'll always be good to have the service.Another important thing that has not been taken into account is the need for use. SQLite database to keep the news already open. Otherwise, without the Internet, the application would be completely useless. http://www.vogella.com/tutorials/AndroidServices/article.html http://developer.alexanderklimov.ru/android/sqlite/android-sqlite.php

In order to eliminate the request, try to:public class CancellableCallback<T> implements Callback<T> { private Callback<T> callback; private boolean canceled; private CancellableCallback() {} public CancellableCallback(Callback<T> callback) { this.callback = callback; canceled = false; } public void cancel() { canceled = true; callback = null; } @Override public void success(T o, Response response) { if (!canceled) { callback.success(o, response); } } @Override public void failure(RetrofitError error) { if (!canceled) { callback.failure(error); } } Now you're changing your code to something like that:CancellableCallback callback = new Callback<ImageUpload>() { @Override public void success(final ImageUpload imageUpload, Response response) { mRecyclerView.post(new Runnable() { @Override public void run() { ... }); } @Override public void failure(RetrofitError error) { } }; service.upload1(file1, str, stringMap, callback); And then you sign off the waiver somehow.if (condition && callback != null) { callback.cancel(); }

I don't think so.Such behaviour can be carried out with help. https://static.javadoc.io/com.google.code.gson/gson/2.6.2/com/google/gson/JsonDeserializer.html private class AccidentDamageDeserializer implements JsonDeserializer<AccidentDamage> { @Override public AccidentDamage deserialize(JsonElement json, Type type, JsonDeserializationContext context) throws JsonParseException { String damage = json.getAsString(); switch(damage){ case "1" : return AccidentDamage.WITHOUT; case "2" : return AccidentDamage.LIGHT; case "3" : return AccidentDamage.HEAVY; case "4" : return AccidentDamage.LETHAL; default : return AccidentDamage.UNKNOWN; } } Use it.GsonBuilder gsonBuilder = new GsonBuilder(); gsonBuilder.registerTypeAdapter(AccidentDamage.class, new AccidentDamageDeserializer () ); Gson gson = gsonBuilder.create();

That's what just came to mind.Put an extension on java class enum-a. fun <T : Enum<*>> Class<T>.enumByCode(code: Int): T { for (value in this.enumConstants) { if (code == value.ordinal) return value } return this.enumConstants[0] } The only thing is to determine what to return as a default point. I have the highest value of every enum. One last thing. But you can do that. enum class Unknown { UNKNOWN } fun <T : Enum<*>> Class<T>.enumByCode(code: Int): T { for (value in this.enumConstants) { if (code == value.ordinal) return value } return Unknown.UNKNOWN as T }

It's done over the cycle for. We need to run through the elements of the mass and choose the meaning you need.