com.mapbox.mapboxsdk.style.layers.Property Java Examples

static LineLayer getLineLayer(String lineLayerId, float minZoom, Expression filter,
                              Expression lineColorExpression, Expression lineWidthExpression,
                              Expression lineOffsetExpression, Expression lineOpacityExpression) {
  LineLayer lineLayer = new LineLayer(lineLayerId, TrafficData.SOURCE_ID);
  lineLayer.setSourceLayer(TrafficData.SOURCE_LAYER);
  lineLayer.setProperties(
    lineCap(Property.LINE_CAP_ROUND),
    lineJoin(Property.LINE_JOIN_ROUND),
    lineColor(lineColorExpression),
    lineWidth(lineWidthExpression),
    lineOffset(lineOffsetExpression)
  );
  if (lineOpacityExpression != null) {
    lineLayer.setProperties(lineOpacity(lineOpacityExpression));
  }

  lineLayer.setFilter(filter);
  lineLayer.setMinZoom(minZoom);
  return lineLayer;
}
 

@NonNull
private MapWayname buildMapWayname(PointF point, SymbolLayer waynameLayer, List<Feature> roads) {
  String roadName = "roadName";
  String[] layerIds = {"streetsLayer"};
  WaynameLayoutProvider layoutProvider = mock(WaynameLayoutProvider.class);
  when(layoutProvider.generateLayoutBitmap(roadName)).thenReturn(mock(Bitmap.class));
  MapLayerInteractor layerInteractor = mock(MapLayerInteractor.class);
  when(waynameLayer.getVisibility()).thenReturn(visibility(Property.VISIBLE));
  when(layerInteractor.retrieveLayerFromId(MAPBOX_WAYNAME_LAYER)).thenReturn(waynameLayer);
  WaynameFeatureFinder featureInteractor = mock(WaynameFeatureFinder.class);
  when(featureInteractor.queryRenderedFeatures(point, layerIds)).thenReturn(roads);
  MapPaddingAdjustor paddingAdjustor = mock(MapPaddingAdjustor.class);
  MapWayname mapWayname = new MapWayname(layoutProvider, layerInteractor, featureInteractor, paddingAdjustor);
  mapWayname.updateWaynameQueryMap(true);
  return mapWayname;

}
 

private LineLayer createArrowShaftLayer() {
  LineLayer shaftLayer = (LineLayer) mapboxMap.getLayer(ARROW_SHAFT_LINE_LAYER_ID);
  if (shaftLayer != null) {
    return shaftLayer;
  }
  return new LineLayer(ARROW_SHAFT_LINE_LAYER_ID, ARROW_SHAFT_SOURCE_ID).withProperties(
    PropertyFactory.lineColor(color(arrowColor)),
    PropertyFactory.lineWidth(
      interpolate(linear(), zoom(),
        stop(MIN_ARROW_ZOOM, MIN_ZOOM_ARROW_SHAFT_SCALE),
        stop(MAX_ARROW_ZOOM, MAX_ZOOM_ARROW_SHAFT_SCALE)
      )
    ),
    PropertyFactory.lineCap(Property.LINE_CAP_ROUND),
    PropertyFactory.lineJoin(Property.LINE_JOIN_ROUND),
    PropertyFactory.visibility(NONE),
    PropertyFactory.lineOpacity(
      step(zoom(), OPAQUE,
        stop(
          ARROW_HIDDEN_ZOOM_LEVEL, TRANSPARENT
        )
      )
    )
  );
}
 

private LineLayer createArrowShaftCasingLayer() {
  LineLayer shaftCasingLayer = (LineLayer) mapboxMap.getLayer(ARROW_SHAFT_CASING_LINE_LAYER_ID);
  if (shaftCasingLayer != null) {
    return shaftCasingLayer;
  }
  return new LineLayer(ARROW_SHAFT_CASING_LINE_LAYER_ID, ARROW_SHAFT_SOURCE_ID).withProperties(
    PropertyFactory.lineColor(color(arrowBorderColor)),
    PropertyFactory.lineWidth(
      interpolate(linear(), zoom(),
        stop(MIN_ARROW_ZOOM, MIN_ZOOM_ARROW_SHAFT_CASING_SCALE),
        stop(MAX_ARROW_ZOOM, MAX_ZOOM_ARROW_SHAFT_CASING_SCALE)
      )
    ),
    PropertyFactory.lineCap(Property.LINE_CAP_ROUND),
    PropertyFactory.lineJoin(Property.LINE_JOIN_ROUND),
    PropertyFactory.visibility(NONE),
    PropertyFactory.lineOpacity(
      step(zoom(), OPAQUE,
        stop(
          ARROW_HIDDEN_ZOOM_LEVEL, TRANSPARENT
        )
      )
    )
  );
}
 

