I’ve got a problem with my map app. I’m populating the map overlays inside an asynctask. They are added to the mapview in the ui-thread.
The problem occurs when I zoom the map and add new points afterwards, which triggers the computation of these points to be displayed. I’m getting an arrayindexoutofboundsexception inside the android class method viewroot.draw whenever I execute this pattern (open map, zoom, add points).
The populating asynctask also calls populate() on my itemized_overlay implementation after adding all points. It’s doinbackground-method returns and I get the mentioned exception immediately afterwards. It doesn’t run the onpostexecution-method, which should follow. If the mapview isn’t touched, I can add as many points as I like. When the error occurs the overlay icons disappear except for their shadows before the debugger stops the application.
Thread [<1> main] (Suspended (exception ArrayIndexOutOfBoundsException))
ViewRoot.draw(boolean) line: 1457
ViewRoot.performTraversals() line: 1167
ViewRoot.handleMessage(Message) line: 1764
ViewRoot(Handler).dispatchMessage(Message) line: 99
Looper.loop() line: 143
ActivityThread.main(String[]) line: 5068
Method.invokeNative(Object, Object[], Class, Class[], Class, int, boolean) line: not available [native method]
Method.invoke(Object, Object...) line: 521
ZygoteInit$MethodAndArgsCaller.run() line: 858
ZygoteInit.main(String[]) line: 616
NativeStart.main(String[]) line: not available [native method]
Any ideas?
Edit: added code
the asynctask:
package de.***.android.memo_neu;
import java.util.HashMap;
import java.util.Iterator;
import android.app.ProgressDialog;
import android.content.Context;
import android.database.Cursor;
import android.os.AsyncTask;
import android.util.Log;
import com.google.android.maps.OverlayItem;
public class PunkteZeigen_Tab_AsyncTask extends
AsyncTask<Cursor, Integer, Object> {
private PunkteZeigen_Tab_Liste context_liste;
private PunkteZeigen_Tab_Karte context_karte;
private ProgressDialog progress_fortschritt;
private int int_modus;
public static final int LISTE = 0;
public static final int KARTE = 1;
private static final int PROGRESS_SET_MIN = 0;
private static final int PROGRESS_UPDATE = 1;
private static final int PROGRESS_SET_MAX = 2;
private static final int PROGRESS_MAX = 3;
public PunkteZeigen_Tab_AsyncTask(Object con, int int_mod) {
int_modus = int_mod;
switch (int_modus) {
case LISTE:
context_liste = (PunkteZeigen_Tab_Liste) con;
break;
case KARTE:
context_karte = (PunkteZeigen_Tab_Karte) con;
break;
default:
}
}
protected void onPreExecute() {
switch (int_modus) {
case LISTE:
progress_fortschritt = new ProgressDialog((Context) context_liste);
progress_fortschritt
.setTitle(R.string.punktezeigen_tab_liste_asynctask_progressdialog_title);
break;
case KARTE:
progress_fortschritt = new ProgressDialog((Context) context_karte);
progress_fortschritt
.setTitle(R.string.punktezeigen_tab_karte_asynctask_progressdialog_title);
break;
default:
}
progress_fortschritt.setCancelable(false);
progress_fortschritt.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
progress_fortschritt.show();
Log.d("memo_debug", "onPreExecute fertig");
}
protected void onProgressUpdate(Integer... int_progress) {
switch (int_progress[0]) {
case PROGRESS_SET_MIN:
progress_fortschritt.setProgress(int_progress[1]);
break;
case PROGRESS_UPDATE:
if (int_progress[1] >= 0) {
if ((int_progress[1] % 5) == 0) {
progress_fortschritt
.incrementProgressBy(progress_fortschritt.getMax() / 5);
}
} else {
progress_fortschritt.incrementProgressBy(-int_progress[1]);
}
break;
case PROGRESS_SET_MAX:
progress_fortschritt.setMax(int_progress[1]);
break;
case PROGRESS_MAX:
progress_fortschritt.setProgress(progress_fortschritt.getMax());
break;
default:
}
}
protected Object doInBackground(Cursor... cursor_db_anfrage) {
progress_fortschritt.setMax(cursor_db_anfrage[0].getCount());
switch (int_modus) {
case LISTE:
return listeBearbeiten(cursor_db_anfrage[0]);
case KARTE:
return karteBearbeiten(cursor_db_anfrage);
default:
return -1;
}
}
private int listeBearbeiten(Cursor cursor_db_anfrage) {
if (cursor_db_anfrage.moveToFirst()) {
GeoPunkt geopkt_geopunkt = new GeoPunkt();
HashMap<String, Object> hashmap_liste_daten_datum;
do {
// geopkt_geopunkt.id= cursor_db_anfrage.getInt(0);
geopkt_geopunkt.name = cursor_db_anfrage.getString(1);
geopkt_geopunkt.lat = cursor_db_anfrage.getInt(2);
geopkt_geopunkt.lon = cursor_db_anfrage.getInt(3);
geopkt_geopunkt.icon = cursor_db_anfrage.getInt(4);
hashmap_liste_daten_datum = new HashMap<String, Object>(2);
hashmap_liste_daten_datum.put("geopkt_name",
geopkt_geopunkt.name);
hashmap_liste_daten_datum.put("geopkt_lat_lon", "Lat:"
+ Integer.toString(geopkt_geopunkt.lat) + " " + "Lon:"
+ Integer.toString(geopkt_geopunkt.lon));
hashmap_liste_daten_datum.put("geopkt_icon",
geopkt_geopunkt.icon);
context_liste.memosingleton_anwendung.list_liste_daten
.add(hashmap_liste_daten_datum);
publishProgress(PROGRESS_UPDATE,
cursor_db_anfrage.getPosition());
} while (cursor_db_anfrage.moveToNext());
}
return cursor_db_anfrage.getCount();
}
private HashMap<Integer, ItemOverlay_neu> karteBearbeiten(
Cursor... cursor_db_anfrage) {
// cursor_db_anfrage[0] geopkt, cursor_db_anfrage[1] icon
// temporaere hashmap fuer overlays (sammlung von punkten) die der
// karte hinzugefuegt werden.
HashMap<Integer, ItemOverlay_neu> hashmap_itemoverlays_temp = new HashMap<Integer, ItemOverlay_neu>();
// falls neue punkte vorhanden sind
if (cursor_db_anfrage[0].moveToFirst()) {
ItemOverlay_neu itemoverlay_temp;
GeoPunkt geopkt_geopunkt = new GeoPunkt();
OverlayItem overlayitem_temp;
// fuer alle gefundenen symbole
if (cursor_db_anfrage[1].moveToFirst()) {
do {
// erzeuge overlay mit zugeordnetem symbol
itemoverlay_temp = new ItemOverlay_neu(context_karte
.getResources().getDrawable(
cursor_db_anfrage[1].getInt(0)),
context_karte);
// falls in der hashmap des singletons noch kein overlay mit
// diesem symbol vorhanden ist, fuege es hinzu
if (!context_karte.memosingleton_anwendung.hashmap_itemoverlays
.containsKey(cursor_db_anfrage[1].getInt(0))) {
context_karte.memosingleton_anwendung.hashmap_itemoverlays
.put(cursor_db_anfrage[1].getInt(0),
itemoverlay_temp);
}
// fuege das overlay in die temporaere hashmap ein
hashmap_itemoverlays_temp.put(
cursor_db_anfrage[1].getInt(0), itemoverlay_temp);
// hashmap aus dem singleton speichert alle overlays mit den
// entsprechenden geopunkten, temporaere hashmap speichert
// nur neue geopunkte
} while (cursor_db_anfrage[1].moveToNext());
}
Log.d("memo_debug", "erste while do fertig");
// fuer alle erfassten neuen punkte
do {
// geopkt_geopunkt.id = cursor_db_anfrage.getInt(0);
geopkt_geopunkt.name = cursor_db_anfrage[0].getString(1);
geopkt_geopunkt.lat = cursor_db_anfrage[0].getInt(2);
geopkt_geopunkt.lon = cursor_db_anfrage[0].getInt(3);
geopkt_geopunkt.icon = cursor_db_anfrage[0].getInt(4);
// erzeuge overlayitem (geopunkt mit zusaetzlichen daten) zum
// einfuegen in overlays
overlayitem_temp = new OverlayItem(
geopkt_geopunkt.getGeoPoint(), geopkt_geopunkt.name, "");
// fuege neue punkte zur singleton hashmap und zur temporaeren
// hashmap hinzu
itemoverlay_temp = context_karte.memosingleton_anwendung.hashmap_itemoverlays
.get(geopkt_geopunkt.icon);
itemoverlay_temp.addOverlay(overlayitem_temp);
itemoverlay_temp = hashmap_itemoverlays_temp
.get(geopkt_geopunkt.icon);
itemoverlay_temp.addOverlay(overlayitem_temp);
publishProgress(PROGRESS_UPDATE,
cursor_db_anfrage[0].getPosition());
} while (cursor_db_anfrage[0].moveToNext());
Log.d("memo_debug", "zweite while do fertig");
publishProgress(PROGRESS_MAX, 0);
// ruft populate() fuer die overlays auf, um sie spaeter anzeigen zu
// koennen
Iterator<ItemOverlay_neu> iterator_itemoverlays = context_karte.memosingleton_anwendung.hashmap_itemoverlays
.values().iterator();
publishProgress(PROGRESS_SET_MIN, 0);
publishProgress(PROGRESS_SET_MAX,
context_karte.memosingleton_anwendung.hashmap_itemoverlays
.size());
while (iterator_itemoverlays.hasNext()) {
iterator_itemoverlays.next().initialisieren();
publishProgress(PROGRESS_UPDATE, -1);
}
Log.d("memo_debug", "erstes populate fertig");
publishProgress(PROGRESS_MAX, 0);
iterator_itemoverlays = hashmap_itemoverlays_temp.values()
.iterator();
publishProgress(PROGRESS_SET_MIN, 0);
publishProgress(PROGRESS_SET_MAX, hashmap_itemoverlays_temp.size());
while (iterator_itemoverlays.hasNext()) {
iterator_itemoverlays.next().initialisieren();
publishProgress(PROGRESS_UPDATE, -1);
}
Log.d("memo_debug", "zweites populate fertig");
publishProgress(PROGRESS_MAX, 0);
}
Log.d("memo_debug", "karteBearbeiten fertig");
return hashmap_itemoverlays_temp;
}
protected void onPostExecute(Object obj_result) {
Log.d("memo_debug", "onPostExecute gestartet");
switch (int_modus) {
case LISTE:
context_liste.listeAnzeigen((Integer) obj_result);
break;
case KARTE:
context_karte.karteAnzeigen(
(HashMap<Integer, ItemOverlay_neu>) obj_result,
PunkteZeigen_Tab_Karte.ANZEIGEN);
break;
default:
}
progress_fortschritt.setProgress(progress_fortschritt.getMax());
progress_fortschritt.dismiss();
Log.d("memo_debug", "onPostExecute fertig");
}
}
Methods that start the asynctask and are called after it finishes:
private void dbAbfrageStarten() {
SQLiteDatabase sqldb_zugriff = sqldb_db_verwaltung
.getReadableDatabase();
// select * from tabellenname where zeit>x
Cursor cursor_db_anfrage_geopkt = sqldb_zugriff.query(
SQL_DB_Verwaltung.TABELLEN_NAME,
null,
"zeit >"
+ Long.toString(memosingleton_anwendung
.letzterDBZugriff(MemoSingleton.KARTE)), null,
null, null, null);
// select icon from tabellenname groupby icon
// erfasse symbole die den ausgelesenen punkten zugeordnet wurden
Cursor cursor_db_anfrage_icon = sqldb_zugriff.query(
SQL_DB_Verwaltung.TABELLEN_NAME,
new String[] { SQL_DB_Verwaltung.NAME_SPALTE_5 }, null, null,
SQL_DB_Verwaltung.NAME_SPALTE_5, null, null);
PunkteZeigen_Tab_AsyncTask asynctask_dbabfrage = new PunkteZeigen_Tab_AsyncTask(
this, PunkteZeigen_Tab_AsyncTask.KARTE);
asynctask_dbabfrage.execute(cursor_db_anfrage_geopkt,
cursor_db_anfrage_icon);
Log.d("memo_debug", "dbAbfrageStarten fertig");
}
public void karteAnzeigen(
HashMap<Integer, ItemOverlay_neu> hashmap_itemoverlays_temp,
int int_modus) {
Log.d("memo_debug", "karteAnzeigen punkt1");
// erfasse, zur zeit auf der karte angezeigte, overlays
MapView mapview_karte = (MapView) this
.findViewById(R.id.punktezeigen_karte_layout_mapview_neu);
List<Overlay> list_karten_overlay = mapview_karte.getOverlays();
memosingleton_anwendung.aktualisiereDBZugriff(MemoSingleton.KARTE);
Iterator<ItemOverlay_neu> iterator_itemoverlays;
Log.d("memo_debug", "karteAnzeigen punkt2");
switch (int_modus) {
case ANZEIGEN:
iterator_itemoverlays = hashmap_itemoverlays_temp.values()
.iterator();
break;
case WIEDERHERSTELLEN:
iterator_itemoverlays = memosingleton_anwendung.hashmap_itemoverlays
.values().iterator();
break;
default:
iterator_itemoverlays = null;
}
Log.d("memo_debug", "karteAnzeigen punkt3");
while ((iterator_itemoverlays != null)
&& iterator_itemoverlays.hasNext()) {
list_karten_overlay.add(iterator_itemoverlays.next());
}
// zeichne die karte neu
mapview_karte.invalidate();
Log.d("memo_debug", "karteAnzeigen fertig");
}
memosingleton_anwendung is an instance of application where i store some data.
Edit further investigation:
I further investigated the problem and it seems to originate from the use of the memosingleton_anwendung.hashmap_itemoverlays. If i don’t add points to these overlays the app works flawlessly. It seems that populate() runs in a separate thread and can’t handle changes in the list although i’m calling it after adding all points.
The solution to my problem included storing the computed overlays in an
ArrayList<Overlay>instead of storing objects of myItemizedOverlay-Implementation.