import org.mapsforge.map.layer.renderer.RendererJob; //导入依赖的package包/类
public synchronized BufferedImage getImage( final int zoomLevel, final int xTile, final int yTile ) {
    try {
        Tile tile = new Tile(xTile, yTile, (byte) zoomLevel, tileSize);
        // displayModel.setFixedTileSize(tileSize);
        // Draw the tile
        float userScaleFactor = model.getUserScaleFactor();
        RendererJob mapGeneratorJob = new RendererJob(tile, mapDatabase, theme, model, userScaleFactor, false, false);
        AwtTileBitmap bmp = (AwtTileBitmap) renderer.executeJob(mapGeneratorJob);
        if (bmp != null) {
            BufferedImage bitmap = AwtGraphicFactory.getBitmap(bmp);
            return bitmap;
        }
    } catch (Exception e) {
        // e.printStackTrace();
        // will try again later
        System.err.println(
                "Not rendering tile: " + zoomLevel + "/" + xTile + "/" + yTile + "  (" + e.getLocalizedMessage() + ")");
    }
    return null;
}
 

import org.mapsforge.map.layer.renderer.RendererJob; //导入依赖的package包/类
private ByteBuf getTile(String themeName, byte zoom, int tx, int ty) throws Exception {
  		long begin = System.currentTimeMillis();

  		String action;
  		RenderThemeFuture rtf = getRenderThemeFuture(themeName);
  		TileCache tileCache = getTileCache(themeName);
  		RendererJob theJob = createJob(MAPDS, rtf, zoom, tx, ty);
  		
  		if (!tileCache.containsKey(theJob)) {
  			action = "Draw tile";
  			TileBasedLabelStore tileBasedLabelStore = new TileBasedLabelStore(tileCache.getCapacityFirstLevel());
  			DatabaseRenderer renderer = new DatabaseRenderer(MAPDS, GRAPHIC_FACTORY, tileCache, tileBasedLabelStore, true, true, null);
  			TileBitmap tb = renderer.executeJob(theJob);
  			tileCache.put(theJob, tb);
  		} else {
  			action = "Use cached tile";
  		}

// Load tile as a Netty buffer.
String tilePath = String.format("%s/%s/%d/%d/%d.tile", SAVE_PATH, themeName, zoom, tx, ty);
InputStream tile = new FileInputStream(tilePath);
ByteBuf buffer = Unpooled.buffer();
buffer.writeBytes(tile, tile.available());

double elapsed = (System.currentTimeMillis() - begin) / 1000.0;

// TODO: Use logger.
System.out.printf("%s %s/%d/%d/%d. (%.3f seconds used)\n", action, themeName, zoom, tx, ty, elapsed);

return buffer;
  }
 

import org.mapsforge.map.layer.renderer.RendererJob; //导入依赖的package包/类
public synchronized Drawable renderTile(MapTile pTile) {

        Tile tile = new Tile(pTile.getX(), pTile.getY(), (byte) pTile.getZoomLevel(), 256);
        model.setFixedTileSize(256);

        //You could try something like this to load a custom theme
        //try{
        //	jobTheme = new ExternalRenderTheme(themeFile);
        //}
        //catch(Exception e){
        //	jobTheme = InternalRenderTheme.OSMARENDER;
        //}


        if (mapDatabase==null)
            return null;
        try {
            //Draw the tile
            RendererJob mapGeneratorJob = new RendererJob(tile, mapDatabase, theme, model, scale, false, false);
            AndroidTileBitmap bmp = (AndroidTileBitmap) renderer.executeJob(mapGeneratorJob);
            if (bmp != null)
                return new BitmapDrawable(AndroidGraphicFactory.getBitmap(bmp));
        } catch (Exception ex) {
            Log.d(IMapView.LOGTAG, "###################### Mapsforge tile generation failed", ex);
        }
        //Make the bad tile easy to spot
        Bitmap bitmap = Bitmap.createBitmap(TILE_SIZE_PIXELS, TILE_SIZE_PIXELS, Bitmap.Config.RGB_565);
        bitmap.eraseColor(Color.YELLOW);
        return new BitmapDrawable(bitmap);
    }
 

import org.mapsforge.map.layer.renderer.RendererJob; //导入依赖的package包/类
public org.mapsforge.core.graphics.Bitmap loadTile(Tile tile)
{
	RendererJob job = getJob(tile);
	org.mapsforge.core.graphics.Bitmap bitmap = tileCache.getImmediately(job);
	if (bitmap == null && !tileCache.containsKey(job))
		jobQueue.add(job);
	jobQueue.notifyWorkers();
	return bitmap;
}
 

import org.mapsforge.map.layer.renderer.RendererJob; //导入依赖的package包/类
private RendererJob createJob(MapDataStore mapData, RenderThemeFuture rtf, byte zoom, int tx, int ty) {
	Tile tile = new Tile(tx, ty, zoom, TILE_SIZE);
	RendererJob theJob = new RendererJob(tile, mapData, rtf, DISPLAY_MODEL, 1.0f, false, false);
	return theJob;
}
 

import org.mapsforge.map.layer.renderer.RendererJob; //导入依赖的package包/类
@Override
public BufferedImage call()  {
	// get mapsforge zoom from jxmapviewer2 zoom (they use different conventions)
	byte mapsforgeZoom = zoomLevelConverter.getMapsforge(tile.getZoom());

	// load the render them
	RenderThemeFuture rtf = new RenderThemeFuture(AwtGraphicFactory.INSTANCE, renderTheme, model);
	rtf.run();

	// render the mapsforge tile
	org.mapsforge.core.model.Tile mtile = new org.mapsforge.core.model.Tile(tile.getX(), tile.getY(), mapsforgeZoom, TILE_SIZE);
	RendererJob job = new RendererJob(mtile, mapDatabase, rtf, model, TEXT_SCALE, true, false);
	TileBitmap bitmap = databaseRenderer.executeJob(job);

	// copy it over onto an image (CompressedImage needs TYPE_INT_ARGB and anyway we can't access the buffered image internal to the tile)
	BufferedImage image = new BufferedImage(TILE_SIZE, TILE_SIZE, BufferedImage.TYPE_INT_ARGB);
	Graphics2D g = (Graphics2D)image.getGraphics();
	g.setClip(0, 0, TILE_SIZE, TILE_SIZE);
	g.setColor(Color.WHITE);
	g.fillRect(0, 0, TILE_SIZE, TILE_SIZE);
	Canvas canvas = (Canvas) AwtGraphicFactory.createGraphicContext(g);
	canvas.drawBitmap(bitmap, 0, 0);
	if(fadeColour!=null){
		BackgroundMapUtils.renderFade(g,fadeColour.getColour());				
	}
	
	g.dispose();
	if(fadeColour!=null){
		image = BackgroundMapUtils.greyscale(image, fadeColour.getGreyscale());				
	}
	
	// TEST save to file
//	ImageUtils.toPNGFile(image, new File("C:\\temp\\MapsforgeOutput\\" + System.currentTimeMillis() + ".png"));
	
	// add to cache
	CompressedImage compressed = new CompressedImage(image, CompressedType.LZ4);
	cacheImage(tile.getX(), tile.getY(), tile.getZoom(), compressed);

	// remove from pending after adding from cache (so can't be added twice)
	removeTile(tile);
	
	return image;
}
 

import org.mapsforge.map.layer.renderer.RendererJob; //导入依赖的package包/类
private static RendererJob getJob(Tile tile)
{
	return new RendererJob(tile, mapDataStore, renderTheme, displayModel, textScale, false, false);
}