/**
 * Toggles the visibility of the traffic layers.
 *
 * @param visible true for visible, false for none
 */
public void setVisibility(boolean visible) {
  this.visible = visible;

  if (!style.isFullyLoaded()) {
    // We are in progress of loading a new style
    return;
  }

  Source source = style.getSource(TrafficData.SOURCE_ID);
  if (source == null) {
    initialise();
  }

  List<Layer> layers = style.getLayers();
  for (Layer layer : layers) {
    if (layerIds.contains(layer.getId())) {
      layer.setProperties(visibility(visible ? Property.VISIBLE : Property.NONE));
    }
  }
}
 

/**
 * Add the route shield layer to the map either using the custom style values or the default.
 */
private void addRouteShieldLayer(String layerId, String sourceId, int index) {
  float scale = index == primaryRouteIndex ? routeScale : alternativeRouteScale;
  Layer routeLayer = new LineLayer(layerId, sourceId).withProperties(
    PropertyFactory.lineCap(Property.LINE_CAP_ROUND),
    PropertyFactory.lineJoin(Property.LINE_JOIN_ROUND),
    PropertyFactory.lineWidth(interpolate(
      exponential(1.5f), zoom(),
      stop(10f, 7f),
      stop(14f, 10.5f * scale),
      stop(16.5f, 15.5f * scale),
      stop(19f, 24f * scale),
      stop(22f, 29f * scale)
      )
    ),
    PropertyFactory.lineColor(
      index == primaryRouteIndex ? routeShieldColor : alternativeRouteShieldColor)
  );
  MapUtils.addLayerToMap(mapboxMap, routeLayer, belowLayer);
}
 

@Test
public void onUpdateWaynameLayer_layerImageIsAdded() {
  String roadName = "roadName";
  SymbolLayer waynameLayer = mock(SymbolLayer.class);
  when(waynameLayer.getVisibility()).thenReturn(visibility(Property.VISIBLE));
  MapLayerInteractor layerInteractor = mock(MapLayerInteractor.class);
  when(layerInteractor.retrieveLayerFromId(MAPBOX_WAYNAME_LAYER)).thenReturn(waynameLayer);
  Bitmap bitmap = mock(Bitmap.class);
  WaynameLayoutProvider layoutProvider = mock(WaynameLayoutProvider.class);
  when(layoutProvider.generateLayoutBitmap(roadName)).thenReturn(bitmap);
  MapWayname mapWayname = buildMapWayname(layoutProvider, layerInteractor);

  mapWayname.updateWaynameLayer(roadName, waynameLayer);

  verify(layerInteractor).addLayerImage(MAPBOX_WAYNAME_ICON, bitmap);
}
 

@Test
public void onUpdateWaynameWithPoint_queryRenderedFeaturesIsCalled() {
  WaynameLayoutProvider layoutProvider = mock(WaynameLayoutProvider.class);
  MapLayerInteractor layerInteractor = mock(MapLayerInteractor.class);
  SymbolLayer waynameLayer = mock(SymbolLayer.class);
  when(waynameLayer.getVisibility()).thenReturn(visibility(Property.VISIBLE));
  when(layerInteractor.retrieveLayerFromId(MAPBOX_WAYNAME_LAYER)).thenReturn(waynameLayer);
  WaynameFeatureFinder featureInteractor = mock(WaynameFeatureFinder.class);
  MapPaddingAdjustor paddingAdjustor = mock(MapPaddingAdjustor.class);
  String[] layerIds = {"streetsLayer"};
  PointF point = mock(PointF.class);
  MapWayname mapWayname = new MapWayname(layoutProvider, layerInteractor, featureInteractor, paddingAdjustor);
  mapWayname.updateWaynameVisibility(true, waynameLayer);
  mapWayname.updateWaynameQueryMap(true);

  mapWayname.updateWaynameWithPoint(point, waynameLayer);

  verify(featureInteractor).queryRenderedFeatures(point, layerIds);
}
 

