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

private void convertExpression(@NonNull MapLocale mapLocale, Layer layer,
                               PropertyValue<?> textFieldProperty, boolean isStreetsV7) {
  Expression textFieldExpression = textFieldProperty.getExpression();
  if (textFieldExpression != null) {
    MapLocale newMapLocale = mapLocale;
    String mapLanguage = mapLocale.getMapLanguage();
    if (mapLanguage.startsWith("name_zh")) {
      // need to re-get mapLocale, since the default is for street-v8
      newMapLocale = getChineseMapLocale(mapLocale, isStreetsV7);
      Timber.d("reset mapLocale to: %s", newMapLocale.getMapLanguage());
    }

    String text = textFieldExpression.toString().replaceAll(EXPRESSION_REGEX, newMapLocale.getMapLanguage());
    if (text.startsWith("[\"step") && textFieldExpression.toArray().length % 2 == 0) {
      // got an invalid step expression from core, we need to add an additional name_x into step
      text = text.replaceAll(STEP_REGEX, STEP_TEMPLATE);
    }
    layer.setProperties(textField(raw(text)));
  }
}
 

private void convertExpressionV8(@NonNull MapLocale mapLocale, Layer layer, PropertyValue<?> textFieldProperty) {
  Expression textFieldExpression = textFieldProperty.getExpression();
  if (textFieldExpression != null) {
    String stringExpression =
      textFieldExpression.toString().replaceAll(EXPRESSION_V8_REGEX_LOCALIZED, EXPRESSION_V8_TEMPLATE_BASE);

    String mapLanguage = mapLocale.getMapLanguage();
    if (!mapLanguage.equals(MapLocale.ENGLISH)) {
      if (mapLanguage.equals("name_zh")) {
        mapLanguage = MapLocale.SIMPLIFIED_CHINESE;
      }
      stringExpression = stringExpression.replaceAll(EXPRESSION_V8_REGEX_BASE,
        String.format(Locale.US,
          EXPRESSION_V8_TEMPLATE_LOCALIZED,
          mapLanguage,
          mapLanguage));
    }
    layer.setProperties(textField(raw(stringExpression)));
  }
}
 

private void initializeSourcesAndLayers(GeoJsonOptions geoJsonOptions) {
  geoJsonSource = coreElementProvider.getSource(geoJsonOptions);
  layer = coreElementProvider.getLayer();

  style.addSource(geoJsonSource);
  if (belowLayerId == null) {
    style.addLayer(layer);
  } else {
    style.addLayerBelow(layer, belowLayerId);
  }

  initializeDataDrivenPropertyMap();
  layer.setProperties(constantPropertyUsageMap.values().toArray(new PropertyValue[0]));
  if (layerFilter != null) {
    setFilter(layerFilter);
  }

  updateSource();
}
 

private PropertyValue getLineColor(PropertyValue pv) {
    if (pv.isExpression()) {
        return PropertyFactory.lineColor(pv.getExpression());
    } else if (pv.isValue()) {
        return PropertyFactory.lineColor(pv.getColorInt());
    }
    return null;
}
 

private PropertyValue getTextFont(PropertyValue pv) {
    if (pv.isExpression()) {
        return PropertyFactory.textFont(pv.getExpression());
    } else if (pv.isValue()) {
        return PropertyFactory.textFont((String[]) pv.getValue());
    }
    return null;
}
 

private PropertyValue getTextOffset(PropertyValue pv) {
    if (pv.isExpression()) {
        return PropertyFactory.textOffset(pv.getExpression());
    } else if (pv.isValue()) {
        return PropertyFactory.textOffset((Float[]) pv.getValue());
    }
    return null;
}
 

private PropertyValue getFillTranslateAnchor(PropertyValue pv) {
    if (pv.isExpression()) {
        return PropertyFactory.fillTranslateAnchor(pv.getExpression());
    } else if (pv.isValue()) {
        return PropertyFactory.fillTranslateAnchor((String) pv.getValue());
    }
    return null;
}
 

private PropertyValue getLineTranslateAnchor(PropertyValue pv) {
    if (pv.isExpression()) {
        return PropertyFactory.lineTranslateAnchor(pv.getExpression());
    } else if (pv.isValue()) {
        return PropertyFactory.lineTranslateAnchor((String) pv.getValue());
    }
    return null;
}
 

private PropertyValue getLineTranslate(PropertyValue pv) {
    if (pv.isExpression()) {
        return PropertyFactory.lineTranslate(pv.getExpression());
    } else if (pv.isValue()) {
        return PropertyFactory.lineTranslate((Float[]) pv.getValue());
    }
    return null;
}
 

private PropertyValue getLineGapWidth(PropertyValue pv) {
    if (pv.isExpression()) {
        return PropertyFactory.lineGapWidth(pv.getExpression());
    } else if (pv.isValue()) {
        return PropertyFactory.lineGapWidth((Float) pv.getValue());
    }
    return null;
}
 

private PropertyValue getLineWidth(PropertyValue pv) {
    if (pv.isExpression()) {
        return PropertyFactory.lineWidth(pv.getExpression());
    } else if (pv.isValue()) {
        return PropertyFactory.lineWidth((Float) pv.getValue());
    }
    return null;
}
 

private PropertyValue getLineOpacity(PropertyValue pv) {
    if (pv.isExpression()) {
        return PropertyFactory.lineOpacity(pv.getExpression());
    } else if (pv.isValue()) {
        return PropertyFactory.lineOpacity((Float) pv.getValue());
    }
    return null;
}
 

