import org.oscim.layers.Layer; //导入依赖的package包/类
private void setBuildingLayerEnabled(boolean enabled) {
    Layers layers = map.layers();
    for (Layer layer : layers) {
        if (layer instanceof CacheboxMapAdapter.BuildingLabelLayer) {
            log.debug("{} BuildingLayer", enabled ? "Enable" : "Disable");
            ((CacheboxMapAdapter.BuildingLabelLayer) layer).buildingLayer.setEnabled(enabled);
        } else if (layer instanceof GroupLayer) {
            List<Layer> groupLayers = ((GroupLayer) layer).layers;
            for (Layer l : groupLayers) {
                if (l instanceof CenterCrossLayer) {
                    log.debug("{} CenterCrossLayer", enabled ? "Enable" : "Disable");
                    if (enabled) {
                        //check settings
                        l.setEnabled(Settings_Map.ShowMapCenterCross.getValue());
                    } else {
                        l.setEnabled(false);
                    }
                }
            }
        }
    }
}
 

import org.oscim.layers.Layer; //导入依赖的package包/类
private void removeSourceFromMap(FileDataSource source) {
    for (Waypoint waypoint : source.waypoints) {
        removeWaypointMarker(waypoint);
        mTotalDataItems--;
    }
    for (Iterator<Layer> i = mMap.layers().iterator(); i.hasNext(); ) {
        Layer layer = i.next();
        if (!(layer instanceof TrackLayer))
            continue;
        if (source.tracks.contains(((TrackLayer) layer).getTrack())) {
            i.remove();
            layer.onDetach();
            mTotalDataItems--;
        }
    }
}
 

import org.oscim.layers.Layer; //导入依赖的package包/类
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) {
        if (mMap.getEventLayer().moveEnabled()) {
            AbstractMapEventLayer eventLayer = mMap.getEventLayer();
            eventLayer.enableMove(false);
            eventLayer.enableRotation(false);
            eventLayer.enableTilt(false);
            eventLayer.enableZoom(false);
            mCrosshairLayer.lock(mColorAccent);
            mPositionLocked = true;
        }
        return true;
    }
    if (keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
        for (Layer layer : mMap.layers()) {
            if (layer instanceof TrackLayer || layer instanceof MapObjectLayer || layer instanceof MarkerLayer)
                layer.setEnabled(false);
        }
        mMap.updateMap(true);
        return true;
    }
    return super.onKeyDown(keyCode, event);
}
 

import org.oscim.layers.Layer; //导入依赖的package包/类
@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) {
        AbstractMapEventLayer eventLayer = mMap.getEventLayer();
        eventLayer.enableMove(true);
        eventLayer.enableRotation(true);
        eventLayer.enableTilt(true);
        eventLayer.enableZoom(true);
        mCrosshairLayer.unlock();
        mPositionLocked = false;
        return true;
    }
    if (keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
        for (Layer layer : mMap.layers()) {
            if (layer instanceof TrackLayer || layer instanceof MapObjectLayer || layer instanceof MarkerLayer)
                layer.setEnabled(true);
        }
        mMap.updateMap(true);
        return true;
    }
    return super.onKeyUp(keyCode, event);
}
 

import org.oscim.layers.Layer; //导入依赖的package包/类
@Override
public synchronized Layer set(int index, Layer layer) {
	if (mLayerList.contains(layer))
		throw new IllegalArgumentException("layer added twice");

	mDirtyLayers = true;
	Layer remove = mLayerList.set(index, layer);

	// unbind replaced layer
	if (remove instanceof UpdateListener)
		mMap.events.unbind((UpdateListener) remove);
	if (remove instanceof InputListener)
		mMap.input.unbind((InputListener) remove);

	return remove;
}
 

import org.oscim.layers.Layer; //导入依赖的package包/类
@Override
public Layer getLayer(Map map) {
    if (vectorTileLayer == null) vectorTileLayer = createVectorTileLayer(map);
    GroupLayer layer = new GroupLayer(map);
    layer.layers.add(new BuildingLayer(map, vectorTileLayer));
    layer.layers.add(new LabelLayer(map, vectorTileLayer));
    return layer;
}
 

import org.oscim.layers.Layer; //导入依赖的package包/类
public void clearLines() {
    for (Layer layer: map.layers()) {
        if (layer.getClass().equals(PathLayer.class)) {
            map.layers().remove(layer);
        }
    }
}
 