@Test
public void isLayerVisible_visibleReturnsTrue() {
  SymbolLayer anySymbolOrLineLayer = mock(SymbolLayer.class);
  when(anySymbolOrLineLayer.getSourceLayer()).thenReturn("any");
  when(anySymbolOrLineLayer.getVisibility()).thenReturn(visibility(Property.VISIBLE));
  List<Layer> layers = buildLayerListWith(anySymbolOrLineLayer);
  MapboxMap map = mock(MapboxMap.class);
  when(map.getLayers()).thenReturn(layers);
  MapLayerInteractor layerInteractor = new MapLayerInteractor(map);

  boolean isVisible = layerInteractor.isLayerVisible("any");

  assertTrue(isVisible);
}
 

@Test
public void toggleHidesLocalCaseLayer() throws Exception {
  executeTrafficTest(new TrafficPluginAction.OnPerformTrafficAction() {
    @Override
    public void onTrafficAction(TrafficPlugin trafficPlugin, MapboxMap mapboxMap, UiController controller) {
      trafficPlugin.setVisibility(false);
      assertTrue(mapboxMap.getStyle().getLayer(Local.CASE_LAYER_ID).getVisibility().getValue().equals(Property.NONE));
    }
  });
}
 

@Test
public void toggleHidesSecondaryBaseLayer() throws Exception {
  executeTrafficTest(new TrafficPluginAction.OnPerformTrafficAction() {
    @Override
    public void onTrafficAction(TrafficPlugin trafficPlugin, MapboxMap mapboxMap, UiController controller) {
      trafficPlugin.setVisibility(false);
      assertTrue(mapboxMap.getStyle().getLayer(Secondary.BASE_LAYER_ID).getVisibility().getValue().equals(Property.NONE));
    }
  });
}
 

@Test
public void toggleHidesSecondaryCaseLayer() throws Exception {
  executeTrafficTest(new TrafficPluginAction.OnPerformTrafficAction() {
    @Override
    public void onTrafficAction(TrafficPlugin trafficPlugin, MapboxMap mapboxMap, UiController controller) {
      trafficPlugin.setVisibility(false);
      assertTrue(mapboxMap.getStyle().getLayer(Secondary.CASE_LAYER_ID).getVisibility().getValue().equals(Property.NONE));
    }
  });
}
 

@Test
public void toggleHidesPrimaryBaseLayer() throws Exception {
  executeTrafficTest(new TrafficPluginAction.OnPerformTrafficAction() {
    @Override
    public void onTrafficAction(TrafficPlugin trafficPlugin, MapboxMap mapboxMap, UiController controller) {
      trafficPlugin.setVisibility(false);
      assertTrue(mapboxMap.getStyle().getLayer(Primary.BASE_LAYER_ID).getVisibility().getValue().equals(Property.NONE));
    }
  });
}
 

private void drawWaypointMarkers(@NonNull MapboxMap mapboxMap, @Nullable Drawable originMarker,
                                 @Nullable Drawable destinationMarker) {
  if (originMarker == null || destinationMarker == null) {
    return;
  }

  SymbolLayer waypointLayer = mapboxMap.getLayerAs(WAYPOINT_LAYER_ID);
  if (waypointLayer == null) {
    Bitmap bitmap = MapImageUtils.getBitmapFromDrawable(originMarker);
    mapboxMap.addImage("originMarker", bitmap);
    bitmap = MapImageUtils.getBitmapFromDrawable(destinationMarker);
    mapboxMap.addImage("destinationMarker", bitmap);

    waypointLayer = new SymbolLayer(WAYPOINT_LAYER_ID, WAYPOINT_SOURCE_ID).withProperties(
      PropertyFactory.iconImage(match(
        Expression.toString(get("waypoint")), literal("originMarker"),
        stop("origin", literal("originMarker")),
        stop("destination", literal("destinationMarker"))
        )
      ),
      PropertyFactory.iconSize(interpolate(
        exponential(1.5f), zoom(),
        stop(22f, 2.8f),
        stop(12f, 1.3f),
        stop(10f, 0.8f),
        stop(0f, 0.6f)
      )),
      PropertyFactory.iconPitchAlignment(Property.ANCHOR_MAP),
      PropertyFactory.iconAllowOverlap(true),
      PropertyFactory.iconIgnorePlacement(true)
    );
    layerIds.add(WAYPOINT_LAYER_ID);
    MapUtils.addLayerToMap(mapboxMap, waypointLayer, belowLayer);
  }
}
 