private PropertyValue getIconOffset(PropertyValue pv) {
    if (pv.isExpression()) {
        return PropertyFactory.iconOffset(pv.getExpression());
    } else if (pv.isValue()) {
        return PropertyFactory.iconOffset((Float[]) pv.getValue());
    }
    return null;
}
 

private PropertyValue getFillPattern(PropertyValue pv) {
    if (pv.isExpression()) {
        return PropertyFactory.fillPattern(pv.getExpression());
    } else if (pv.isValue()) {
        return PropertyFactory.fillPattern((String) pv.getValue());
    }
    return null;
}
 

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

  layerInteractor.updateLayerVisibility(true, "random");

  verify(anySymbolOrLineLayer, times(0)).setProperties(any(PropertyValue.class));
}
 

private PropertyValue getFillColor(PropertyValue pv) {
    if (pv.isExpression()) {
        return PropertyFactory.fillColor(pv.getExpression());
    } else if (pv.isValue()) {
        return PropertyFactory.fillColor(pv.getColorInt());
    }
    return null;
}
 

private PropertyValue getLineDashArray(PropertyValue pv) {
    if (pv.isExpression()) {
        return PropertyFactory.lineDasharray(pv.getExpression());
    } else if (pv.isValue()) {
        return PropertyFactory.lineDasharray((Float[]) pv.getValue());
    }
    return null;
}
 

private PropertyValue getTextField(PropertyValue pv) {
    if (pv.isExpression()) {
        return PropertyFactory.textField(pv.getExpression());
    } else if (pv.isValue()) {
        return PropertyFactory.textField((String) pv.getValue());
    }
    return null;
}
 

private PropertyValue getTextOpacity(PropertyValue pv) {
    if (pv.isExpression()) {
        return PropertyFactory.textOpacity(pv.getExpression());
    } else if (pv.isValue()) {
        return PropertyFactory.textOpacity((Float) pv.getValue());
    }
    return null;
}
 

private PropertyValue getIconOpacity(PropertyValue pv) {
    if (pv.isExpression()) {
        return PropertyFactory.iconOpacity(pv.getExpression());
    } else if (pv.isValue()) {
        return PropertyFactory.iconOpacity((Float) pv.getValue());
    }
    return null;
}
 

private PropertyValue getIconSize(PropertyValue pv) {
    if (pv.isExpression()) {
        return PropertyFactory.iconSize(pv.getExpression());
    } else if (pv.isValue()) {
        return PropertyFactory.iconSize((Float) pv.getValue());
    }
    return null;
}
 

private PropertyValue getIconPadding(PropertyValue pv) {
    if (pv.isExpression()) {
        return PropertyFactory.iconPadding(pv.getExpression());
    } else if (pv.isValue()) {
        return PropertyFactory.iconPadding((Float) pv.getValue());
    }
    return null;
}
 

private PropertyValue getAvoidEdges(PropertyValue pv) {
    if (pv.isExpression()) {
        return PropertyFactory.symbolAvoidEdges(pv.getExpression());
    } else if (pv.isValue()) {
        return PropertyFactory.symbolAvoidEdges((Boolean) pv.getValue());
    }
    return null;
}
 

private PropertyValue getIconImage(PropertyValue pv) {
    if (pv.isExpression()) {
        return PropertyFactory.iconImage(pv.getExpression());
    } else if (pv.isValue()) {
        return PropertyFactory.iconImage((String) pv.getValue());
    }
    return null;
}
 

private PropertyValue getIconKeepUpright(PropertyValue pv) {
    if (pv.isExpression()) {
        return PropertyFactory.iconKeepUpright(pv.getExpression());
    } else if (pv.isValue()) {
        return PropertyFactory.iconKeepUpright((Boolean) pv.getValue());
    }
    return null;
}
 

private PropertyValue getIconAllowOverlap(PropertyValue pv) {
    if (pv.isExpression()) {
        return PropertyFactory.iconAllowOverlap(pv.getExpression());
    } else if (pv.isValue()) {
        return PropertyFactory.iconAllowOverlap((Boolean) pv.getValue());
    }
    return null;
}
 

private PropertyValue getSymbolSpacing(PropertyValue pv) {
    if (pv.isExpression()) {
        return PropertyFactory.symbolSpacing(pv.getExpression());
    } else if (pv.isValue()) {
        return PropertyFactory.symbolSpacing((Float) pv.getValue());
    }
    return null;
}
 

private PropertyValue getSymbolPlacement(PropertyValue pv) {
    if (pv.isExpression()) {
        return PropertyFactory.symbolPlacement(pv.getExpression());
    } else if (pv.isValue()) {
        return PropertyFactory.symbolPlacement((String) pv.getValue());
    }
    return null;
}
 

@Override
public boolean matches(PropertyValue argument) {
  if (argument == wanted) {
    return true;
  } else if (!argument.name.equals(wanted.name)) {
    return false;
  } else if (argument.getValue() != null && wanted.getValue() != null) {
    return argument.getValue().equals(wanted.getValue());
  } else if (argument.getExpression() != null && wanted.getExpression() != null) {
    return Arrays.deepEquals(argument.getExpression().toArray(), wanted.getExpression().toArray());
  } else {
    return argument.getValue() == null && wanted.getValue() == null
      && argument.getExpression() == null && wanted.getExpression() == null;
  }
}
 

private PropertyValue getLinePattern(PropertyValue pv) {
    if (pv.isExpression()) {
        return PropertyFactory.linePattern(pv.getExpression());
    } else if (pv.isValue()) {
        return PropertyFactory.linePattern((String) pv.getValue());
    }
    return null;
}