TileGenerator _is_ a MapWorker, extract TileGenerator interface

src/org/oscim/layers/tile/ITileGenerator.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2013 Hannes Janetzek
+ *
+ * This program is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Lesser General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+ * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.oscim.layers.tile;
+
+public interface ITileGenerator {
+
+	/**
+	 * Load data for 'tile' and file tile.layers for rendering.
+	 * (executed on MapWorker threads)
+	 */
+	public abstract boolean executeJob(MapTile tile);
+
+	public abstract void cleanup();
+}

src/org/oscim/layers/tile/MapWorker.java

@@ -1,6 +1,7 @@
 /*
  * Copyright 2010, 2011, 2012 mapsforge.org
  * Copyright 2013 Hannes Hannes Janetzek
+ *
  * This program is free software: you can redistribute it and/or modify it under the
  * terms of the GNU Lesser General Public License as published by the Free Software
  * Foundation, either version 3 of the License, or (at your option) any later version.
@@ -20,10 +21,9 @@ import org.oscim.utils.PausableThread;
  * A MapWorker uses a {@link TileGenerator} to generate map tiles. It runs in a
  * separate thread to avoid blocking the UI thread.
  */
-public class MapWorker extends PausableThread {
+public abstract class MapWorker extends PausableThread {
 	private final String THREAD_NAME;
 	private final JobQueue mJobQueue;
-	private final TileGenerator mMapGenerator;
 	private final TileManager mTileManager;
 
 	/**
@@ -31,31 +31,18 @@ public class MapWorker extends PausableThread {
 	 *            thread id
 	 * @param jobQueue
 	 *            ...
-	 * @param tileGenerator
-	 *            ...
 	 * @param tileManager
 	 *            ...
 	 */
-	public MapWorker(int id, JobQueue jobQueue, TileGenerator tileGenerator,
+	public MapWorker(int id, JobQueue jobQueue, TileManager tileManager) {
-			TileManager tileManager) {
 
 		super();
 		mJobQueue = jobQueue;
-		mMapGenerator = tileGenerator;
 		mTileManager = tileManager;
 
 		THREAD_NAME = "MapWorker" + id;
 	}
 
-	public TileGenerator getTileGenerator() {
-		return mMapGenerator;
-	}
-
-	@Override
-	protected void afterRun() {
-		// empty
-	}
-
 	@Override
 	protected void doWork() {
 		MapTile tile = mJobQueue.poll();
@@ -64,17 +51,20 @@ public class MapWorker extends PausableThread {
 			return;
 
 		try {
-			mMapGenerator.executeJob(tile);
+			executeJob(tile);
 		} catch (Exception e) {
 			e.printStackTrace();
 			return;
 		}
 
 		if (!isInterrupted()) {
+			// pass tile to main thread
 			mTileManager.passTile(tile);
 		}
 	}
 
+	protected abstract boolean executeJob(MapTile tile);
+
 	@Override
 	protected String getThreadName() {
 		return THREAD_NAME;

src/org/oscim/layers/tile/TileGenerator.java

@@ -58,7 +58,7 @@ import android.util.Log;
  *       5. RenderTheme calls IRenderCallback functions with style information
  *       6. Styled items become added to MapTile.layers... roughly
  */
-public class TileGenerator implements IRenderCallback, IMapDatabaseCallback {
+public class TileGenerator extends MapWorker implements IRenderCallback, IMapDatabaseCallback, ITileGenerator  {
 
 	private static final String TAG = TileGenerator.class.getName();
 
@@ -117,7 +117,9 @@ public class TileGenerator implements IRenderCallback, IMapDatabaseCallback {
 
 	/**
 	 */
-	public TileGenerator() {
+	public TileGenerator(int id, JobQueue jobQueue,	TileManager tileManager) {
+		super(id, jobQueue, tileManager);
+
 		mClipper = new LineClipper(0, 0, Tile.SIZE, Tile.SIZE, true);
 
 		MapElement m = mDebugWay = new MapElement();
@@ -137,15 +139,24 @@ public class TileGenerator implements IRenderCallback, IMapDatabaseCallback {
 		m.geometryType = GEOM_POINT;
 	}
 
+	/* (non-Javadoc)
+	 * @see org.oscim.layers.tile.ITileGenerator#cleanup()
+	 */
+	@Override
 	public void cleanup() {
+		mMapDatabase.close();
 	}
 
-	public boolean executeJob(MapTile MapTile) {
+	/* (non-Javadoc)
+	 * @see org.oscim.layers.tile.ITileGenerator#executeJob(org.oscim.layers.tile.MapTile)
+	 */
+	@Override
+	public boolean executeJob(MapTile mapTile) {
 
 		if (mMapDatabase == null)
 			return false;
 
-		mTile = (MapTile) MapTile;
+		mTile = mapTile;
 
 		if (mTile.layers != null) {
 			// should be fixed now.

src/org/oscim/layers/tile/TileLayer.java

@@ -49,38 +49,34 @@ public class TileLayer extends Layer {
 	private final TileManager mTileManager;
 
 	private final JobQueue mJobQueue;
-	// TODO use 1 download and 1 generator thread instead
+
-		private final MapWorker mMapWorkers[];
+	private final int mNumTileWorker = 4;
-		private final int mNumMapWorkers = 4;
+	private final TileGenerator mTileWorker[];
-		private final TileGenerator mTileGenerators[];
 
 	public TileLayer(MapView mapView) {
 		super(mapView);
 		mTileManager = new TileManager(mapView, this);
 		mJobQueue = new JobQueue();
-		mMapWorkers = new MapWorker[mNumMapWorkers];
+		mTileWorker = new TileGenerator[mNumTileWorker];
-		mTileGenerators = new TileGenerator[mNumMapWorkers];
 
 		TileGenerator.setDebugSettings(mapView.getDebugSettings());
 
-		for (int i = 0; i < mNumMapWorkers; i++) {
+		for (int i = 0; i < mNumTileWorker; i++) {
-			mTileGenerators[i] = new TileGenerator();
+			mTileWorker[i] = new TileGenerator(i, mJobQueue, mTileManager);
-			mMapWorkers[i] = new MapWorker(i, mJobQueue, mTileGenerators[i], mTileManager);
+			mTileWorker[i].start();
-			mMapWorkers[i].start();
 		}
 
 		mLayer = new TileRenderLayer(mapView, mTileManager);
 	}
 
-	public TileRenderLayer getTileLayer(){
+	public TileRenderLayer getTileLayer() {
-		return (TileRenderLayer)mLayer;
+		return (TileRenderLayer) mLayer;
 	}
 
-
 	@Override
 	public void onUpdate(MapPosition mapPosition, boolean changed) {
 
-		if (mClearMap){
+		if (mClearMap) {
 			mTileManager.init(mMapView.getWidth(), mMapView.getHeight());
 			mClearMap = false;
 			changed = true;
@@ -90,19 +86,20 @@ public class TileLayer extends Layer {
 			mTileManager.update(mapPosition);
 	}
 
-
 	@Override
-	public void destroy(){
+	public void destroy() {
+
 		mTileManager.destroy();
 
-		for (MapWorker mapWorker : mMapWorkers) {
+		for (TileGenerator tileWorker : mTileWorker) {
-			mapWorker.pause();
+			tileWorker.pause();
-			mapWorker.interrupt();
+			tileWorker.interrupt();
 
-			mapWorker.getTileGenerator().getMapDatabase().close();
+			//tileWorker.getMapDatabase().close();
+			tileWorker.cleanup();
 
 			try {
-				mapWorker.join(10000);
+				tileWorker.join(10000);
 			} catch (InterruptedException e) {
 				// restore the interrupted status
 				Thread.currentThread().interrupt();
@@ -132,15 +129,15 @@ public class TileLayer extends Layer {
 		if (mMapOptions != null && mMapOptions.equals(options))
 			return true;
 
-		mapWorkersPause(true);
+		tileWorkersPause(true);
 
 		mJobQueue.clear();
 		mMapOptions = options;
 
 		mMapDatabase = null;
 
-		for (int i = 0; i < mNumMapWorkers; i++) {
+		for (int i = 0; i < mNumTileWorker; i++) {
-			MapWorker mapWorker = mMapWorkers[i];
+			//TileGenerator tileWorker = mTileWorker[i];
 
 			IMapDatabase mapDatabase = MapDatabaseFactory
 					.createMapDatabase(options.db);
@@ -151,8 +148,10 @@ public class TileLayer extends Layer {
 				Log.d(TAG, "failed open db: " + result.getErrorMessage());
 			}
 
-			TileGenerator tileGenerator = mapWorker.getTileGenerator();
+			mTileWorker[i].setMapDatabase(mapDatabase);
-			tileGenerator.setMapDatabase(mapDatabase);
+
+			//TileGenerator tileGenerator = tileWorker.getTileGenerator();
+			//tileGenerator.setMapDatabase(mapDatabase);
 
 			// TODO this could be done in a cleaner way..
 			if (mMapDatabase == null)
@@ -168,7 +167,7 @@ public class TileLayer extends Layer {
 
 		clearMap();
 
-		mapWorkersProceed();
+		tileWorkersProceed();
 
 		return true;
 	}
@@ -203,9 +202,11 @@ public class TileLayer extends Layer {
 
 		return mapPosition;
 	}
+
 	public String getRenderTheme() {
 		return mRenderTheme;
 	}
+
 	/**
 	 * Sets the internal theme which is used for rendering the map.
 	 *
@@ -232,6 +233,7 @@ public class TileLayer extends Layer {
 
 		return ret;
 	}
+
 	/**
 	 * Sets the theme file which is used for rendering the map.
 	 *
@@ -258,7 +260,7 @@ public class TileLayer extends Layer {
 
 	private boolean setRenderTheme(Theme theme) {
 
-		mapWorkersPause(true);
+		tileWorkersPause(true);
 
 		InputStream inputStream = null;
 		try {
@@ -269,7 +271,7 @@ public class TileLayer extends Layer {
 			// FIXME !!!
 			GLRenderer.setRenderTheme(t);
 
-			for (TileGenerator g : mTileGenerators)
+			for (TileGenerator g : mTileWorker)
 				g.setRenderTheme(t);
 
 			return true;
@@ -287,12 +289,13 @@ public class TileLayer extends Layer {
 			} catch (IOException e) {
 				Log.e(TAG, e.getMessage());
 			}
-			mapWorkersProceed();
+			tileWorkersProceed();
 		}
 		return false;
 	}
+
 	/**
-	 * add jobs and remember MapWorkers that stuff needs to be done
+	 * add jobs and remember TileGenerators that stuff needs to be done
 	 *
 	 * @param jobs
 	 *            tile jobs
@@ -304,29 +307,29 @@ public class TileLayer extends Layer {
 		}
 		mJobQueue.setJobs(jobs);
 
-		for (int i = 0; i < mNumMapWorkers; i++) {
+		for (int i = 0; i < mNumTileWorker; i++) {
-			MapWorker m = mMapWorkers[i];
+			TileGenerator m = mTileWorker[i];
 			synchronized (m) {
 				m.notify();
 			}
 		}
 	}
 
-	private void mapWorkersPause(boolean wait) {
+	private void tileWorkersPause(boolean wait) {
-		for (MapWorker mapWorker : mMapWorkers) {
+		for (TileGenerator tileWorker : mTileWorker) {
-			if (!mapWorker.isPausing())
+			if (!tileWorker.isPausing())
-				mapWorker.pause();
+				tileWorker.pause();
 		}
 		if (wait) {
-			for (MapWorker mapWorker : mMapWorkers) {
+			for (TileGenerator tileWorker : mTileWorker) {
-				if (!mapWorker.isPausing())
+				if (!tileWorker.isPausing())
-					mapWorker.awaitPausing();
+					tileWorker.awaitPausing();
 			}
 		}
 	}
 
-	private void mapWorkersProceed() {
+	private void tileWorkersProceed() {
-		for (MapWorker mapWorker : mMapWorkers)
+		for (TileGenerator tileWorker : mTileWorker)
-			mapWorker.proceed();
+			tileWorker.proceed();
 	}
 }