@Test
public void onVisibiltySetToTrue_paddingIsAdjusted() {
  SymbolLayer waynameLayer = mock(SymbolLayer.class);
  when(waynameLayer.getVisibility()).thenReturn(visibility(Property.NONE));
  MapLayerInteractor layerInteractor = mock(MapLayerInteractor.class);
  when(layerInteractor.retrieveLayerFromId(MAPBOX_WAYNAME_LAYER)).thenReturn(waynameLayer);
  MapPaddingAdjustor paddingAdjustor = mock(MapPaddingAdjustor.class);
  MapWayname mapWayname = buildMapWayname(layerInteractor, paddingAdjustor);

  mapWayname.updateWaynameVisibility(true, waynameLayer);

  verify(paddingAdjustor).updateTopPaddingWithWayname();
}
 

@Test
public void onVisibiltySetToFalse_paddingIsAdjusted() {
  SymbolLayer waynameLayer = mock(SymbolLayer.class);
  when(waynameLayer.getVisibility()).thenReturn(visibility(Property.VISIBLE));
  MapLayerInteractor layerInteractor = mock(MapLayerInteractor.class);
  when(layerInteractor.retrieveLayerFromId(MAPBOX_WAYNAME_LAYER)).thenReturn(waynameLayer);
  MapPaddingAdjustor paddingAdjustor = mock(MapPaddingAdjustor.class);
  MapWayname mapWayname = buildMapWayname(layerInteractor, paddingAdjustor);

  mapWayname.updateWaynameVisibility(false, waynameLayer);

  verify(paddingAdjustor).updateTopPaddingWithDefault();
}
 

@Test
public void isLayerVisible_visibleReturnsFalse() {
  LineLayer anySymbolOrLineLayer = mock(LineLayer.class);
  when(anySymbolOrLineLayer.getSourceLayer()).thenReturn("any");
  when(anySymbolOrLineLayer.getVisibility()).thenReturn(visibility(Property.NONE));
  List<Layer> layers = buildLayerListWith(anySymbolOrLineLayer);
  MapboxMap map = mock(MapboxMap.class);
  when(map.getLayers()).thenReturn(layers);
  MapLayerInteractor layerInteractor = new MapLayerInteractor(map);

  boolean isVisible = layerInteractor.isLayerVisible("any");

  assertFalse(isVisible);
}
 

@Test
public void toggleHidesTrunkBaseLayer() throws Exception {
  executeTrafficTest(new TrafficPluginAction.OnPerformTrafficAction() {
    @Override
    public void onTrafficAction(TrafficPlugin trafficPlugin, MapboxMap mapboxMap, UiController controller) {
      trafficPlugin.setVisibility(false);
      assertTrue(mapboxMap.getStyle().getLayer(Trunk.BASE_LAYER_ID).getVisibility().getValue().equals(Property.NONE));
    }
  });
}
 

private void createWaynameIcon(String wayname, Layer waynameLayer) {
  boolean isVisible = waynameLayer.getVisibility().getValue().contentEquals(Property.VISIBLE);
  if (isVisible) {
    Bitmap waynameLayoutBitmap = layoutProvider.generateLayoutBitmap(wayname);
    if (waynameLayoutBitmap != null) {
      layerInteractor.addLayerImage(MAPBOX_WAYNAME_ICON, waynameLayoutBitmap);
      waynameLayer.setProperties(iconImage(MAPBOX_WAYNAME_ICON));
    }
  }
}
 

@Test
public void toggleHidesLocalBaseLayer() throws Exception {
  executeTrafficTest(new TrafficPluginAction.OnPerformTrafficAction() {
    @Override
    public void onTrafficAction(TrafficPlugin trafficPlugin, MapboxMap mapboxMap, UiController controller) {
      trafficPlugin.setVisibility(false);
      assertTrue(mapboxMap.getStyle().getLayer(Local.BASE_LAYER_ID).getVisibility().getValue().equals(Property.NONE));
    }
  });
}
 

@Test
public void motorWayCaseLayerVisible() throws Exception {
  executeTrafficTest(new TrafficPluginAction.OnPerformTrafficAction() {
    @Override
    public void onTrafficAction(TrafficPlugin trafficPlugin, MapboxMap mapboxMap, UiController controller) {
      assertTrue(mapboxMap.getStyle().getLayer(MotorWay.CASE_LAYER_ID).getVisibility().getValue().equals(Property.VISIBLE));
    }
  });
}
 

