Java AndroidGraphicFactory.INSTANCE属性代码示例

@AfterPermissionGranted(PERMISSIONS_REQUEST_READ_STORAGE)
private void createLayers() {
    if (EasyPermissions.hasPermissions(getContext(), Manifest.permission.READ_EXTERNAL_STORAGE)) {
        TileCache tileCache = AndroidUtil.createTileCache(getContext(),
                "mapFragment",
                this.mapView.getModel().displayModel.getTileSize(),
                1.0f,
                this.mapView.getModel().frameBufferModel.getOverdrawFactor());

        final Layers layers = this.mapView.getLayerManager().getLayers();
        final MapViewPosition mapViewPosition = this.mapView.getModel().mapViewPosition;

        initializePosition(mapViewPosition);

        TileRendererLayer tileRendererLayer = createTileRendererLayer(tileCache, mapViewPosition,
                getMapFile(), getRenderTheme());
        layers.add(tileRendererLayer);

        LabelLayer labelLayer = new LabelLayer(AndroidGraphicFactory.INSTANCE, tileRendererLayer.getLabelStore());
        mapView.getLayerManager().getLayers().add(labelLayer);

        // overlay with a marker to show the goal position
        this.goalLocationOverlay = new Marker(null, null, 0, 0);
        layers.add(this.goalLocationOverlay);

        createLocationLayer();
    } else {
        EasyPermissions.requestPermissions(
                this,
                "",
                PERMISSIONS_REQUEST_READ_STORAGE,
                Manifest.permission.READ_EXTERNAL_STORAGE);
    }
}
 

public MapsforgeOSMTileSource(@NonNull Context context,
                              @NonNull String name,
                              @NonNull String mapFile,
                              @NonNull TileCache cache) {
    this.context = context;
    this.name = name;
    this.mapFile = mapFile;
    //this.tileCache = cache;
    //this.tileWeakCache = new WeakHashMap<>();

    MapDatabase mapDatabase = new MapDatabase();
    mapGenerator = new DatabaseRenderer(mapDatabase, AndroidGraphicFactory.INSTANCE);
    xmlRenderTheme = new RenderTheme();
    displayModel = new Model().displayModel;

    mapDatabase.closeFile();
    mapDatabase.openFile(new File(mapFile));
    mapBounds = mapDatabase.getMapFileInfo().boundingBox;
    zoomBounds = -1;
}
 

