sitio - guardar ubicacion en google maps android

La tarea asíncrona Android google maps agrega marcadores

Question

Tengo un mapa Tengo una base de datos de puntos. Quiero mostrar los puntos de la base de datos en AsyncTask, para que el usuario pueda moverse por el mapa cuando se carguen los puntos. No hay muchos puntos (como 353 o etc.), pero los vuelvo a dibujar cuando el usuario se acerca (acerca al zoom) al mapa con marcadores más grandes. Cuando se produce este redibujado, la aplicación se congela por una fracción de segundo, pero es notable, así que pensé que AsyncTask sería la respuesta.

Sin embargo, no está funcionando. Y es extraño. Encontré algunas preguntas aquí, pero el problema no era llamar al método "publishProgress ()", que no es mi caso.

En el método "doInBackground ()" abro la base de datos, hago la consulta y la guardo en un Cursor (que es un atributo de mi clase ShowPoints, que extiende AsyncTask, por lo que debería ser accesible por todos los métodos de esta clase // al menos Creo que). Luego paso por el cursor y cada vez llamo "publishProgress ()" que debería llamar "onProgressUpdate ()" y aquí creo el marcador usando mi cursor desde "doInBackgroud ()".

Es extraño que si depuro, y paso por el código paso a paso, todo funcione como debería. Pero cuando ejecuto la aplicación, no se agregan marcadores o solo algunos de ellos.

private class ShowPoints extends AsyncTask<String, Integer, String> {
private String resp="Body načteny";
private Cursor c_body;
private LatLng marker_pozice;
@Override
protected String doInBackground(String... params) {
int i=0;
try {
DatabaseHelper db = new DatabaseHelper(MainActivity.this);
try {
db.openDataBase();
}catch(SQLException sqle){
throw sqle;
}
c_body = db.query(DatabaseHelper.TABLE_POINTS, allColumns, null, null, null,null, null);
if(c_body.moveToFirst())
{
if(params[0]=="small"){
do {
i++;
int ikona = R.drawable.gray_dot;
int trasa = c_body.getInt(6);
switch(trasa){
case 1: ikona = R.drawable.color_00a750_dot;
break;
case 2: ikona = R.drawable.color_ec1c24_dot;
break;
case 3: ikona = R.drawable.color_ffca05_dot;
break;
case 4: ikona = R.drawable.color_6dcef5_dot;
break;
case 5: ikona = R.drawable.color_f497b0_dot;
break;
case 6: ikona = R.drawable.color_0088cf_dot;
break;
case 7: ikona = R.drawable.color_98d3bf_dot;
break;
case 8: ikona = R.drawable.color_c3792f_dot;
break;
case 9: ikona = R.drawable.color_c5168c_dot;
break;
}
publishProgress(ikona);
Log.i("Thread",String.valueOf(i));
} while (c_body.moveToNext());
}else{
do {
i++;
int ikona = R.drawable.bigg_dot;
int trasa = c_body.getInt(6);
switch(trasa){
case 1: ikona = R.drawable.biggr_00a750_dot;
break;
case 2: ikona = R.drawable.biggr_ec1c24_dot;
break;
case 3: ikona = R.drawable.biggr_ffca05_dot;
break;
case 4: ikona = R.drawable.biggr_6dcef5_dot;
break;
case 5: ikona = R.drawable.biggr_f497b0_dot;
break;
case 6: ikona = R.drawable.biggr_0088cf_dot;
break;
case 7: ikona = R.drawable.biggr_98d3bf_dot;
break;
case 8: ikona = R.drawable.biggr_c3792f_dot;
break;
case 9: ikona = R.drawable.biggr_c5168c_dot;
break;
}
Log.i("Thread",String.valueOf(i));
publishProgress(ikona);
} while (c_body.moveToNext());
}
}
db.close();
} catch (Exception e) {
e.printStackTrace();
resp = e.getMessage();
}
return resp;
}
@Override
protected void onProgressUpdate(Integer... ikona) {
marker_pozice = new LatLng(c_body.getDouble(3), c_body.getDouble(4));
mMap.addMarker(new MarkerOptions()
.position(marker_pozice)
.title(c_body.getString(2))
.snippet(c_body.getString(7)+"/n"+c_body.getString(1))
.icon(BitmapDescriptorFactory.fromResource(ikona[0])));
}
// progress. For example updating ProgessDialog
}

Lo llamo en el método onCreate:

ShowPoints pointShower = new ShowPoints();
pointShower.execute("small");

También funciona el registro que estoy haciendo en "doInBackgroud ()", pero los marcadores no se agregan al mapa (o no todos ellos ... a veces se dibujan 3, a veces 19, etc.).

mMap es accesible, porque esta clase está dentro de otra clase, donde el mapa es un atributo y se crea una instancia antes de que se llame a Async. También como estoy diciendo, en el debuger paso a paso puedo dibujar todos los puntos.

También en "onPostExecute ()" Tengo un brindis, que se muestra cuando lance la aplicación, por lo que no hay dudas de que finaliza la sincronización (el inicio de sesión funciona, se llama al método final).

Answer 1

Hago esto creando una lista de MarkerOptions en la asynctask y luego en onPostExecute. Los agrego al mapa en un bucle. En realidad, tengo dos tareas que se ejecutan sincrónicamente. Tarea1 configura la lista de marcas y cuando termina la tarea 2 comienza y obtiene / descarga cualquier icono asociado con el marcador. Hago las descargas al final porque es probable que reutilices los marcadores y puedes usar un hash para obtener un marcador previamente descargado. Probablemente solo estarías usando la 2da tarea asíncrona que recibe los íconos del marcador, así como pequeño favor. He incluido la clase que uso para obtener los mapas de bits para los marcadores.

Aquí hay una clase personalizada para manejar el crp.

package com.gosylvester.bestrides.beans;
import com.google.android.gms.maps.model.MarkerOptions;
public class KmlMarkerOptions {
public MarkerOptions markeroptions;
public String href;
public int hrefhash =-1;
}

esta es la segunda tarea de sincronización que carga los mapas de bits para los marcadores.

private class LoadMarkerBitmapDescriptor extends
AsyncTask<List<KmlMarkerOptions>, Void, Boolean> {
@Override
protected Boolean doInBackground(List<KmlMarkerOptions>... params) {
Boolean ret = true;
List<KmlMarkerOptions> kmlmarkeroptions = params[0];
int markerSize = kmlmarkeroptions.size();
for (int currentMarkerPosition = 0; currentMarkerPosition < markerSize; currentMarkerPosition++) {
KmlMarkerOptions currentMarkerOptions = kmlmarkeroptions
.get(currentMarkerPosition);
int hrefhash = currentMarkerOptions.hrefhash;
if (hrefhash != -1) {
// not the poistion zero marker
if (currentMarkerPosition != 0) {
// search for an existing bitmap descriptor
for (int previousMarkerPosition = 0; previousMarkerPosition < currentMarkerPosition; previousMarkerPosition++) {
KmlMarkerOptions previousMarkerOptions = kmlmarkeroptions
.get(previousMarkerPosition);
if (previousMarkerOptions.hrefhash == hrefhash) {
currentMarkerOptions.markeroptions
.icon(previousMarkerOptions.markeroptions
.getIcon());
break;
}
}
}
if (currentMarkerOptions.markeroptions.getIcon() == null) {
try {
InputStream is = (InputStream) new URL(
currentMarkerOptions.href).getContent();
Bitmap bm = (Bitmap) BitmapFactory.decodeStream(is);
currentMarkerOptions.markeroptions
.icon((BitmapDescriptor) BitmapDescriptorFactory
.fromBitmap(bm));
} catch (Exception e1) {
e1.printStackTrace();
ret = false;
}
}
}
}
return ret;
}
protected void onPostExecute(Boolean result) {
addIcontoMap();
}
protected void addIcontoMap() {
for (KmlMarkerOptions kmlmo : mKmlmo) {
mMap.addMarker(kmlmo.markeroptions);
}
}

Answer 2

Si bien sus intenciones aquí son buenas, simplemente no veo mucho beneficio porque todavía está llamando al hilo de la interfaz de usuario para cada elemento y apuesto a que no verá mucha diferencia en el rendimiento. Una vez dicho esto, estoy dispuesto a apostar que tu problema es que estás sosteniendo el cursor y lo onProgressUpdate utilizando en el onProgressUpdate mientras tu doInBackground continúa moviendo el cursor a la siguiente fila. Lo cual explicaría por qué cuando depuras funciona correctamente porque estás dando un paso adelante.

Lo que recomendaría para aumentar el rendimiento sería crear en doInBackground una lista de algún objeto que contenga toda la información sobre el objeto del mapa (icono, posición, etc.). Solo agregue los marcadores al mapa donde se encuentran en el cuadro delimitador visible del mapa para que no esté trazando marcadores que ni siquiera son visibles. luego en su onPostExecute use esa lista y trace todo allí.

Aunque no sé con seguridad si esta es la causa del problema, pero podría ser el problema