import org.oscim.layers.Layer; //导入依赖的package包/类
public void clearLinesExcept(ArrayList<PathLayer> layers) {
    for (Layer layer: map.layers()) {
        if (layer.getClass().equals(PathLayer.class)) {
            if (!layers.contains(layer)) {
                map.layers().remove(layer);
            }
        }
    }
}
 

import org.oscim.layers.Layer; //导入依赖的package包/类
public void moveToTop(Class<?> klass) {
    for (Layer layer: map.layers()) {
        if (layer.getClass().equals(klass)) {
            map.layers().remove(layer);
            map.layers().add(layer);
        }
    }
}
 

import org.oscim.layers.Layer; //导入依赖的package包/类
@Override
public synchronized void add(int index, Layer layer) {
	if (mLayerList.contains(layer))
		throw new IllegalArgumentException("layer added twice");

	if (layer instanceof UpdateListener)
		mMap.events.bind((UpdateListener) layer);

	if (layer instanceof InputListener)
		mMap.input.bind((InputListener) layer);

	mLayerList.add(index, layer);
	mDirtyLayers = true;
}
 

import org.oscim.layers.Layer; //导入依赖的package包/类
void destroy() {
	if (mDirtyLayers)
		updateLayers();

	for (Layer o : mLayers)
		o.onDetach();
}
 

import org.oscim.layers.Layer; //导入依赖的package包/类
boolean handleGesture(Gesture g, MotionEvent e) {
	if (mDirtyLayers)
		updateLayers();

	for (Layer o : mLayers)
		if (o instanceof GestureListener)
			if (((GestureListener) o).onGesture(g, e))
				return true;

	return false;
}
 

import org.oscim.layers.Layer; //导入依赖的package包/类
public void onDetach() {
	if (mDirtyLayers)
		updateLayers();

	for (Layer o : mLayers)
		o.onDetach();
}
 

import org.oscim.layers.Layer; //导入依赖的package包/类
public void onUpdate(MapPosition mapPosition, boolean changed, boolean clear) {
	if (mDirtyLayers)
		updateLayers();

	for (Layer l : mLayers)
		l.onUpdate(mapPosition, changed, clear);
}
 

import org.oscim.layers.Layer; //导入依赖的package包/类
public void destroy() {
	if (mDirtyLayers)
		updateLayers();

	for (Layer l : mLayers) {
		l.destroy();
	}
}
 

import org.oscim.layers.Layer; //导入依赖的package包/类
@Override
public void dispose() {
    log.debug("Dispose MapView");

    //save last position for next initial
    MapPosition mapPosition = this.map.getMapPosition();
    Settings_Map.lastMapState.setValue(lastMapState.getValues());
    Settings_Map.MapInitLatitude.setValue(mapPosition.getLatitude());
    Settings_Map.MapInitLongitude.setValue(mapPosition.getLongitude());
    Config.AcceptChanges();

    positionChangedHandler.dispose();
    positionChangedHandler = null;

    Layers layers = map.layers();
    for (Layer layer : layers) {
        if (layer instanceof Disposable) {
            ((Disposable) layer).dispose();
        } else if (layer instanceof GroupLayer) {
            for (Layer groupLayer : ((GroupLayer) layer).layers) {
                if (groupLayer instanceof Disposable) {
                    ((Disposable) groupLayer).dispose();
                }
            }
        }
    }

    layers.clear();

    wayPointLayer = null;

    mapInputHandler.clear();
    mapInputHandler = null;

    CacheboxMain.drawMap = false;
    map.clearMap();
    map.destroy();
    TextureBucket.pool.clear();
    TextItem.pool.clear();
    TextureItem.disposeTextures();

    main.mMapRenderer = null;
    map = null;

    //dispose actors
    mapStateButton.dispose();

    infoPanel.dispose();
    Settings_Map.ShowMapCenterCross.removeChangedEventListener(showMapCenterCrossChangedListener);
}
 

import org.oscim.layers.Layer; //导入依赖的package包/类
@Override
public Layer getLayer(Map map) {
    return null;
}
 

import org.oscim.layers.Layer; //导入依赖的package包/类
public LocationAccuracyRenderer(Map map, Layer layer) {
    mMap = map;
    mLayer = layer;

}
 

import org.oscim.layers.Layer; //导入依赖的package包/类
@Export
public static boolean addLayer(Layer l) {
	return mMap.layers().add(l);
}
 

import org.oscim.layers.Layer; //导入依赖的package包/类
Layers(Map map) {
	mMap = map;
	mLayerList = new CopyOnWriteArrayList<Layer>();
}