Utiliser Retrofit dans Android
J'ai une application Android qui propose 3 activités:
- Une activité de connexion
- Une activité de tâches où toutes les tâches appartenant à un utilisateur sont affichées (remplies à l'aide d'un adaptateur de matrice)
- Une activité task_details qui résulte d'un clic sur une tâche de la liste
Je dois consommer REST Apis. Les recherches que j'ai effectuées jusqu'à présent m'indiquent d'utiliser Retrofit. J'ai vérifié comment l'utiliser et découvert que:
- Définir l'URL de base dans l'activité principale (Mine est l'activité de connexion)
- Je dois créer une classe d'API et définir mes fonctions à l'aide d'annotations.
- Utilisez la classe Rest Adapter dans l’activité et définissez les rappels.
Si mon application avait été une application à activité unique, j'aurais tout craqué dans mon MainActivity.Java mais je ne sais pas comment et où mettre tout le code des étapes 1, 2, 3 pour pouvoir l'utiliser dans mes 3 activités aider en expliquant comment utiliser Retrofit dans mon application. Merci beaucoup.
Plus précisément, j’ai besoin d’appels réseau pour: 1. Connectez l'utilisateur 2. Obtenez toutes les tâches de l'utilisateur. Et pour les deux, j'utiliserais une api REST donnée.
*********************************************
Calling Api USing Retrofit
*********************************************
**Dependancies** :-
implementation 'com.Android.support:recyclerview-v7:27.1.1'
implementation 'com.squareup.picasso:picasso:2.5.2'
implementation 'com.Android.support:cardview-v7:27.1.1'
enter code here
**Model**
use the Pozo class
**Api Call**
-> getLogin() // use the method
//API call for Login
private void getLogin()
{
getWindow().setFlags(WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE,
WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE);
AsyncHttpClient client = new AsyncHttpClient();
RequestParams requestParams = new RequestParams();
requestParams.put("email_id", edit_email.getText().toString());
requestParams.put("password", edit_password.getText().toString());
Log.e("", "LOGIN URL==>" + Urls.LOGIN + requestParams);
Log.d("device_token", "Device_ Token" + FirebaseInstanceId.getInstance().getToken());
client.post(Urls.LOGIN, requestParams, new JsonHttpResponseHandler() {
@Override
public void onStart() {
super.onStart();
ShowProgress();
}
@Override
public void onFinish() {
super.onFinish();
Hideprogress();
}
@Override
public void onSuccess(int statusCode, Header[] headers, JSONObject response) {
super.onSuccess(statusCode, headers, response);
Log.e("", "Login RESPONSE-" + response);
Login login = new Gson().fromJson(String.valueOf(response), Login.class);
edit_email.setText("");
edit_password.setText("");
if (login.getStatus().equals("true")) {
getWindow().clearFlags(WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE);
MDToast mdToast = MDToast.makeText(SignInActivity.this, String.valueOf("User Login Successfully!"),
MDToast.LENGTH_SHORT, MDToast.TYPE_SUCCESS);
mdToast.show();
Utils.WriteSharePrefrence(SignInActivity.this, Util_Main.Constant.EMAIL, login.getData().getEmailId());
Utils.WriteSharePrefrence(SignInActivity.this, Constant.USERID, login.getData().getId());
Utils.WriteSharePrefrence(SignInActivity.this, Constant.USERNAME, login.getData().getFirstName());
Utils.WriteSharePrefrence(SignInActivity.this, Constant.PROFILE, login.getData().getProfileImage());
hideKeyboard(SignInActivity.this);
Intent intent = new Intent(SignInActivity.this, DashboardActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
startActivity(intent);
finish();
} else {
getWindow().clearFlags(WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE);
MDToast mdToast = MDToast.makeText(SignInActivity.this, String.valueOf("Login Denied"),
MDToast.LENGTH_SHORT, MDToast.TYPE_ERROR);
mdToast.show();
}
}
@Override
public void onFailure(int statusCode, Header[] headers, String responseString, Throwable throwable) {
super.onFailure(statusCode, headers, responseString, throwable);
Log.e("", throwable.getMessage());
getWindow().clearFlags(WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE);
MDToast mdToast = MDToast.makeText(SignInActivity.this, "Something went wrong",
MDToast.LENGTH_SHORT, MDToast.TYPE_ERROR);
mdToast.show();
}
});
}
L'utilisation de Retrofit est assez simple et directe.
Tout d’abord, vous devez ajouter la modification à votre projet, par exemple avec le système de construction Gradle.
compile 'com.squareup.retrofit:retrofit:1.7.1' |
une autre façon de télécharger .jar et de le placer dans votre dossier libs.
Vous devez ensuite définir les interfaces qui seront utilisées par Retrofit pour passer des appels d’API vers vos points de terminaison REST. Par exemple pour les utilisateurs:
public interface YourUsersApi {
//You can use rx.Java for sophisticated composition of requests
@GET("/users/{user}")
public Observable<SomeUserModel> fetchUser(@Path("user") String user);
//or you can just get your model if you use json api
@GET("/users/{user}")
public SomeUserModel fetchUser(@Path("user") String user);
//or if there are some special cases you can process your response manually
@GET("/users/{user}")
public Response fetchUser(@Path("user") String user);
}
D'accord. Maintenant que vous avez défini votre interface API, vous pouvez essayer de l’utiliser.
Pour commencer, vous devez créer une instance deRestAdapteret définir l'URL de base de votre interface dorsale API. C'est aussi assez simple:
RestAdapter restAdapter = new RestAdapter.Builder()
.setEndpoint("https://yourserveraddress.com")
.build();
YourUsersApi yourUsersApi = restAdapter.create(YourUsersApi.class);
Ici Retrofit lira vos informations depuis l’interface et sous le capot créeraRestHandlerselon les méta-informations que vous avez fournies et qui exécuteront les requêtes HTTP.
Puis, sous le capot, une fois la réponse reçue, en cas d’application json api, vos données seront transformées dans votre modèle à l’aide de la bibliothèque Gson. Vous devez donc être conscient du fait que les limitations présentes dans Gson se trouvent réellement dans Retrofit.
Pour étendre/redéfinir le processus de sérialisation/désérialisation de vos données de réponse sur vos modèles, vous souhaiterez peut-être fournir à vos sérialiseurs/désérialiseurs personnalisés la mise à niveau.
Ici, vous devez implémenter l'interface Converter et implémenter 2 méthodesfromBody ()ettoBody ().
Voici un exemple:
public class SomeCustomRetrofitConverter implements Converter {
private GsonBuilder gb;
public SomeCustomRetrofitConverter() {
gb = new GsonBuilder();
//register your cursom custom type serialisers/deserialisers if needed
gb.registerTypeAdapter(SomeCutsomType.class, new SomeCutsomTypeDeserializer());
}
public static final String ENCODING = "UTF-8";
@Override
public Object fromBody(TypedInput body, Type type) throws ConversionException {
String charset = "UTF-8";
if (body.mimeType() != null) {
charset = MimeUtil.parseCharset(body.mimeType());
}
InputStreamReader isr = null;
try {
isr = new InputStreamReader(body.in(), charset);
Gson gson = gb.create();
return gson.fromJson(isr, type);
} catch (IOException e) {
throw new ConversionException(e);
} catch (JsonParseException e) {
throw new ConversionException(e);
} finally {
if (isr != null) {
try {
isr.close();
} catch (IOException ignored) {
}
}
}
}
@Override
public TypedOutput toBody(Object object) {
try {
Gson gson = gb.create();
return new JsonTypedOutput(gson.toJson(object).getBytes(ENCODING), ENCODING);
} catch (UnsupportedEncodingException e) {
throw new AssertionError(e);
}
}
private static class JsonTypedOutput implements TypedOutput {
private final byte[] jsonBytes;
private final String mimeType;
JsonTypedOutput(byte[] jsonBytes, String encode) {
this.jsonBytes = jsonBytes;
this.mimeType = "application/json; charset=" + encode;
}
@Override
public String fileName() {
return null;
}
@Override
public String mimeType() {
return mimeType;
}
@Override
public long length() {
return jsonBytes.length;
}
@Override
public void writeTo(OutputStream out) throws IOException {
out.write(jsonBytes);
}
}
}
Et maintenant, vous devez activer vos adaptateurs personnalisés, si nécessaire en utilisantsetConverter ()sur la construction de RestAdapter.
D'accord. Vous savez maintenant comment vous pouvez obtenir vos données du serveur sur votre application Android. Mais vous avez besoin d’une manière ou d’une autre de gérer vos données et d’appeler REST appelez au bon endroit. Là, je suggérerais d’utiliser Android Service ou AsyncTask ou un chargeur ou rx.Java qui interrogerait vos données sur le fil d’arrière-plan afin de ne pas bloquer votre interface utilisateur.
Alors maintenant, vous pouvez trouver l'endroit le plus approprié pour appeler
SomeUserModel yourUser = yourUsersApi.fetchUser("someUsers")
pour récupérer vos données distantes.
Je viens d'utiliser la rénovation depuis quelques semaines et au début, j'ai eu du mal à l'utiliser dans mon application. Je voudrais partager avec vous la manière la plus simple d’utiliser la mise à niveau dans votre application. Et plus tard, si vous avez déjà une bonne connaissance de la mise à niveau, vous pouvez améliorer vos codes (en séparant votre interface utilisateur de l’API et en utilisant des rappels) et peut-être même utiliser certaines techniques du message ci-dessus.
Dans votre application, vous disposez d'une connexion, d'une activité pour la liste des tâches et d'une activité pour afficher la tâche détaillée.
La première chose à faire est d’ajouter la mise à niveau dans votre application. Pour cela, suivez le post @artemis ci-dessus.
Retrofit utilise l'interface comme API. Alors, créez une classe d'interface.
public interface MyApi{
/*LOGIN*/
@GET("/api_reciever/login") //your login function in your api
public void login(@Query("username") String username,@Query("password") String password,Callback<String> calback); //this is for your login, and you can used String as response or you can use a POJO, retrofit is very rubust to convert JSON to POJO
/*GET LIST*/
@GET("/api_reciever/getlist") //a function in your api to get all the list
public void getTaskList(@Query("user_uuid") String user_uuid,Callback<ArrayList<Task>> callback); //this is an example of response POJO - make sure your variable name is the same with your json tagging
/*GET LIST*/
@GET("/api_reciever/getlistdetails") //a function in your api to get all the list
public void getTaskDetail(@Query("task_uuid") String task_uuid,Callback<Task> callback); //this is an example of response POJO - make sure your variable name is the same with your json tagging
}
Créez une autre classe d’interface pour contenir toute votre adresse de base de votre api
public interface Constants{
public String URL = "www.yoururl.com"
}
Dans votre activité de connexion, créez une méthode pour gérer la modification.
private void myLogin(String username,String password){
RestAdapter restAdapter = new RestAdapter.Builder()
.setEndpoint(Constants.URL) //call your base url
.build();
MyApi mylogin = restAdapter.create(MyApi.class); //this is how retrofit create your api
mylogin.login(username,password,new Callback<String>() {
@Override
public void success(String s, Response response) {
//process your response if login successfull you can call Intent and launch your main activity
}
@Override
public void failure(RetrofitError retrofitError) {
retrofitError.printStackTrace(); //to see if you have errors
}
});
}
Dans votre MainActivityList
private void myList(String user_uuid){
RestAdapter restAdapter = new RestAdapter.Builder()
.setEndpoint(Constants.URL) //call your base url
.build();
MyApi mytask = restAdapter.create(MyApi.class); //this is how retrofit create your api
mytask.getTaskDetail(user_uuid,new Callback<Task>>() {
@Override
public void success(ArrayList<Task> list, Response response) {
//process your response if successful load the list in your listview adapter
}
@Override
public void failure(RetrofitError retrofitError) {
retrofitError.printStackTrace(); //to see if you have errors
}
});
}
Dans votre liste détaillée
private void myDetailed(String task_uuid){
RestAdapter restAdapter = new RestAdapter.Builder()
.setEndpoint(Constants.URL) //call your base url
.build();
MyApi mytask = restAdapter.create(MyApi.class); //this is how retrofit create your api
mytask.getTaskList(task_uuid,new Callback<Task>() {
@Override
public void success(Task task, Response response) {
//process your response if successful do what you want in your task
}
@Override
public void failure(RetrofitError retrofitError) {
retrofitError.printStackTrace(); //to see if you have errors
}
});
}
J'espère que cela vous aidera, bien que ce soit vraiment le moyen le plus simple d'utiliser la modernisation.
Jetez un coup d’œil à cet excellent blog sur l’utilisation de Retrofit avec Otto, les deux bibliothèques proviennent de Square.
http://www.mdswanson.com/blog/2014/04/07/durable-Android-rest-clients.html
L'idée de base est que vous détenez une référence à un objet "référentiel" dans votre classe Application. Cet objet aura des méthodes qui "s'abonnent" pour laisser reposer les demandes d'événements api. Lorsqu’il en reçoit un, il passe le bon appel Retrofit, puis "poste" la réponse, qui peut ensuite être "souscrite" à un autre composant (tel que l’activité ayant formulé la demande).
Une fois que tout est correctement configuré, accéder aux données via votre api de repos devient très facile. Par exemple, faire une demande de données ressemblerait à ceci:
mBus.post(new GetMicropostsRequest(mUserId));
et consommer les données ressemblerait à ceci:
@Subscribe
public void onGetUserProfileResponse(GetUserProfileResponse event) {
mView.setUserIcon("http://www.gravatar.com/avatar/" + event.getGravatar_id());
mView.setUserName(event.getName());
}
Il faut un peu d’effort immédiat, mais au final, il devient "trivial" d’accéder à tout ce dont vous avez besoin depuis notre backend via Rest.
Utiliser RetroFit est très facile.
Ajouter une dépendance dans build.gradle.
compile 'com.squareup.retrofit:retrofit:1.9.0' compile 'com.squareup.okhttp:okhttp:2.4.0'Créez une interface pour toutes les méthodes http.
Copiez votre sortie json et créez une classe pojo pour recevoir json de votre
réponse, vous pouvez faire pojo à partir de JsonSchema2pojo site.faire un adaptateur et appelez votre méthode
pour une démo complète, essayez ce tutoriel Exemple de conversion Android
Vous pouvez essayer d’enregistrer des références à votre API dans votre classe d’application. Ensuite, vous pouvez obtenir son instance à partir de n'importe quelle activité ou fragment et obtenir une api à partir de là. Cela semble un peu bizarre, mais il s’agit peut-être d’une simple alternative au DI. Et si vous ne stockez que des références dans votre classe d'applications, il ne s'agira pas d'une sorte d'objet divin.
UPD: http://square.github.io/retrofit/ - voici de la documentation, elle pourrait être utile
Tout d'abord, tout mettre dans MainActivity serait une mauvaise pratique et vous aboutiriez à un objet God .
La documentation sur le site Retrofit est fantastique. Je vais donc lire votre question sur la structure du projet. J'ai écrit une très petite application à des fins de démonstration. Il charge les chats à partir de l’API de chat et devrait être assez simple pour suivre ce qui se passe.
Il présente un exemple d'utilisation de JSON ou XML pour l'analyse de données du service. Vous pouvez le trouver sur https://github.com/codepath/Android_guides/wiki/Consuming-APIs-with-Retrofit
J'espère que vous pourrez extrapoler pourquoi je l'ai structuré comme je l'ai fait. Je serai ravi de répondre à vos questions et de mettre à jour votre réponse.
Découvrez cette application qui illustre l'intégration de Retrofit à l'API Google Tasks.
https://github.com/sschendel/SyncManagerAndroid-DemoGoogleTasks
Il existe des exemples d'api de modification (TaskApi) utilisés dans Activity AsyncTask dans MainActivity, ainsi que des exemples d'utilisation dans Sync Adapter dans le service en arrière-plan.
La stratégie de l'article publié dans la réponse de @ nPn est probablement une solution plus élégante, mais vous pouvez au moins regarder un autre exemple de travail.
Je trouve ces tutoriels AndroidHive , CodePath utile
Je vais décrire brièvement ce que j'ai appris.
Étape 1: Ajoutez ces trois dependencies to build.gradle et ajoutez Internet permission à Manifest
compile 'com.google.code.gson:gson:2.6.2' // for string to class conversion. Not Compulsory
compile 'com.squareup.retrofit2:retrofit:2.1.0'// compulsory
compile 'com.squareup.retrofit2:converter-gson:2.1.0' //for retrofit conversion
Ajoutez-les au manifeste
<uses-permission Android:name="Android.permission.INTERNET" />
Étape 2 Creae ApiClient et ApiInterface.
public class ApiClient {
public static final String BASE_URL = "http://yourwebsite/services/";
private static Retrofit retrofit = null;
public static Retrofit getClient() {
if (retrofit==null) {
retrofit = new Retrofit.Builder()
.baseUrl(BASE_URL)
.addConverterFactory(GsonConverterFactory.create())
.build();
}
return retrofit;
}
}
où ApiInterface.class
public interface ApiInterface {
// getting same data in three different ways.
@GET("GetCompanyDetailByID")
Call<CompanyResponse> getDetailOfComapanies(@Query("CompanyID") int companyID);
@GET("GetCompanyDetailByID")
Call<ResponseBody> getRawDetailOfCompanies(@Query("CompanyID") int companyID);
@GET("{pathToAdd}")
Call<CompanyResponse> getDetailOfComapaniesWithPath(@Path("pathToAdd") String pathToAppend, @Query("CompanyID") int companyID);
}
Et appelez ce service comme
ApiInterface apiService =
ApiClient.getClient().create(ApiInterface.class);
Call<CompanyResponse> companyResponseCall = apiService.getDetailOfComapanies(2);
//Call<CompanyResponse> companyResponseCall = apiService.getDetailOfComapaniesWithPath("GetCompanyDetailByID",2);
companyResponseCall.enqueue(new Callback<CompanyResponse>() {
@Override
public void onResponse(Call<CompanyResponse> call, Response<CompanyResponse> response) {
CompanyResponse comapnyResponse = response.body();
Boolean status = comapnyResponse.getStatus();
}
@Override
public void onFailure(Call<CompanyResponse> call, Throwable t) {
}
});
Pour obtenir une chaîne Json brute
Call<ResponseBody> call = apiService.getRawDetailOfCompanies(2);
call.enqueue(new Callback<ResponseBody>() {
@Override
public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) {
String jsonStr = response.body().string();
if(!jsonStr.isEmpty()){
Gson gson = new Gson();
JSONObject jObject = new JSONObject(jsonStr).getJSONObject("data");
//1st Method
Data dataKiType = gson.fromJson(jObject.toString(), Data.class);
dataKiType.getCompanyDetail();
//2nd method for creaing class or List at runTime
Type listType = new TypeToken<Data>(){}.getType();
Data yourClassList = new Gson().fromJson(jObject.toString(), listType);
yourClassList.getCompanyDetail();
} e.printStackTrace();
}
}
@Override
public void onFailure(Call<ResponseBody> call, Throwable t) {
}
});
Vous pouvez créer votre objet métier à l'aide de http://www.jsonschema2pojo.org/ en collant simplement json. et en sélectionnant le type de source en JSON et le style d'annotation en GSon
Vous trouverez un exemple concis, mais complet et concis, dans https://github.com/square/retrofit/tree/master/samples
Les débutants trouvent peu intimidant d’apprendre à rénover. J'ai préparé un tutoriel qui simplifiera la courbe d'apprentissage. Voir Didacticiel Retrofit Android pour plus d'informations.
D'abord, ajoutez ces lignes au fichier gradle
compile 'com.squareup.retrofit2:retrofit:2.1.0'
compile 'com.squareup.retrofit2:converter-gson:2.1.0'
compile 'com.google.code.gson:gson:2.7'
compile 'com.squareup:otto:1.3.8'
compile 'com.squareup.okhttp3:logging-interceptor:3.4.1'
Puis créez des objets dans OnCreate of Activity
HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
OkHttpClient client= new OkHttpClient
.Builder()
.connectTimeout(30, TimeUnit.SECONDS)
.readTimeout(30, TimeUnit.SECONDS)
.addInterceptor(interceptor).build();
Gson gson=new GsonBuilder()
.setDateFormat("yyyy-MM-dd'T'HH:mm:ssZ")
.create();
Retrofit retrofit= new Retrofit.Builder()
.baseUrl("url")
.client(client)
.addConverterFactory(GsonConverterFactory.create(gson))
.build();
Créer une iterface
public interface summaryListAPI {
//post
@FormUrlEncoded
@POST("index.php")
Call<summaryList> post(
@Field("status") String status,
@Field("sox") String sox
);
//get
@GET("yesbdeChatHistoryList/{userId}/")
Call<List<ChatTabTwoResp>> getFriends(
@Path("userId") int userId
);
}
Créer des cours
public class summaryList {
@SerializedName("bookingSummary") @Expose private List<summaryListData> status = new ArrayList<summaryListData>();
}
public class summaryListData {
@SerializedName("date") @Expose private String date;
}
Ajouter cette méthode à votre activité
public void apiSummaryListMain(final Retrofit retrofit) {
retrofit.create(summaryListAPI.class).post("8547861657","100").enqueue(new Callback<summaryList>() {
@Override
public void onResponse(Call<summaryList> call, Response<summaryList> response) {
if (response.isSuccessful()) {
progressBar.setVisibility(View.INVISIBLE);
List<summaryListData> summary_List= response.body().getStatus();
}else{
}
}
@Override
public void onFailure(Call<summaryList> call, Throwable t) {
}
});
}
Développer votre propre bibliothèque HTTP sécurisée pour l'interface avec une API REST peut être un réel problème: vous devez gérer de nombreux aspects, tels que l'établissement de connexions, la mise en cache, le réessayage de demandes échouées, le threading, l'analyse syntaxique des réponses, les erreurs manipulation, et plus encore. Retrofit, en revanche, est une bibliothèque bien planifiée, documentée et testée qui vous fera économiser beaucoup de temps précieux et de maux de tête.
compiler 'com.google.code.gson: gson: 2.6.2'
compile 'com.squareup.retrofit2: retrofit: 2.1.0' // obligatoire
compile 'com.squareup.retrofit2: converter-gson: 2.1.0' // pour la conversion ultérieure
Intégration simple de rattrapage + okhttp avec RxJava
public WebService apiService(Context context) {
String mBaseUrl = context.getString(BuildConfig.DEBUG ? R.string.local_url : R.string.live_url);
int cacheSize = 5 * 1024 * 1024; // 5 MB
Cache cache = new Cache(context.getCacheDir(), cacheSize);
HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
loggingInterceptor.setLevel(BuildConfig.DEBUG ? HttpLoggingInterceptor.Level.BODY : HttpLoggingInterceptor.Level.NONE);
OkHttpClient okHttpClient = new OkHttpClient.Builder()
.readTimeout(120, TimeUnit.SECONDS)
.writeTimeout(120, TimeUnit.SECONDS)
.connectTimeout(120, TimeUnit.SECONDS)
.addInterceptor(loggingInterceptor)
//.addNetworkInterceptor(networkInterceptor)
.cache(cache)
.build();
return new Retrofit.Builder().baseUrl(mBaseUrl)
.client(okHttpClient)
.addConverterFactory(GsonConverterFactory.create())
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.build().create(WebService.class);
}
Ça marche
package com.keshav.gmailretrofitexampleworking.network;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;
public class ApiClient {
public static final String BASE_URL = "http://api.androidhive.info/json/";
private static Retrofit retrofit = null;
public static Retrofit getClient() {
if (retrofit == null) {
retrofit = new Retrofit.Builder()
.baseUrl(BASE_URL)
.addConverterFactory(GsonConverterFactory.create())
.build();
}
return retrofit;
}
}
==============================================
package com.keshav.gmailretrofitexampleworking.network;
import com.keshav.gmailretrofitexampleworking.models.Message;
import Java.util.List;
import retrofit2.Call;
import retrofit2.http.GET;
public interface ApiInterface {
@GET("inbox.json")
Call<List<Message>> getInbox();
}
compiler 'com.google.code.gson: gson: 2.6.2'
compile 'com.squareup.retrofit2:retrofit:2.0.2'
compile 'com.squareup.retrofit2:converter-gson:2.0.2'
=============================================== ===
Appelez Retrofit 2 APi dans onCreate
private void getInbox() {
swipeRefreshLayout.setRefreshing(true);
ApiInterface apiService =
ApiClient.getClient().create(ApiInterface.class);
Call<List<Message>> call = apiService.getInbox();
call.enqueue(new Callback<List<Message>>() {
@Override
public void onResponse(Call<List<Message>> call, Response<List<Message>> response) {
// clear the inbox
messages.clear();
// add all the messages
// messages.addAll(response.body());
// TODO - avoid looping
// the loop was performed to add colors to each message
Log.e("keshav","response" +response.body());
for (Message message : response.body()) {
// generate a random color
// TODO keshav Generate Random Color Here
message.setColor(getRandomMaterialColor("400"));
messages.add(message);
}
mAdapter.notifyDataSetChanged();
swipeRefreshLayout.setRefreshing(false);
}
@Override
public void onFailure(Call<List<Message>> call, Throwable t) {
Toast.makeText(getApplicationContext(), "Unable to fetch json: " + t.getMessage(), Toast.LENGTH_LONG).show();
swipeRefreshLayout.setRefreshing(false);
}
});
}
Code source https://drive.google.com/open?id=0BzBKpZ4nzNzUVFRnVVzz0JabUU
https://drive.google.com/open?id=0BzBKpZ4nzNzUc2FBdW00WkRfWW8
Je viens de freiner ce problème très facilement. Vous devez simplement installer un plugin et suivre certaines étapes pour implémenter la mise à niveau dans n'importe laquelle de vos applications.
Déjà posté réponse: Retrofit dans Android?
Ajoutez (QAssist - Android Studio Plugin) un plugin Android dans votre studio Android. ( https://github.com/sakkeerhussain/QAssist ).
J'espère que ceci vous aidera.