@Test
public void motorWayBaseLayerVisible() throws Exception {
  executeTrafficTest(new TrafficPluginAction.OnPerformTrafficAction() {
    @Override
    public void onTrafficAction(TrafficPlugin trafficPlugin, MapboxMap mapboxMap, UiController controller) {
      assertTrue(mapboxMap.getStyle().getLayer(MotorWay.BASE_LAYER_ID).getVisibility().getValue().equals(Property.VISIBLE));
    }
  });
}
 

@Test
public void trunkCaseLayerVisible() throws Exception {
  executeTrafficTest(new TrafficPluginAction.OnPerformTrafficAction() {
    @Override
    public void onTrafficAction(TrafficPlugin trafficPlugin, MapboxMap mapboxMap, UiController controller) {
      assertTrue(mapboxMap.getStyle().getLayer(Primary.CASE_LAYER_ID).getVisibility().getValue().equals(Property.VISIBLE));
    }
  });
}
 

@Test
public void trunkBaseLayerVisible() throws Exception {
  executeTrafficTest(new TrafficPluginAction.OnPerformTrafficAction() {
    @Override
    public void onTrafficAction(TrafficPlugin trafficPlugin, MapboxMap mapboxMap, UiController controller) {
      assertTrue(mapboxMap.getStyle().getLayer(Primary.BASE_LAYER_ID).getVisibility().getValue().equals(Property.VISIBLE));
    }
  });
}
 

@Test
public void primaryCaseLayerVisible() throws Exception {
  executeTrafficTest(new TrafficPluginAction.OnPerformTrafficAction() {
    @Override
    public void onTrafficAction(TrafficPlugin trafficPlugin, MapboxMap mapboxMap, UiController controller) {
      assertTrue(mapboxMap.getStyle().getLayer(Primary.CASE_LAYER_ID).getVisibility().getValue().equals(Property.VISIBLE));
    }
  });
}
 

@Test
public void primaryBaseLayerVisible() throws Exception {
  executeTrafficTest(new TrafficPluginAction.OnPerformTrafficAction() {
    @Override
    public void onTrafficAction(TrafficPlugin trafficPlugin, MapboxMap mapboxMap, UiController controller) {
      assertTrue(mapboxMap.getStyle().getLayer(Primary.BASE_LAYER_ID).getVisibility().getValue().equals(Property.VISIBLE));
    }
  });
}
 

@Test
public void secondaryCaseLayerVisible() throws Exception {
  executeTrafficTest(new TrafficPluginAction.OnPerformTrafficAction() {
    @Override
    public void onTrafficAction(TrafficPlugin trafficPlugin, MapboxMap mapboxMap, UiController controller) {
      assertTrue(mapboxMap.getStyle().getLayer(Secondary.CASE_LAYER_ID).getVisibility().getValue().equals(Property.VISIBLE));
    }
  });
}
 

@Test
public void secondaryBaseLayerVisible() throws Exception {
  executeTrafficTest(new TrafficPluginAction.OnPerformTrafficAction() {
    @Override
    public void onTrafficAction(TrafficPlugin trafficPlugin, MapboxMap mapboxMap, UiController controller) {
      assertTrue(mapboxMap.getStyle().getLayer(Secondary.BASE_LAYER_ID).getVisibility().getValue().equals(Property.VISIBLE));
    }
  });
}
 

@Test
public void localCaseLayerVisible() throws Exception {
  executeTrafficTest(new TrafficPluginAction.OnPerformTrafficAction() {
    @Override
    public void onTrafficAction(TrafficPlugin trafficPlugin, MapboxMap mapboxMap, UiController controller) {
      assertTrue(mapboxMap.getStyle().getLayer(Local.CASE_LAYER_ID).getVisibility().getValue().equals(Property.VISIBLE));
    }
  });
}
 

@Test
public void localBaseLayerVisible() throws Exception {
  executeTrafficTest(new TrafficPluginAction.OnPerformTrafficAction() {
    @Override
    public void onTrafficAction(TrafficPlugin trafficPlugin, MapboxMap mapboxMap, UiController controller) {
      assertTrue(mapboxMap.getStyle().getLayer(Local.BASE_LAYER_ID).getVisibility().getValue().equals(Property.VISIBLE));
    }
  });
}