private void createPolygons(JSONArray coordinates) {
    Polygon polygon = new Polygon(paintFill, paintStroke,
            AndroidGraphicFactory.INSTANCE);

    List<LatLong> polygonList = polygon.getLatLongs();

    for (int j = 0; j < coordinates.length(); j++) {
        try {
            JSONArray arrLatLong = new JSONArray(coordinates.get(j).toString());
            polygonList.add(new LatLong(arrLatLong.getDouble(1), arrLatLong.getDouble(0)));
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }

    layers.add(polygon);
}
 

@Override
public final void onCreate(final Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	setHasOptionsMenu(true);

	// get shared preferences
	prefs = PreferenceManager.getDefaultSharedPreferences(getActivity());

	// Register our gps broadcast mReceiver
	registerReceiver();

	catalogObjects = new ArrayList<Layer>();
	sessionObjects = new ArrayList<Layer>();
	gpxObjects = new Polyline(MapUtils.createPaint(AndroidGraphicFactory.INSTANCE.createColor(Color.BLACK), STROKE_GPX_WIDTH,
			Style.STROKE), AndroidGraphicFactory.INSTANCE);
}
 

/**
 * draws a connected series of line segments specified by a list of LatLongs.
 *
 * @param pointList
 * @param color:       the color of the polyline
 * @param strokeWidth: the stroke width of the polyline
 * @return Polyline
 */
public Polyline createPolyline(PointList pointList, int color, int strokeWidth) {
    Paint paintStroke = AndroidGraphicFactory.INSTANCE.createPaint();

    paintStroke.setStyle(Style.STROKE);
    paintStroke.setStrokeJoin(Join.ROUND);
    paintStroke.setStrokeCap(Cap.ROUND);
    paintStroke.setColor(color);
    //        paintStroke.setDashPathEffect(new float[]{25, 25});
    paintStroke.setStrokeWidth(strokeWidth);

    // TODO: new mapsforge version wants an mapsforge-paint, not an android paint.
    // This doesn't seem to support transparceny
    //paintStroke.setAlpha(128);
    Polyline line = new Polyline((Paint) paintStroke, AndroidGraphicFactory.INSTANCE);
    List<LatLong> geoPoints = line.getLatLongs();
    PointList tmp = pointList;
    for (int i = 0; i < pointList.getSize(); i++) {
        geoPoints.add(new LatLong(tmp.getLatitude(i), tmp.getLongitude(i)));
    }
    return line;
}
 

/**
 * Callback function for loadGpxObjects()
 */
@Override
public final void onGpxLoaded(final List<LatLong> points) {
    Log.d(TAG, "Loading " + points.size() + " gpx objects");

    clearGpxLayer();

    if (mMapView == null) {
        return;
    }

    mGpxObjects = new Polyline(MapUtils.createPaint(AndroidGraphicFactory.INSTANCE.createColor(Color.GREEN), STROKE_GPX_WIDTH,
            Style.STROKE), AndroidGraphicFactory.INSTANCE);

    for (final LatLong point : points) {
        mGpxObjects.getLatLongs().add(point);
    }

    synchronized (this) {
        mMapView.getLayerManager().getLayers().add(mGpxObjects);
    }

    mRefreshGpxPending = false;
}
 

/**
 * Creates a long-press enabled offline map layer
 */
private void addOnlineLayer() {
    final OnlineTileSource onlineTileSource = MapUtils.createOnlineTileSource();

    mMapDownloadLayer = new TileDownloadLayer(mTileCache,
            mMapView.getModel().mapViewPosition, onlineTileSource,
            AndroidGraphicFactory.INSTANCE) {
        @Override
        public boolean onLongPress(LatLong tapLatLong, Point thisXY, Point tapXY) {
                onLongPress(tapLatLong, thisXY, tapXY);
                return true;
        }
    };
    mMapView.getLayerManager().getLayers().add(mMapDownloadLayer);
    mMapDownloadLayer.onResume();
}
 

@Override public void onCreate(Bundle bundle) {
	super.onCreate(bundle);
	if (DEBUG) { Log.d(TAG, "Map.onCreate"); }
	AndroidGraphicFactory.createInstance(getActivity().getApplication());
	mapView = new MapView(getActivity());
	//
	mapView.setClickable(true);
	mapView.getMapScaleBar().setVisible(true);
	mapView.setBuiltInZoomControls(true);
	mapView.getMapZoomControls().setZoomLevelMin((byte)2);
	mapView.getMapZoomControls().setZoomLevelMax((byte)18);
	mapView.getMapZoomControls().setShowMapZoomControls(true);
	mapView.setLayerType(View.LAYER_TYPE_SOFTWARE, null);
	tileCache = AndroidUtil.createTileCache(getActivity(), "mapcache", mapView.getModel().displayModel.getTileSize(),
		1f, mapView.getModel().frameBufferModel.getOverdrawFactor());

	polyline = new AlternatingLine(AndroidGraphicFactory.INSTANCE);
}
 

static TileCache createExternalStorageTileCache(Context c, String id, int firstLevelSize, int tileSize) {
	Log.d(TAG, "createExternalStorageTileCache firstLevelSize=" + firstLevelSize);
	TileCache firstLevelTileCache = new InMemoryTileCache(firstLevelSize);
	if (storage != null) { // storage will be null if full
		String cacheDirectoryName = storage.getAbsolutePath() + File.separator + id;
		File cacheDirectory = new File(cacheDirectoryName);
		if (cacheDirectory.exists() || cacheDirectory.mkdirs()) {
			int tileCacheFiles = estimateSizeOfFileSystemCache(cacheDirectoryName, firstLevelSize, tileSize);
			if (cacheDirectory.canWrite() && tileCacheFiles > 0) {
				try {
					Log.d(TAG, "createExternalStorageTileCache tileCacheFiles=" + tileCacheFiles);
					TileCache secondLevelTileCache = new FileSystemTileCache(tileCacheFiles,
						cacheDirectory, AndroidGraphicFactory.INSTANCE, true, 25, true);
					return new TwoLevelTileCache(firstLevelTileCache, secondLevelTileCache);
				} catch (IllegalArgumentException e) {
					Log.w(TAG, "createExternalStorageTileCache e=" + e);
				}
			}
		}
		else {
			Log.w(TAG, "createExternalStorageTileCache can't");
		}
	}
	return firstLevelTileCache;
}
 

@Override public void onStart() {
	super.onStart();
	if (DEBUG) { Log.d(TAG, "Map.onStart"); }
	// warp to 'unter den linden'
	mapView.getModel().mapViewPosition.setCenter(new LatLong(52.517037, 13.38886));
	mapView.getModel().mapViewPosition.setZoomLevel((byte)12);
	MultiMapDataStore multiMapDataStore = new MultiMapDataStore(MultiMapDataStore.DataPolicy.DEDUPLICATE);
	tileLayer = new TileRendererLayer(tileCache, multiMapDataStore, mapView.getModel().mapViewPosition,
		false, true, AndroidGraphicFactory.INSTANCE);
	multiMapDataStore.addMapDataStore(new MapFile(new File(MAPFILE1)), true, true);
	multiMapDataStore.addMapDataStore(new MapFile(new File(MAPFILE2)), false, false);
	tileLayer.setXmlRenderTheme(InternalRenderTheme.OSMARENDER);
	mapView.getLayerManager().getLayers().add(tileLayer);
	Bitmap bitmap = AndroidGraphicFactory.convertToBitmap(getResources().getDrawable(R.drawable.poi_black));
	bitmap.incrementRefCount();
	Marker marker = new Marker(new LatLong(52.517037, 13.38886), bitmap, 0, -bitmap.getHeight() / 2) {
		@Override public boolean onTap(LatLong geoPoint, Point viewPosition, Point tapPoint) {
			if (contains(viewPosition, tapPoint)) {
				Toast.makeText(getActivity(), "Unter den Linden Ecke Friedrichstraße, Berlin", Toast.LENGTH_SHORT).show();
				return true;
			}
			return false;
		}
	};
	mapView.getLayerManager().getLayers().add(marker);
}
 

protected void addLayers(TileCache tileCache, MapViewPosition mapViewPosition) {
    if (isNetworkAvailable()) {
        downloadLayer = new TileDownloadLayer(this.tileCache,
                mapViewPosition, OpenStreetMapMapnik.INSTANCE,
                AndroidGraphicFactory.INSTANCE);
        layerManager.getLayers().add(downloadLayer);
    } else {
        Layer layer = Utils.createTileRendererLayer(tileCache, mapViewPosition, getMapFile());
        layerManager.getLayers().add(layer);
    }

    // a marker to show at the position
    Drawable drawable = getResources().getDrawable(R.drawable.pin);
    Bitmap bitmap = AndroidGraphicFactory.convertToBitmap(drawable);

    // create the overlay and tell it to follow the location
    myLocationOverlay = new MyLocationOverlay(this,
            mapViewPosition, bitmap, Utils.createPaint(AndroidGraphicFactory.INSTANCE.createColor(90, 15, 20, 25), 0,
            Style.FILL), null, user);
    myLocationOverlay.setSnapToLocationEnabled(false);

    layerManager.getLayers().add(this.myLocationOverlay);
}
 

@Override public void onStart() {
	super.onStart();
	if (DEBUG) { Log.d(TAG, "Map.onStart"); }
	// warp to 'unter den linden'
	mapView.getModel().mapViewPosition.setCenter(new LatLong(52.517037, 13.38886));
	mapView.getModel().mapViewPosition.setZoomLevel((byte)12);
	MultiMapDataStore multiMapDataStore = new MultiMapDataStore(MultiMapDataStore.DataPolicy.DEDUPLICATE);
	tileLayer = new TileRendererLayer(tileCache, multiMapDataStore, mapView.getModel().mapViewPosition,
		false, true, AndroidGraphicFactory.INSTANCE);
	tileLayer.setTextScale(1.5f);
	multiMapDataStore.addMapDataStore(new MapFile(new File(MAPFILE1)), true, true);
	multiMapDataStore.addMapDataStore(new MapFile(new File(MAPFILE2)), false, false);
	multiMapDataStore.addMapDataStore(new MapFile(new File(MAPFILE0)), false, false);
	try {
		tileLayer.setXmlRenderTheme(new ExternalRenderTheme(new File(THEMEFILE))); // set a different render theme
	}
	catch (FileNotFoundException ignore) {
		tileLayer.setXmlRenderTheme(InternalRenderTheme.OSMARENDER); // fallback if not founr
	}
	mapView.getLayerManager().getLayers().add(tileLayer);
	mapView.getLayerManager().getLayers().add( // add a grid around each tile
		new TileGridLayer(AndroidGraphicFactory.INSTANCE, mapView.getModel().displayModel));
	mapView.getLayerManager().getLayers().add( // add text to show x/y/z of each tile
		new TileCoordinatesLayer(AndroidGraphicFactory.INSTANCE, mapView.getModel().displayModel));
}
 

@Override public void onStart() {
	super.onStart();
	if (DEBUG) { Log.d(TAG, "Map.onStart"); }
	// warp to 'unter den linden'
	mapView.getModel().mapViewPosition.setCenter(new LatLong(52.517037, 13.38886));
	mapView.getModel().mapViewPosition.setZoomLevel((byte)12);
	MultiMapDataStore multiMapDataStore = new MultiMapDataStore(MultiMapDataStore.DataPolicy.DEDUPLICATE);
	tileLayer = new TileRendererLayer(tileCache, multiMapDataStore, mapView.getModel().mapViewPosition,
		false, true, AndroidGraphicFactory.INSTANCE);
	multiMapDataStore.addMapDataStore(new MapFile(new File(MAPFILE1)), true, true);
	multiMapDataStore.addMapDataStore(new MapFile(new File(MAPFILE2)), false, false);
	multiMapDataStore.addMapDataStore(new MapFile(new File(MAPFILE0)), false, false);
	tileLayer.setXmlRenderTheme(InternalRenderTheme.OSMARENDER);
	mapView.getLayerManager().getLayers().add(tileLayer);
	myLocationOverlay = new ThreeStateLocationOverlay(getActivity(), mapView.getModel().mapViewPosition);
	myLocationOverlay.setSnapToLocationEnabled(true);
	mapView.getLayerManager().getLayers().add(myLocationOverlay);
}
 

/**
 * @param c
 *            the Android context
 * @param id
 *            name for the directory
 * @return a new cache created on the external storage
 */
@Deprecated
public static TileCache createExternalStorageTileCache(final Context c, final String id) {
	final TileCache firstLevelTileCache = new InMemoryTileCache(32);
	final String cacheDirectoryName = c.getExternalCacheDir().getAbsolutePath() + File.separator + id;
	final File cacheDirectory = new File(cacheDirectoryName);
	if (!cacheDirectory.exists()) {
		cacheDirectory.mkdir();
	}
	final TileCache secondLevelTileCache = new FileSystemTileCache(1024, cacheDirectory, AndroidGraphicFactory.INSTANCE);
	return new TwoLevelTileCache(firstLevelTileCache, secondLevelTileCache);
}
 

/**
 * load map to mapView
 *
 * @param areaFolder
 */
public void loadMap(File areaFolder) {
    logToast("Loading map: " + currentArea);
    File mapFile = new File(areaFolder, currentArea + ".map");
    mapView.getLayerManager().getLayers().clear();
    TileRendererLayer tileRendererLayer =
            new TileRendererLayer(tileCache, mapView.getModel().mapViewPosition, false, true,
                    AndroidGraphicFactory.INSTANCE) {
                @Override public boolean onTap(LatLong tapLatLong, Point layerXY, Point tapXY) {
                    return myOnTap(tapLatLong, layerXY, tapXY);
                }
            };
    tileRendererLayer.setMapFile(mapFile);
    tileRendererLayer.setTextScale(0.8f);
    tileRendererLayer.setXmlRenderTheme(InternalRenderTheme.OSMARENDER);
    //        log("last location " + Variable.getVariable().getLastLocation());
    if (Variable.getVariable().getLastLocation() == null) {
        centerPointOnMap(tileRendererLayer.getMapDatabase().getMapFileInfo().boundingBox.getCenterPoint(), 6);
    } else {
        centerPointOnMap(Variable.getVariable().getLastLocation(), Variable.getVariable().getLastZoomLevel());
    }

    mapView.getLayerManager().getLayers().add(tileRendererLayer);
    ViewGroup.LayoutParams params =
            new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
    activity.addContentView(mapView, params);
    loadGraphStorage();
}