java - programacion - manual de android en pdf
Usando la modificación en Android (15)
A los principiantes les resulta un poco intimidante aprender a adaptarse. He preparado un tutorial que simplificará la curva de aprendizaje. Consulte Modificación del tutorial de Android para obtener más información.
Tengo una aplicación de Android que tiene 3 actividades:
- Una actividad de inicio de sesión
- Una actividad de tareas donde se muestran todas las tareas pertenecientes a un usuario (rellenado con un adaptador de matriz)
- Una actividad task_details que resulta de hacer clic en una tarea en la lista
Tengo que consumir REST Apis. La investigación que he hecho hasta ahora me ordena usar Retrofit. Revisé cómo usarlo y descubrí que:
- Establezca la URL base en la actividad principal (la mía es la actividad de inicio de sesión)
- Necesito crear una clase API y definir mis funciones usando anotaciones.
- Use el Adaptador de descanso de la clase en la Actividad y defina Devolución de llamada.
Si mi aplicación hubiera sido una aplicación de actividad única, habría procesado todo en mi MainActivity.java, pero no sé cómo ni dónde poner todo el código de los pasos 1, 2 y 3 para utilizar en mis 3 actividades. ¿Podría por favor? ayuda diciéndome cómo usar Retrofit en mi aplicación. Muchas gracias.
Específicamente, necesito llamadas de red para: 1. Iniciar sesión con el usuario 2. Obtener todas las tareas del usuario. Y para ambos, estaría usando una api REST dada.
Acabo de frenar este problema de una manera muy sencilla, solo necesita instalar un complemento y seguir algunos pasos para implementar la actualización en cualquiera de sus aplicaciones .:
¿Ya ha publicado respuesta: volver a instalar en Android?
Añade el plugin de Android (QAssist - Android Studio Plugin) en tu estudio de Android. ( https://github.com/sakkeerhussain/QAssist ).
Espero que esto te ayudará.
Acabo de utilizar la actualización por un par de semanas y al principio me pareció difícil de usar en mi aplicación. Me gustaría compartir con usted la forma más fácil de utilizar la actualización en su aplicación. Y luego, si ya tiene una buena comprensión de la retroadaptación, puede mejorar sus códigos (separando su interfaz de usuario de la API y usar devoluciones de llamada) y tal vez obtener algunas técnicas de la publicación anterior.
En su aplicación tiene inicio de sesión, actividad para la lista de tareas y actividad para ver tareas detalladas.
Lo primero es que necesita agregar actualizaciones en su aplicación y de 2 formas, siga la publicación de @artemis anterior.
Retrofit usa la interfaz como su API. Entonces, crea una clase de interfaz.
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
}
Crea otra clase de interfaz para guardar toda tu DIRECCIÓN BASE de tu API
public interface Constants{
public String URL = "www.yoururl.com"
}
En su actividad de inicio de sesión, cree un método para manejar la modificación
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
}
});
}
En su 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
}
});
}
En tu lista detallada
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
}
});
}
Espero que esto te ayude, aunque es la forma más simple de usar la retroadaptación.
Eche un vistazo a este excelente blog sobre el uso de Retrofit en conjunto con Otto, ambas bibliotecas son de Square.
http://www.mdswanson.com/blog/2014/04/07/durable-android-rest-clients.html
La idea básica es que mantendrá una referencia a un objeto "repositorio" en su clase de Aplicación. Este objeto tendrá métodos que se "suscribirán" para descansar solicitudes de eventos api. Cuando se recibe uno, realiza la llamada de readaptación adecuada y luego "publica" la respuesta, que luego puede ser "suscrita" por otro componente (como la actividad que realizó la solicitud).
Una vez que tenga todo esto configurado correctamente, acceder a los datos a través de su API de reposo se vuelve muy fácil. Por ejemplo, hacer una solicitud de datos sería algo como esto:
mBus.post(new GetMicropostsRequest(mUserId));
y consumir los datos se vería así:
@Subscribe
public void onGetUserProfileResponse(GetUserProfileResponse event) {
mView.setUserIcon("http://www.gravatar.com/avatar/" + event.getGravatar_id());
mView.setUserName(event.getName());
}
Se necesita un poco de esfuerzo inicial, pero al final se convierte en algo "trivial" acceder a todo lo que necesita desde nuestro back-end a través de Rest.
El uso de Retrofit es bastante simple y directo.
En primer lugar, debe agregar modificaciones a su proyecto, como ejemplo con el sistema de compilación Gradle.
compile ''com.squareup.retrofit:retrofit:1.7.1'' |
De otra forma puede descargar .jar y colocarlo en su carpeta libs.
Luego debe definir las interfaces que utilizará Retrofit para realizar llamadas a la API a sus puntos finales REST. Por ejemplo para usuarios:
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);
}
De acuerdo. Ahora que ha definido su interfaz API, puede intentar usarla.
Para comenzar, necesita crear una instancia de RestAdapter y establecer la URL base de su back-end de API. También es bastante simple:
RestAdapter restAdapter = new RestAdapter.Builder()
.setEndpoint("https://yourserveraddress.com")
.build();
YourUsersApi yourUsersApi = restAdapter.create(YourUsersApi.class);
Aquí, Retrofit leerá su información desde la interfaz y, debajo del capó, creará RestHandler de acuerdo con la metainformación que proporcionó y que en realidad realizará las solicitudes HTTP.
Luego, una vez recibida la respuesta, en el caso de json api, sus datos se transformarán en su modelo utilizando la biblioteca Gson, por lo que debe tener en cuenta que las limitaciones que están presentes en Gson están realmente presentes en Retrofit.
Para extender / anular el proceso de serialización / deserialización de sus datos de respuesta a sus modelos, es posible que desee proporcionar sus serializadores / deserializadores personalizados para la retroadaptación.
Aquí debe implementar la interfaz del convertidor e implementar 2 métodos desde Body () y toBody () .
Aquí hay un ejemplo:
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);
}
}
}
Y ahora necesita habilitar sus adaptadores personalizados, si fue necesario usando setConverter () en la construcción de RestAdapter
De acuerdo. Ahora sabe cómo puede obtener sus datos del servidor a su aplicación Android. Pero de alguna manera necesita gestionar sus datos e invocar la llamada REST en el lugar correcto. Allí sugeriría usar el servicio de Android o AsyncTask o loader o rx.java que consultaría sus datos en el hilo de fondo para no bloquear su UI.
Así que ahora puedes encontrar el lugar más apropiado para llamar
SomeUserModel yourUser = yourUsersApi.fetchUser("someUsers")
para recuperar sus datos remotos
En primer lugar, poner todo en MainActivity sería una mala práctica y terminarías con un objeto de Dios .
La documentación en el http://square.github.io/retrofit/ es fantástica, así que voy a leer su pregunta sobre cómo estructurar el proyecto. Escribí una aplicación muy pequeña para demostraciones. Carga gatos de la API de gato y debería ser bastante simple para seguir lo que está sucediendo.
Tiene un ejemplo de uso de JSON o XML para el análisis de datos del servicio. Puede encontrarlo en https://github.com/codepath/android_guides/wiki/Consuming-APIs-with-Retrofit
Espero que puedas extrapolar por qué lo he estructurado de la manera en que lo hice. Me complace responder a cualquier pregunta que tenga en los comentarios y actualizar la respuesta.
Encontré un ejemplo pequeño, pero completo y conciso en https://github.com/square/retrofit/tree/master/samples
Encuentro estos tutoriales AndroidHive , https://github.com/codepath/android_guides/wiki/Consuming-APIs-with-Retrofit útiles
Describiré brevemente lo que he aprendido.
Paso 1: Agregue estas tres dependencies to build.gradle y agregue Internet permission para 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
Agrégalos en Manifiesto
<uses-permission android:name="android.permission.INTERNET" />
Paso 2 Creae ApiClient y 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;
}
}
donde 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);
}
Y llama a este servicio como
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) {
}
});
Para obtener Raw Json String
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) {
}
});
Puede crear su objeto comercial utilizando JsonSchema2pojo simplemente pegando json. y seleccionando el tipo de fuente a JSON y el estilo de anotación a GSon
Integración simple de adaptación + okhttp usando 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);
}
Mira esta aplicación que muestra la integración de Retrofit en la API de Google Tasks.
https://github.com/sschendel/SyncManagerAndroid-DemoGoogleTasks
Hay ejemplos de Retrofit api (TaskApi) utilizados en Activity AsyncTask en MainActivity, así como ejemplos de uso dentro de Sync Adapter en segundo plano.
La estrategia del artículo publicado en la respuesta de @ nPn es probablemente una solución más elegante, pero al menos puede mirar otro ejemplo de trabajo.
Primero, agregue estas líneas al archivo 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''
Luego crea objetos en 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();
Crear una interfaz
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
);
}
Crear clases
public class summaryList {
@SerializedName("bookingSummary") @Expose private List<summaryListData> status = new ArrayList<summaryListData>();
}
public class summaryListData {
@SerializedName("date") @Expose private String date;
}
Agrega este Método a tu actividad
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) {
}
});
}
Puede intentar guardar referencias a su API dentro de su clase de aplicación. Luego puedes obtener su instancia de cualquier actividad o fragmento y obtener API de allí. Eso suena un poco raro, pero puede ser una alternativa DI simple. Y si solo almacena referencias en su clase de aplicación, no será un tipo de objeto de dios
UPD: http://square.github.io/retrofit/ - aquí hay documentación, podría ser útil
Usar RetroFit es muy fácil.
Agregue dependencia en build.gradle.
compile ''com.squareup.retrofit:retrofit:1.9.0'' compile ''com.squareup.okhttp:okhttp:2.4.0''Haz una interfaz para todos los métodos http.
Copie su salida json y cree una clase pojo para recibir json de su
respuesta, puede hacer pojo desde el sitio JsonSchema2pojo .hacer un adaptador y llamar a su método
para una demostración completa prueba este tutorial Ejemplo de actualización de Android
Desarrollar su propia biblioteca HTTP segura para interactuar con una API REST puede ser una verdadera molestia: debe manejar muchos aspectos, como realizar conexiones, almacenar en caché, reintentar solicitudes fallidas, enhebrar, analizar las respuestas, manejar errores, y mucho más. La modificación, por otro lado, es una biblioteca bien planificada, documentada y probada que le ahorrará mucho tiempo y dolores de cabeza.
compile ''com.google.code.gson: gson: 2.6.2''
compile ''com.squareup.retrofit2: retrofit: 2.1.0'' // obligatorio
compile ''com.squareup.retrofit2: converter-gson: 2.1.0'' // para la conversión de actualización
Esta funcionando
paquete 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();
}
compile ''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''
=============================================== ===
Llame a Retrofit 2 APi inside 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);
}
});
}
Código fuente https://drive.google.com/open?id=0BzBKpZ4nzNzUVFRnVVkzc0JabUU
https://drive.google.com/open?id=0BzBKpZ4nzNzUc2FBdW00WkRfWW8