@rnmapbox/maps 10.1.13 → 10.1.14

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (10) hide show
  1. package/android/src/main/java/com/rnmapbox/rnmbx/components/annotation/RNMBXPointAnnotationCoordinator.kt +39 -40
  2. package/android/src/main/java/com/rnmapbox/rnmbx/components/camera/CameraStop.kt +9 -9
  3. package/android/src/main/java/com/rnmapbox/rnmbx/components/camera/CameraUpdateItem.kt +1 -2
  4. package/android/src/main/java/com/rnmapbox/rnmbx/components/camera/RNMBXCamera.kt +4 -7
  5. package/android/src/main/java/com/rnmapbox/rnmbx/components/camera/RNMBXCameraManager.kt +2 -2
  6. package/android/src/main/java/com/rnmapbox/rnmbx/components/camera/constants/CameraMode.java +3 -2
  7. package/android/src/main/java/com/rnmapbox/rnmbx/components/styles/RNMBXStyleFactory.kt +1046 -987
  8. package/android/src/main/java/com/rnmapbox/rnmbx/modules/RNMBXModule.kt +1 -0
  9. package/android/src/main/java/com/rnmapbox/rnmbx/utils/ViewTagResolver.kt +10 -2
  10. package/package.json +1 -1
package/android/src/main/java/com/rnmapbox/rnmbx/components/styles/RNMBXStyleFactory.kt CHANGED
@@ -2,6 +2,7 @@
2
2
  // THIS FILE IS AUTOGENERATED
3
3
  package com.rnmapbox.rnmbx.components.styles
4
4
 
5
+ import com.mapbox.maps.MapboxStyleException
5
6
  import com.mapbox.maps.extension.style.expressions.generated.Expression
6
7
  import com.mapbox.maps.extension.style.layers.generated.BackgroundLayer
7
8
  import com.mapbox.maps.extension.style.layers.generated.CircleLayer
@@ -24,13 +25,15 @@ import com.mapbox.maps.extension.style.types.StyleTransition
24
25
 
25
26
  import com.mapbox.maps.extension.style.light.LightPosition
26
27
  import com.rnmapbox.rnmbx.utils.DownloadMapImageTask.OnAllImagesLoaded
27
- import com.rnmapbox.rnmbx.utils.Logger.e
28
+ import com.rnmapbox.rnmbx.utils.Logger
28
29
 
29
30
  import com.rnmapbox.rnmbx.v11compat.light.*;
30
31
  import com.rnmapbox.rnmbx.v11compat.stylefactory.*;
31
32
 
32
33
  import java.util.List;
33
34
 
35
+ const val LOG_TAG = "RNMBXStyleFactory"
36
+
34
37
  object RNMBXStyleFactory {
35
38
  const val VALUE_KEY = "value";
36
39
  const val SHOULD_ADD_IMAGE_KEY = "shouldAddImage";
@@ -43,47 +46,51 @@ object RNMBXStyleFactory {
43
46
  }
44
47
 
45
48
  for (styleKey in styleKeys) {
46
- val styleValue = style.getStyleValueForKey(styleKey)
47
-
48
- when (styleKey) {
49
- "fillSortKey" ->
50
- setFillSortKey(layer, styleValue)
51
- "visibility" ->
52
- setVisibility(layer, styleValue)
53
- "fillAntialias" ->
54
- setFillAntialias(layer, styleValue)
55
- "fillOpacity" ->
56
- setFillOpacity(layer, styleValue)
57
- "fillOpacityTransition" ->
58
- setFillOpacityTransition(layer, styleValue)
59
- "fillColor" ->
60
- setFillColor(layer, styleValue)
61
- "fillColorTransition" ->
62
- setFillColorTransition(layer, styleValue)
63
- "fillOutlineColor" ->
64
- setFillOutlineColor(layer, styleValue)
65
- "fillOutlineColorTransition" ->
66
- setFillOutlineColorTransition(layer, styleValue)
67
- "fillTranslate" ->
68
- setFillTranslate(layer, styleValue)
69
- "fillTranslateTransition" ->
70
- setFillTranslateTransition(layer, styleValue)
71
- "fillTranslateAnchor" ->
72
- setFillTranslateAnchor(layer, styleValue)
73
- "fillPattern" ->
74
- style.addImage(styleValue!!, styleKey, object : OnAllImagesLoaded {
75
- override fun onAllImagesLoaded() {
76
- try {
77
- setFillPattern(layer, styleValue)
78
- } catch (exception: RuntimeException) {
79
- e("RNMBXFill",String.format("Exception failed during setFillPattern: %s", exception.message))
80
- }
81
- }
82
- })
83
- "fillEmissiveStrength" ->
84
- setFillEmissiveStrength(layer, styleValue)
85
- "fillEmissiveStrengthTransition" ->
86
- setFillEmissiveStrengthTransition(layer, styleValue)
49
+ try {
50
+ val styleValue = style.getStyleValueForKey(styleKey)
51
+
52
+ when (styleKey) {
53
+ "fillSortKey" ->
54
+ setFillSortKey(layer, styleValue)
55
+ "visibility" ->
56
+ setVisibility(layer, styleValue)
57
+ "fillAntialias" ->
58
+ setFillAntialias(layer, styleValue)
59
+ "fillOpacity" ->
60
+ setFillOpacity(layer, styleValue)
61
+ "fillOpacityTransition" ->
62
+ setFillOpacityTransition(layer, styleValue)
63
+ "fillColor" ->
64
+ setFillColor(layer, styleValue)
65
+ "fillColorTransition" ->
66
+ setFillColorTransition(layer, styleValue)
67
+ "fillOutlineColor" ->
68
+ setFillOutlineColor(layer, styleValue)
69
+ "fillOutlineColorTransition" ->
70
+ setFillOutlineColorTransition(layer, styleValue)
71
+ "fillTranslate" ->
72
+ setFillTranslate(layer, styleValue)
73
+ "fillTranslateTransition" ->
74
+ setFillTranslateTransition(layer, styleValue)
75
+ "fillTranslateAnchor" ->
76
+ setFillTranslateAnchor(layer, styleValue)
77
+ "fillPattern" ->
78
+ style.addImage(styleValue!!, styleKey, object : OnAllImagesLoaded {
79
+ override fun onAllImagesLoaded() {
80
+ try {
81
+ setFillPattern(layer, styleValue)
82
+ } catch (exception: RuntimeException) {
83
+ Logger.e("RNMBXFill",String.format("Exception failed during setFillPattern: %s", exception.message))
84
+ }
85
+ }
86
+ })
87
+ "fillEmissiveStrength" ->
88
+ setFillEmissiveStrength(layer, styleValue)
89
+ "fillEmissiveStrengthTransition" ->
90
+ setFillEmissiveStrengthTransition(layer, styleValue)
91
+ }
92
+ } catch (e: MapboxStyleException) {
93
+ Logger.e(LOG_TAG, "Failed to update: $styleKey ${e.message}")
87
94
  }
88
95
  }
89
96
  }
@@ -95,71 +102,75 @@ object RNMBXStyleFactory {
95
102
  }
96
103
 
97
104
  for (styleKey in styleKeys) {
98
- val styleValue = style.getStyleValueForKey(styleKey)
99
-
100
- when (styleKey) {
101
- "lineCap" ->
102
- setLineCap(layer, styleValue)
103
- "lineJoin" ->
104
- setLineJoin(layer, styleValue)
105
- "lineMiterLimit" ->
106
- setLineMiterLimit(layer, styleValue)
107
- "lineRoundLimit" ->
108
- setLineRoundLimit(layer, styleValue)
109
- "lineSortKey" ->
110
- setLineSortKey(layer, styleValue)
111
- "visibility" ->
112
- setVisibility(layer, styleValue)
113
- "lineOpacity" ->
114
- setLineOpacity(layer, styleValue)
115
- "lineOpacityTransition" ->
116
- setLineOpacityTransition(layer, styleValue)
117
- "lineColor" ->
118
- setLineColor(layer, styleValue)
119
- "lineColorTransition" ->
120
- setLineColorTransition(layer, styleValue)
121
- "lineTranslate" ->
122
- setLineTranslate(layer, styleValue)
123
- "lineTranslateTransition" ->
124
- setLineTranslateTransition(layer, styleValue)
125
- "lineTranslateAnchor" ->
126
- setLineTranslateAnchor(layer, styleValue)
127
- "lineWidth" ->
128
- setLineWidth(layer, styleValue)
129
- "lineWidthTransition" ->
130
- setLineWidthTransition(layer, styleValue)
131
- "lineGapWidth" ->
132
- setLineGapWidth(layer, styleValue)
133
- "lineGapWidthTransition" ->
134
- setLineGapWidthTransition(layer, styleValue)
135
- "lineOffset" ->
136
- setLineOffset(layer, styleValue)
137
- "lineOffsetTransition" ->
138
- setLineOffsetTransition(layer, styleValue)
139
- "lineBlur" ->
140
- setLineBlur(layer, styleValue)
141
- "lineBlurTransition" ->
142
- setLineBlurTransition(layer, styleValue)
143
- "lineDasharray" ->
144
- setLineDasharray(layer, styleValue)
145
- "linePattern" ->
146
- style.addImage(styleValue!!, styleKey, object : OnAllImagesLoaded {
147
- override fun onAllImagesLoaded() {
148
- try {
149
- setLinePattern(layer, styleValue)
150
- } catch (exception: RuntimeException) {
151
- e("RNMBXLine",String.format("Exception failed during setLinePattern: %s", exception.message))
152
- }
153
- }
154
- })
155
- "lineGradient" ->
156
- setLineGradient(layer, styleValue)
157
- "lineTrimOffset" ->
158
- setLineTrimOffset(layer, styleValue)
159
- "lineEmissiveStrength" ->
160
- setLineEmissiveStrength(layer, styleValue)
161
- "lineEmissiveStrengthTransition" ->
162
- setLineEmissiveStrengthTransition(layer, styleValue)
105
+ try {
106
+ val styleValue = style.getStyleValueForKey(styleKey)
107
+
108
+ when (styleKey) {
109
+ "lineCap" ->
110
+ setLineCap(layer, styleValue)
111
+ "lineJoin" ->
112
+ setLineJoin(layer, styleValue)
113
+ "lineMiterLimit" ->
114
+ setLineMiterLimit(layer, styleValue)
115
+ "lineRoundLimit" ->
116
+ setLineRoundLimit(layer, styleValue)
117
+ "lineSortKey" ->
118
+ setLineSortKey(layer, styleValue)
119
+ "visibility" ->
120
+ setVisibility(layer, styleValue)
121
+ "lineOpacity" ->
122
+ setLineOpacity(layer, styleValue)
123
+ "lineOpacityTransition" ->
124
+ setLineOpacityTransition(layer, styleValue)
125
+ "lineColor" ->
126
+ setLineColor(layer, styleValue)
127
+ "lineColorTransition" ->
128
+ setLineColorTransition(layer, styleValue)
129
+ "lineTranslate" ->
130
+ setLineTranslate(layer, styleValue)
131
+ "lineTranslateTransition" ->
132
+ setLineTranslateTransition(layer, styleValue)
133
+ "lineTranslateAnchor" ->
134
+ setLineTranslateAnchor(layer, styleValue)
135
+ "lineWidth" ->
136
+ setLineWidth(layer, styleValue)
137
+ "lineWidthTransition" ->
138
+ setLineWidthTransition(layer, styleValue)
139
+ "lineGapWidth" ->
140
+ setLineGapWidth(layer, styleValue)
141
+ "lineGapWidthTransition" ->
142
+ setLineGapWidthTransition(layer, styleValue)
143
+ "lineOffset" ->
144
+ setLineOffset(layer, styleValue)
145
+ "lineOffsetTransition" ->
146
+ setLineOffsetTransition(layer, styleValue)
147
+ "lineBlur" ->
148
+ setLineBlur(layer, styleValue)
149
+ "lineBlurTransition" ->
150
+ setLineBlurTransition(layer, styleValue)
151
+ "lineDasharray" ->
152
+ setLineDasharray(layer, styleValue)
153
+ "linePattern" ->
154
+ style.addImage(styleValue!!, styleKey, object : OnAllImagesLoaded {
155
+ override fun onAllImagesLoaded() {
156
+ try {
157
+ setLinePattern(layer, styleValue)
158
+ } catch (exception: RuntimeException) {
159
+ Logger.e("RNMBXLine",String.format("Exception failed during setLinePattern: %s", exception.message))
160
+ }
161
+ }
162
+ })
163
+ "lineGradient" ->
164
+ setLineGradient(layer, styleValue)
165
+ "lineTrimOffset" ->
166
+ setLineTrimOffset(layer, styleValue)
167
+ "lineEmissiveStrength" ->
168
+ setLineEmissiveStrength(layer, styleValue)
169
+ "lineEmissiveStrengthTransition" ->
170
+ setLineEmissiveStrengthTransition(layer, styleValue)
171
+ }
172
+ } catch (e: MapboxStyleException) {
173
+ Logger.e(LOG_TAG, "Failed to update: $styleKey ${e.message}")
163
174
  }
164
175
  }
165
176
  }
@@ -171,175 +182,179 @@ object RNMBXStyleFactory {
171
182
  }
172
183
 
173
184
  for (styleKey in styleKeys) {
174
- val styleValue = style.getStyleValueForKey(styleKey)
175
-
176
- when (styleKey) {
177
- "symbolPlacement" ->
178
- setSymbolPlacement(layer, styleValue)
179
- "symbolSpacing" ->
180
- setSymbolSpacing(layer, styleValue)
181
- "symbolAvoidEdges" ->
182
- setSymbolAvoidEdges(layer, styleValue)
183
- "symbolSortKey" ->
184
- setSymbolSortKey(layer, styleValue)
185
- "symbolZOrder" ->
186
- setSymbolZOrder(layer, styleValue)
187
- "iconAllowOverlap" ->
188
- setIconAllowOverlap(layer, styleValue)
189
- "iconIgnorePlacement" ->
190
- setIconIgnorePlacement(layer, styleValue)
191
- "iconOptional" ->
192
- setIconOptional(layer, styleValue)
193
- "iconRotationAlignment" ->
194
- setIconRotationAlignment(layer, styleValue)
195
- "iconSize" ->
196
- setIconSize(layer, styleValue)
197
- "iconTextFit" ->
198
- setIconTextFit(layer, styleValue)
199
- "iconTextFitPadding" ->
200
- setIconTextFitPadding(layer, styleValue)
201
- "iconImage" ->
202
- style.addImage(styleValue!!, styleKey, object : OnAllImagesLoaded {
203
- override fun onAllImagesLoaded() {
204
- try {
205
- setIconImage(layer, styleValue)
206
- } catch (exception: RuntimeException) {
207
- e("RNMBXSymbol",String.format("Exception failed during setIconImage: %s", exception.message))
208
- }
209
- }
210
- })
211
- "iconRotate" ->
212
- setIconRotate(layer, styleValue)
213
- "iconPadding" ->
214
- setIconPadding(layer, styleValue)
215
- "iconKeepUpright" ->
216
- setIconKeepUpright(layer, styleValue)
217
- "iconOffset" ->
218
- setIconOffset(layer, styleValue)
219
- "iconAnchor" ->
220
- setIconAnchor(layer, styleValue)
221
- "iconPitchAlignment" ->
222
- setIconPitchAlignment(layer, styleValue)
223
- "textPitchAlignment" ->
224
- setTextPitchAlignment(layer, styleValue)
225
- "textRotationAlignment" ->
226
- setTextRotationAlignment(layer, styleValue)
227
- "textField" ->
228
- setTextField(layer, styleValue)
229
- "textFont" ->
230
- setTextFont(layer, styleValue)
231
- "textSize" ->
232
- setTextSize(layer, styleValue)
233
- "textMaxWidth" ->
234
- setTextMaxWidth(layer, styleValue)
235
- "textLineHeight" ->
236
- setTextLineHeight(layer, styleValue)
237
- "textLetterSpacing" ->
238
- setTextLetterSpacing(layer, styleValue)
239
- "textJustify" ->
240
- setTextJustify(layer, styleValue)
241
- "textRadialOffset" ->
242
- setTextRadialOffset(layer, styleValue)
243
- "textVariableAnchor" ->
244
- setTextVariableAnchor(layer, styleValue)
245
- "textAnchor" ->
246
- setTextAnchor(layer, styleValue)
247
- "textMaxAngle" ->
248
- setTextMaxAngle(layer, styleValue)
249
- "textWritingMode" ->
250
- setTextWritingMode(layer, styleValue)
251
- "textRotate" ->
252
- setTextRotate(layer, styleValue)
253
- "textPadding" ->
254
- setTextPadding(layer, styleValue)
255
- "textKeepUpright" ->
256
- setTextKeepUpright(layer, styleValue)
257
- "textTransform" ->
258
- setTextTransform(layer, styleValue)
259
- "textOffset" ->
260
- setTextOffset(layer, styleValue)
261
- "textAllowOverlap" ->
262
- setTextAllowOverlap(layer, styleValue)
263
- "textIgnorePlacement" ->
264
- setTextIgnorePlacement(layer, styleValue)
265
- "textOptional" ->
266
- setTextOptional(layer, styleValue)
267
- "visibility" ->
268
- setVisibility(layer, styleValue)
269
- "iconOpacity" ->
270
- setIconOpacity(layer, styleValue)
271
- "iconOpacityTransition" ->
272
- setIconOpacityTransition(layer, styleValue)
273
- "iconColor" ->
274
- setIconColor(layer, styleValue)
275
- "iconColorTransition" ->
276
- setIconColorTransition(layer, styleValue)
277
- "iconHaloColor" ->
278
- setIconHaloColor(layer, styleValue)
279
- "iconHaloColorTransition" ->
280
- setIconHaloColorTransition(layer, styleValue)
281
- "iconHaloWidth" ->
282
- setIconHaloWidth(layer, styleValue)
283
- "iconHaloWidthTransition" ->
284
- setIconHaloWidthTransition(layer, styleValue)
285
- "iconHaloBlur" ->
286
- setIconHaloBlur(layer, styleValue)
287
- "iconHaloBlurTransition" ->
288
- setIconHaloBlurTransition(layer, styleValue)
289
- "iconTranslate" ->
290
- setIconTranslate(layer, styleValue)
291
- "iconTranslateTransition" ->
292
- setIconTranslateTransition(layer, styleValue)
293
- "iconTranslateAnchor" ->
294
- setIconTranslateAnchor(layer, styleValue)
295
- "textOpacity" ->
296
- setTextOpacity(layer, styleValue)
297
- "textOpacityTransition" ->
298
- setTextOpacityTransition(layer, styleValue)
299
- "textColor" ->
300
- setTextColor(layer, styleValue)
301
- "textColorTransition" ->
302
- setTextColorTransition(layer, styleValue)
303
- "textHaloColor" ->
304
- setTextHaloColor(layer, styleValue)
305
- "textHaloColorTransition" ->
306
- setTextHaloColorTransition(layer, styleValue)
307
- "textHaloWidth" ->
308
- setTextHaloWidth(layer, styleValue)
309
- "textHaloWidthTransition" ->
310
- setTextHaloWidthTransition(layer, styleValue)
311
- "textHaloBlur" ->
312
- setTextHaloBlur(layer, styleValue)
313
- "textHaloBlurTransition" ->
314
- setTextHaloBlurTransition(layer, styleValue)
315
- "textTranslate" ->
316
- setTextTranslate(layer, styleValue)
317
- "textTranslateTransition" ->
318
- setTextTranslateTransition(layer, styleValue)
319
- "textTranslateAnchor" ->
320
- setTextTranslateAnchor(layer, styleValue)
321
- "symbolZElevate" ->
322
- setSymbolZElevate(layer, styleValue)
323
- "iconEmissiveStrength" ->
324
- setIconEmissiveStrength(layer, styleValue)
325
- "iconEmissiveStrengthTransition" ->
326
- setIconEmissiveStrengthTransition(layer, styleValue)
327
- "textEmissiveStrength" ->
328
- setTextEmissiveStrength(layer, styleValue)
329
- "textEmissiveStrengthTransition" ->
330
- setTextEmissiveStrengthTransition(layer, styleValue)
331
- "iconImageCrossFade" ->
332
- style.addImage(styleValue!!, styleKey, object : OnAllImagesLoaded {
333
- override fun onAllImagesLoaded() {
334
- try {
335
- setIconImageCrossFade(layer, styleValue)
336
- } catch (exception: RuntimeException) {
337
- e("RNMBXSymbol",String.format("Exception failed during setIconImageCrossFade: %s", exception.message))
338
- }
339
- }
340
- })
341
- "iconImageCrossFadeTransition" ->
342
- setIconImageCrossFadeTransition(layer, styleValue)
185
+ try {
186
+ val styleValue = style.getStyleValueForKey(styleKey)
187
+
188
+ when (styleKey) {
189
+ "symbolPlacement" ->
190
+ setSymbolPlacement(layer, styleValue)
191
+ "symbolSpacing" ->
192
+ setSymbolSpacing(layer, styleValue)
193
+ "symbolAvoidEdges" ->
194
+ setSymbolAvoidEdges(layer, styleValue)
195
+ "symbolSortKey" ->
196
+ setSymbolSortKey(layer, styleValue)
197
+ "symbolZOrder" ->
198
+ setSymbolZOrder(layer, styleValue)
199
+ "iconAllowOverlap" ->
200
+ setIconAllowOverlap(layer, styleValue)
201
+ "iconIgnorePlacement" ->
202
+ setIconIgnorePlacement(layer, styleValue)
203
+ "iconOptional" ->
204
+ setIconOptional(layer, styleValue)
205
+ "iconRotationAlignment" ->
206
+ setIconRotationAlignment(layer, styleValue)
207
+ "iconSize" ->
208
+ setIconSize(layer, styleValue)
209
+ "iconTextFit" ->
210
+ setIconTextFit(layer, styleValue)
211
+ "iconTextFitPadding" ->
212
+ setIconTextFitPadding(layer, styleValue)
213
+ "iconImage" ->
214
+ style.addImage(styleValue!!, styleKey, object : OnAllImagesLoaded {
215
+ override fun onAllImagesLoaded() {
216
+ try {
217
+ setIconImage(layer, styleValue)
218
+ } catch (exception: RuntimeException) {
219
+ Logger.e("RNMBXSymbol",String.format("Exception failed during setIconImage: %s", exception.message))
220
+ }
221
+ }
222
+ })
223
+ "iconRotate" ->
224
+ setIconRotate(layer, styleValue)
225
+ "iconPadding" ->
226
+ setIconPadding(layer, styleValue)
227
+ "iconKeepUpright" ->
228
+ setIconKeepUpright(layer, styleValue)
229
+ "iconOffset" ->
230
+ setIconOffset(layer, styleValue)
231
+ "iconAnchor" ->
232
+ setIconAnchor(layer, styleValue)
233
+ "iconPitchAlignment" ->
234
+ setIconPitchAlignment(layer, styleValue)
235
+ "textPitchAlignment" ->
236
+ setTextPitchAlignment(layer, styleValue)
237
+ "textRotationAlignment" ->
238
+ setTextRotationAlignment(layer, styleValue)
239
+ "textField" ->
240
+ setTextField(layer, styleValue)
241
+ "textFont" ->
242
+ setTextFont(layer, styleValue)
243
+ "textSize" ->
244
+ setTextSize(layer, styleValue)
245
+ "textMaxWidth" ->
246
+ setTextMaxWidth(layer, styleValue)
247
+ "textLineHeight" ->
248
+ setTextLineHeight(layer, styleValue)
249
+ "textLetterSpacing" ->
250
+ setTextLetterSpacing(layer, styleValue)
251
+ "textJustify" ->
252
+ setTextJustify(layer, styleValue)
253
+ "textRadialOffset" ->
254
+ setTextRadialOffset(layer, styleValue)
255
+ "textVariableAnchor" ->
256
+ setTextVariableAnchor(layer, styleValue)
257
+ "textAnchor" ->
258
+ setTextAnchor(layer, styleValue)
259
+ "textMaxAngle" ->
260
+ setTextMaxAngle(layer, styleValue)
261
+ "textWritingMode" ->
262
+ setTextWritingMode(layer, styleValue)
263
+ "textRotate" ->
264
+ setTextRotate(layer, styleValue)
265
+ "textPadding" ->
266
+ setTextPadding(layer, styleValue)
267
+ "textKeepUpright" ->
268
+ setTextKeepUpright(layer, styleValue)
269
+ "textTransform" ->
270
+ setTextTransform(layer, styleValue)
271
+ "textOffset" ->
272
+ setTextOffset(layer, styleValue)
273
+ "textAllowOverlap" ->
274
+ setTextAllowOverlap(layer, styleValue)
275
+ "textIgnorePlacement" ->
276
+ setTextIgnorePlacement(layer, styleValue)
277
+ "textOptional" ->
278
+ setTextOptional(layer, styleValue)
279
+ "visibility" ->
280
+ setVisibility(layer, styleValue)
281
+ "iconOpacity" ->
282
+ setIconOpacity(layer, styleValue)
283
+ "iconOpacityTransition" ->
284
+ setIconOpacityTransition(layer, styleValue)
285
+ "iconColor" ->
286
+ setIconColor(layer, styleValue)
287
+ "iconColorTransition" ->
288
+ setIconColorTransition(layer, styleValue)
289
+ "iconHaloColor" ->
290
+ setIconHaloColor(layer, styleValue)
291
+ "iconHaloColorTransition" ->
292
+ setIconHaloColorTransition(layer, styleValue)
293
+ "iconHaloWidth" ->
294
+ setIconHaloWidth(layer, styleValue)
295
+ "iconHaloWidthTransition" ->
296
+ setIconHaloWidthTransition(layer, styleValue)
297
+ "iconHaloBlur" ->
298
+ setIconHaloBlur(layer, styleValue)
299
+ "iconHaloBlurTransition" ->
300
+ setIconHaloBlurTransition(layer, styleValue)
301
+ "iconTranslate" ->
302
+ setIconTranslate(layer, styleValue)
303
+ "iconTranslateTransition" ->
304
+ setIconTranslateTransition(layer, styleValue)
305
+ "iconTranslateAnchor" ->
306
+ setIconTranslateAnchor(layer, styleValue)
307
+ "textOpacity" ->
308
+ setTextOpacity(layer, styleValue)
309
+ "textOpacityTransition" ->
310
+ setTextOpacityTransition(layer, styleValue)
311
+ "textColor" ->
312
+ setTextColor(layer, styleValue)
313
+ "textColorTransition" ->
314
+ setTextColorTransition(layer, styleValue)
315
+ "textHaloColor" ->
316
+ setTextHaloColor(layer, styleValue)
317
+ "textHaloColorTransition" ->
318
+ setTextHaloColorTransition(layer, styleValue)
319
+ "textHaloWidth" ->
320
+ setTextHaloWidth(layer, styleValue)
321
+ "textHaloWidthTransition" ->
322
+ setTextHaloWidthTransition(layer, styleValue)
323
+ "textHaloBlur" ->
324
+ setTextHaloBlur(layer, styleValue)
325
+ "textHaloBlurTransition" ->
326
+ setTextHaloBlurTransition(layer, styleValue)
327
+ "textTranslate" ->
328
+ setTextTranslate(layer, styleValue)
329
+ "textTranslateTransition" ->
330
+ setTextTranslateTransition(layer, styleValue)
331
+ "textTranslateAnchor" ->
332
+ setTextTranslateAnchor(layer, styleValue)
333
+ "symbolZElevate" ->
334
+ setSymbolZElevate(layer, styleValue)
335
+ "iconEmissiveStrength" ->
336
+ setIconEmissiveStrength(layer, styleValue)
337
+ "iconEmissiveStrengthTransition" ->
338
+ setIconEmissiveStrengthTransition(layer, styleValue)
339
+ "textEmissiveStrength" ->
340
+ setTextEmissiveStrength(layer, styleValue)
341
+ "textEmissiveStrengthTransition" ->
342
+ setTextEmissiveStrengthTransition(layer, styleValue)
343
+ "iconImageCrossFade" ->
344
+ style.addImage(styleValue!!, styleKey, object : OnAllImagesLoaded {
345
+ override fun onAllImagesLoaded() {
346
+ try {
347
+ setIconImageCrossFade(layer, styleValue)
348
+ } catch (exception: RuntimeException) {
349
+ Logger.e("RNMBXSymbol",String.format("Exception failed during setIconImageCrossFade: %s", exception.message))
350
+ }
351
+ }
352
+ })
353
+ "iconImageCrossFadeTransition" ->
354
+ setIconImageCrossFadeTransition(layer, styleValue)
355
+ }
356
+ } catch (e: MapboxStyleException) {
357
+ Logger.e(LOG_TAG, "Failed to update: $styleKey ${e.message}")
343
358
  }
344
359
  }
345
360
  }
@@ -351,55 +366,59 @@ object RNMBXStyleFactory {
351
366
  }
352
367
 
353
368
  for (styleKey in styleKeys) {
354
- val styleValue = style.getStyleValueForKey(styleKey)
355
-
356
- when (styleKey) {
357
- "circleSortKey" ->
358
- setCircleSortKey(layer, styleValue)
359
- "visibility" ->
360
- setVisibility(layer, styleValue)
361
- "circleRadius" ->
362
- setCircleRadius(layer, styleValue)
363
- "circleRadiusTransition" ->
364
- setCircleRadiusTransition(layer, styleValue)
365
- "circleColor" ->
366
- setCircleColor(layer, styleValue)
367
- "circleColorTransition" ->
368
- setCircleColorTransition(layer, styleValue)
369
- "circleBlur" ->
370
- setCircleBlur(layer, styleValue)
371
- "circleBlurTransition" ->
372
- setCircleBlurTransition(layer, styleValue)
373
- "circleOpacity" ->
374
- setCircleOpacity(layer, styleValue)
375
- "circleOpacityTransition" ->
376
- setCircleOpacityTransition(layer, styleValue)
377
- "circleTranslate" ->
378
- setCircleTranslate(layer, styleValue)
379
- "circleTranslateTransition" ->
380
- setCircleTranslateTransition(layer, styleValue)
381
- "circleTranslateAnchor" ->
382
- setCircleTranslateAnchor(layer, styleValue)
383
- "circlePitchScale" ->
384
- setCirclePitchScale(layer, styleValue)
385
- "circlePitchAlignment" ->
386
- setCirclePitchAlignment(layer, styleValue)
387
- "circleStrokeWidth" ->
388
- setCircleStrokeWidth(layer, styleValue)
389
- "circleStrokeWidthTransition" ->
390
- setCircleStrokeWidthTransition(layer, styleValue)
391
- "circleStrokeColor" ->
392
- setCircleStrokeColor(layer, styleValue)
393
- "circleStrokeColorTransition" ->
394
- setCircleStrokeColorTransition(layer, styleValue)
395
- "circleStrokeOpacity" ->
396
- setCircleStrokeOpacity(layer, styleValue)
397
- "circleStrokeOpacityTransition" ->
398
- setCircleStrokeOpacityTransition(layer, styleValue)
399
- "circleEmissiveStrength" ->
400
- setCircleEmissiveStrength(layer, styleValue)
401
- "circleEmissiveStrengthTransition" ->
402
- setCircleEmissiveStrengthTransition(layer, styleValue)
369
+ try {
370
+ val styleValue = style.getStyleValueForKey(styleKey)
371
+
372
+ when (styleKey) {
373
+ "circleSortKey" ->
374
+ setCircleSortKey(layer, styleValue)
375
+ "visibility" ->
376
+ setVisibility(layer, styleValue)
377
+ "circleRadius" ->
378
+ setCircleRadius(layer, styleValue)
379
+ "circleRadiusTransition" ->
380
+ setCircleRadiusTransition(layer, styleValue)
381
+ "circleColor" ->
382
+ setCircleColor(layer, styleValue)
383
+ "circleColorTransition" ->
384
+ setCircleColorTransition(layer, styleValue)
385
+ "circleBlur" ->
386
+ setCircleBlur(layer, styleValue)
387
+ "circleBlurTransition" ->
388
+ setCircleBlurTransition(layer, styleValue)
389
+ "circleOpacity" ->
390
+ setCircleOpacity(layer, styleValue)
391
+ "circleOpacityTransition" ->
392
+ setCircleOpacityTransition(layer, styleValue)
393
+ "circleTranslate" ->
394
+ setCircleTranslate(layer, styleValue)
395
+ "circleTranslateTransition" ->
396
+ setCircleTranslateTransition(layer, styleValue)
397
+ "circleTranslateAnchor" ->
398
+ setCircleTranslateAnchor(layer, styleValue)
399
+ "circlePitchScale" ->
400
+ setCirclePitchScale(layer, styleValue)
401
+ "circlePitchAlignment" ->
402
+ setCirclePitchAlignment(layer, styleValue)
403
+ "circleStrokeWidth" ->
404
+ setCircleStrokeWidth(layer, styleValue)
405
+ "circleStrokeWidthTransition" ->
406
+ setCircleStrokeWidthTransition(layer, styleValue)
407
+ "circleStrokeColor" ->
408
+ setCircleStrokeColor(layer, styleValue)
409
+ "circleStrokeColorTransition" ->
410
+ setCircleStrokeColorTransition(layer, styleValue)
411
+ "circleStrokeOpacity" ->
412
+ setCircleStrokeOpacity(layer, styleValue)
413
+ "circleStrokeOpacityTransition" ->
414
+ setCircleStrokeOpacityTransition(layer, styleValue)
415
+ "circleEmissiveStrength" ->
416
+ setCircleEmissiveStrength(layer, styleValue)
417
+ "circleEmissiveStrengthTransition" ->
418
+ setCircleEmissiveStrengthTransition(layer, styleValue)
419
+ }
420
+ } catch (e: MapboxStyleException) {
421
+ Logger.e(LOG_TAG, "Failed to update: $styleKey ${e.message}")
403
422
  }
404
423
  }
405
424
  }
@@ -411,27 +430,31 @@ object RNMBXStyleFactory {
411
430
  }
412
431
 
413
432
  for (styleKey in styleKeys) {
414
- val styleValue = style.getStyleValueForKey(styleKey)
415
-
416
- when (styleKey) {
417
- "visibility" ->
418
- setVisibility(layer, styleValue)
419
- "heatmapRadius" ->
420
- setHeatmapRadius(layer, styleValue)
421
- "heatmapRadiusTransition" ->
422
- setHeatmapRadiusTransition(layer, styleValue)
423
- "heatmapWeight" ->
424
- setHeatmapWeight(layer, styleValue)
425
- "heatmapIntensity" ->
426
- setHeatmapIntensity(layer, styleValue)
427
- "heatmapIntensityTransition" ->
428
- setHeatmapIntensityTransition(layer, styleValue)
429
- "heatmapColor" ->
430
- setHeatmapColor(layer, styleValue)
431
- "heatmapOpacity" ->
432
- setHeatmapOpacity(layer, styleValue)
433
- "heatmapOpacityTransition" ->
434
- setHeatmapOpacityTransition(layer, styleValue)
433
+ try {
434
+ val styleValue = style.getStyleValueForKey(styleKey)
435
+
436
+ when (styleKey) {
437
+ "visibility" ->
438
+ setVisibility(layer, styleValue)
439
+ "heatmapRadius" ->
440
+ setHeatmapRadius(layer, styleValue)
441
+ "heatmapRadiusTransition" ->
442
+ setHeatmapRadiusTransition(layer, styleValue)
443
+ "heatmapWeight" ->
444
+ setHeatmapWeight(layer, styleValue)
445
+ "heatmapIntensity" ->
446
+ setHeatmapIntensity(layer, styleValue)
447
+ "heatmapIntensityTransition" ->
448
+ setHeatmapIntensityTransition(layer, styleValue)
449
+ "heatmapColor" ->
450
+ setHeatmapColor(layer, styleValue)
451
+ "heatmapOpacity" ->
452
+ setHeatmapOpacity(layer, styleValue)
453
+ "heatmapOpacityTransition" ->
454
+ setHeatmapOpacityTransition(layer, styleValue)
455
+ }
456
+ } catch (e: MapboxStyleException) {
457
+ Logger.e(LOG_TAG, "Failed to update: $styleKey ${e.message}")
435
458
  }
436
459
  }
437
460
  }
@@ -443,85 +466,89 @@ object RNMBXStyleFactory {
443
466
  }
444
467
 
445
468
  for (styleKey in styleKeys) {
446
- val styleValue = style.getStyleValueForKey(styleKey)
447
-
448
- when (styleKey) {
449
- "visibility" ->
450
- setVisibility(layer, styleValue)
451
- "fillExtrusionOpacity" ->
452
- setFillExtrusionOpacity(layer, styleValue)
453
- "fillExtrusionOpacityTransition" ->
454
- setFillExtrusionOpacityTransition(layer, styleValue)
455
- "fillExtrusionColor" ->
456
- setFillExtrusionColor(layer, styleValue)
457
- "fillExtrusionColorTransition" ->
458
- setFillExtrusionColorTransition(layer, styleValue)
459
- "fillExtrusionTranslate" ->
460
- setFillExtrusionTranslate(layer, styleValue)
461
- "fillExtrusionTranslateTransition" ->
462
- setFillExtrusionTranslateTransition(layer, styleValue)
463
- "fillExtrusionTranslateAnchor" ->
464
- setFillExtrusionTranslateAnchor(layer, styleValue)
465
- "fillExtrusionPattern" ->
466
- style.addImage(styleValue!!, styleKey, object : OnAllImagesLoaded {
467
- override fun onAllImagesLoaded() {
468
- try {
469
- setFillExtrusionPattern(layer, styleValue)
470
- } catch (exception: RuntimeException) {
471
- e("RNMBXFillExtrusion",String.format("Exception failed during setFillExtrusionPattern: %s", exception.message))
472
- }
473
- }
474
- })
475
- "fillExtrusionHeight" ->
476
- setFillExtrusionHeight(layer, styleValue)
477
- "fillExtrusionHeightTransition" ->
478
- setFillExtrusionHeightTransition(layer, styleValue)
479
- "fillExtrusionBase" ->
480
- setFillExtrusionBase(layer, styleValue)
481
- "fillExtrusionBaseTransition" ->
482
- setFillExtrusionBaseTransition(layer, styleValue)
483
- "fillExtrusionVerticalGradient" ->
484
- setFillExtrusionVerticalGradient(layer, styleValue)
485
- "fillExtrusionRoundedRoof" ->
486
- setFillExtrusionRoundedRoof(layer, styleValue)
487
- "fillExtrusionAmbientOcclusionWallRadius" ->
488
- setFillExtrusionAmbientOcclusionWallRadius(layer, styleValue)
489
- "fillExtrusionAmbientOcclusionWallRadiusTransition" ->
490
- setFillExtrusionAmbientOcclusionWallRadiusTransition(layer, styleValue)
491
- "fillExtrusionAmbientOcclusionGroundRadius" ->
492
- setFillExtrusionAmbientOcclusionGroundRadius(layer, styleValue)
493
- "fillExtrusionAmbientOcclusionGroundRadiusTransition" ->
494
- setFillExtrusionAmbientOcclusionGroundRadiusTransition(layer, styleValue)
495
- "fillExtrusionAmbientOcclusionGroundAttenuation" ->
496
- setFillExtrusionAmbientOcclusionGroundAttenuation(layer, styleValue)
497
- "fillExtrusionAmbientOcclusionGroundAttenuationTransition" ->
498
- setFillExtrusionAmbientOcclusionGroundAttenuationTransition(layer, styleValue)
499
- "fillExtrusionFloodLightColor" ->
500
- setFillExtrusionFloodLightColor(layer, styleValue)
501
- "fillExtrusionFloodLightColorTransition" ->
502
- setFillExtrusionFloodLightColorTransition(layer, styleValue)
503
- "fillExtrusionFloodLightIntensity" ->
504
- setFillExtrusionFloodLightIntensity(layer, styleValue)
505
- "fillExtrusionFloodLightIntensityTransition" ->
506
- setFillExtrusionFloodLightIntensityTransition(layer, styleValue)
507
- "fillExtrusionFloodLightWallRadius" ->
508
- setFillExtrusionFloodLightWallRadius(layer, styleValue)
509
- "fillExtrusionFloodLightWallRadiusTransition" ->
510
- setFillExtrusionFloodLightWallRadiusTransition(layer, styleValue)
511
- "fillExtrusionFloodLightGroundRadius" ->
512
- setFillExtrusionFloodLightGroundRadius(layer, styleValue)
513
- "fillExtrusionFloodLightGroundRadiusTransition" ->
514
- setFillExtrusionFloodLightGroundRadiusTransition(layer, styleValue)
515
- "fillExtrusionFloodLightGroundAttenuation" ->
516
- setFillExtrusionFloodLightGroundAttenuation(layer, styleValue)
517
- "fillExtrusionFloodLightGroundAttenuationTransition" ->
518
- setFillExtrusionFloodLightGroundAttenuationTransition(layer, styleValue)
519
- "fillExtrusionVerticalScale" ->
520
- setFillExtrusionVerticalScale(layer, styleValue)
521
- "fillExtrusionVerticalScaleTransition" ->
522
- setFillExtrusionVerticalScaleTransition(layer, styleValue)
523
- "fillExtrusionCutoffFadeRange" ->
524
- setFillExtrusionCutoffFadeRange(layer, styleValue)
469
+ try {
470
+ val styleValue = style.getStyleValueForKey(styleKey)
471
+
472
+ when (styleKey) {
473
+ "visibility" ->
474
+ setVisibility(layer, styleValue)
475
+ "fillExtrusionOpacity" ->
476
+ setFillExtrusionOpacity(layer, styleValue)
477
+ "fillExtrusionOpacityTransition" ->
478
+ setFillExtrusionOpacityTransition(layer, styleValue)
479
+ "fillExtrusionColor" ->
480
+ setFillExtrusionColor(layer, styleValue)
481
+ "fillExtrusionColorTransition" ->
482
+ setFillExtrusionColorTransition(layer, styleValue)
483
+ "fillExtrusionTranslate" ->
484
+ setFillExtrusionTranslate(layer, styleValue)
485
+ "fillExtrusionTranslateTransition" ->
486
+ setFillExtrusionTranslateTransition(layer, styleValue)
487
+ "fillExtrusionTranslateAnchor" ->
488
+ setFillExtrusionTranslateAnchor(layer, styleValue)
489
+ "fillExtrusionPattern" ->
490
+ style.addImage(styleValue!!, styleKey, object : OnAllImagesLoaded {
491
+ override fun onAllImagesLoaded() {
492
+ try {
493
+ setFillExtrusionPattern(layer, styleValue)
494
+ } catch (exception: RuntimeException) {
495
+ Logger.e("RNMBXFillExtrusion",String.format("Exception failed during setFillExtrusionPattern: %s", exception.message))
496
+ }
497
+ }
498
+ })
499
+ "fillExtrusionHeight" ->
500
+ setFillExtrusionHeight(layer, styleValue)
501
+ "fillExtrusionHeightTransition" ->
502
+ setFillExtrusionHeightTransition(layer, styleValue)
503
+ "fillExtrusionBase" ->
504
+ setFillExtrusionBase(layer, styleValue)
505
+ "fillExtrusionBaseTransition" ->
506
+ setFillExtrusionBaseTransition(layer, styleValue)
507
+ "fillExtrusionVerticalGradient" ->
508
+ setFillExtrusionVerticalGradient(layer, styleValue)
509
+ "fillExtrusionRoundedRoof" ->
510
+ setFillExtrusionRoundedRoof(layer, styleValue)
511
+ "fillExtrusionAmbientOcclusionWallRadius" ->
512
+ setFillExtrusionAmbientOcclusionWallRadius(layer, styleValue)
513
+ "fillExtrusionAmbientOcclusionWallRadiusTransition" ->
514
+ setFillExtrusionAmbientOcclusionWallRadiusTransition(layer, styleValue)
515
+ "fillExtrusionAmbientOcclusionGroundRadius" ->
516
+ setFillExtrusionAmbientOcclusionGroundRadius(layer, styleValue)
517
+ "fillExtrusionAmbientOcclusionGroundRadiusTransition" ->
518
+ setFillExtrusionAmbientOcclusionGroundRadiusTransition(layer, styleValue)
519
+ "fillExtrusionAmbientOcclusionGroundAttenuation" ->
520
+ setFillExtrusionAmbientOcclusionGroundAttenuation(layer, styleValue)
521
+ "fillExtrusionAmbientOcclusionGroundAttenuationTransition" ->
522
+ setFillExtrusionAmbientOcclusionGroundAttenuationTransition(layer, styleValue)
523
+ "fillExtrusionFloodLightColor" ->
524
+ setFillExtrusionFloodLightColor(layer, styleValue)
525
+ "fillExtrusionFloodLightColorTransition" ->
526
+ setFillExtrusionFloodLightColorTransition(layer, styleValue)
527
+ "fillExtrusionFloodLightIntensity" ->
528
+ setFillExtrusionFloodLightIntensity(layer, styleValue)
529
+ "fillExtrusionFloodLightIntensityTransition" ->
530
+ setFillExtrusionFloodLightIntensityTransition(layer, styleValue)
531
+ "fillExtrusionFloodLightWallRadius" ->
532
+ setFillExtrusionFloodLightWallRadius(layer, styleValue)
533
+ "fillExtrusionFloodLightWallRadiusTransition" ->
534
+ setFillExtrusionFloodLightWallRadiusTransition(layer, styleValue)
535
+ "fillExtrusionFloodLightGroundRadius" ->
536
+ setFillExtrusionFloodLightGroundRadius(layer, styleValue)
537
+ "fillExtrusionFloodLightGroundRadiusTransition" ->
538
+ setFillExtrusionFloodLightGroundRadiusTransition(layer, styleValue)
539
+ "fillExtrusionFloodLightGroundAttenuation" ->
540
+ setFillExtrusionFloodLightGroundAttenuation(layer, styleValue)
541
+ "fillExtrusionFloodLightGroundAttenuationTransition" ->
542
+ setFillExtrusionFloodLightGroundAttenuationTransition(layer, styleValue)
543
+ "fillExtrusionVerticalScale" ->
544
+ setFillExtrusionVerticalScale(layer, styleValue)
545
+ "fillExtrusionVerticalScaleTransition" ->
546
+ setFillExtrusionVerticalScaleTransition(layer, styleValue)
547
+ "fillExtrusionCutoffFadeRange" ->
548
+ setFillExtrusionCutoffFadeRange(layer, styleValue)
549
+ }
550
+ } catch (e: MapboxStyleException) {
551
+ Logger.e(LOG_TAG, "Failed to update: $styleKey ${e.message}")
525
552
  }
526
553
  }
527
554
  }
@@ -533,49 +560,53 @@ object RNMBXStyleFactory {
533
560
  }
534
561
 
535
562
  for (styleKey in styleKeys) {
536
- val styleValue = style.getStyleValueForKey(styleKey)
537
-
538
- when (styleKey) {
539
- "visibility" ->
540
- setVisibility(layer, styleValue)
541
- "rasterOpacity" ->
542
- setRasterOpacity(layer, styleValue)
543
- "rasterOpacityTransition" ->
544
- setRasterOpacityTransition(layer, styleValue)
545
- "rasterHueRotate" ->
546
- setRasterHueRotate(layer, styleValue)
547
- "rasterHueRotateTransition" ->
548
- setRasterHueRotateTransition(layer, styleValue)
549
- "rasterBrightnessMin" ->
550
- setRasterBrightnessMin(layer, styleValue)
551
- "rasterBrightnessMinTransition" ->
552
- setRasterBrightnessMinTransition(layer, styleValue)
553
- "rasterBrightnessMax" ->
554
- setRasterBrightnessMax(layer, styleValue)
555
- "rasterBrightnessMaxTransition" ->
556
- setRasterBrightnessMaxTransition(layer, styleValue)
557
- "rasterSaturation" ->
558
- setRasterSaturation(layer, styleValue)
559
- "rasterSaturationTransition" ->
560
- setRasterSaturationTransition(layer, styleValue)
561
- "rasterContrast" ->
562
- setRasterContrast(layer, styleValue)
563
- "rasterContrastTransition" ->
564
- setRasterContrastTransition(layer, styleValue)
565
- "rasterResampling" ->
566
- setRasterResampling(layer, styleValue)
567
- "rasterFadeDuration" ->
568
- setRasterFadeDuration(layer, styleValue)
569
- "rasterColor" ->
570
- setRasterColor(layer, styleValue)
571
- "rasterColorMix" ->
572
- setRasterColorMix(layer, styleValue)
573
- "rasterColorMixTransition" ->
574
- setRasterColorMixTransition(layer, styleValue)
575
- "rasterColorRange" ->
576
- setRasterColorRange(layer, styleValue)
577
- "rasterColorRangeTransition" ->
578
- setRasterColorRangeTransition(layer, styleValue)
563
+ try {
564
+ val styleValue = style.getStyleValueForKey(styleKey)
565
+
566
+ when (styleKey) {
567
+ "visibility" ->
568
+ setVisibility(layer, styleValue)
569
+ "rasterOpacity" ->
570
+ setRasterOpacity(layer, styleValue)
571
+ "rasterOpacityTransition" ->
572
+ setRasterOpacityTransition(layer, styleValue)
573
+ "rasterHueRotate" ->
574
+ setRasterHueRotate(layer, styleValue)
575
+ "rasterHueRotateTransition" ->
576
+ setRasterHueRotateTransition(layer, styleValue)
577
+ "rasterBrightnessMin" ->
578
+ setRasterBrightnessMin(layer, styleValue)
579
+ "rasterBrightnessMinTransition" ->
580
+ setRasterBrightnessMinTransition(layer, styleValue)
581
+ "rasterBrightnessMax" ->
582
+ setRasterBrightnessMax(layer, styleValue)
583
+ "rasterBrightnessMaxTransition" ->
584
+ setRasterBrightnessMaxTransition(layer, styleValue)
585
+ "rasterSaturation" ->
586
+ setRasterSaturation(layer, styleValue)
587
+ "rasterSaturationTransition" ->
588
+ setRasterSaturationTransition(layer, styleValue)
589
+ "rasterContrast" ->
590
+ setRasterContrast(layer, styleValue)
591
+ "rasterContrastTransition" ->
592
+ setRasterContrastTransition(layer, styleValue)
593
+ "rasterResampling" ->
594
+ setRasterResampling(layer, styleValue)
595
+ "rasterFadeDuration" ->
596
+ setRasterFadeDuration(layer, styleValue)
597
+ "rasterColor" ->
598
+ setRasterColor(layer, styleValue)
599
+ "rasterColorMix" ->
600
+ setRasterColorMix(layer, styleValue)
601
+ "rasterColorMixTransition" ->
602
+ setRasterColorMixTransition(layer, styleValue)
603
+ "rasterColorRange" ->
604
+ setRasterColorRange(layer, styleValue)
605
+ "rasterColorRangeTransition" ->
606
+ setRasterColorRangeTransition(layer, styleValue)
607
+ }
608
+ } catch (e: MapboxStyleException) {
609
+ Logger.e(LOG_TAG, "Failed to update: $styleKey ${e.message}")
579
610
  }
580
611
  }
581
612
  }
@@ -587,31 +618,35 @@ object RNMBXStyleFactory {
587
618
  }
588
619
 
589
620
  for (styleKey in styleKeys) {
590
- val styleValue = style.getStyleValueForKey(styleKey)
591
-
592
- when (styleKey) {
593
- "visibility" ->
594
- setVisibility(layer, styleValue)
595
- "hillshadeIlluminationDirection" ->
596
- setHillshadeIlluminationDirection(layer, styleValue)
597
- "hillshadeIlluminationAnchor" ->
598
- setHillshadeIlluminationAnchor(layer, styleValue)
599
- "hillshadeExaggeration" ->
600
- setHillshadeExaggeration(layer, styleValue)
601
- "hillshadeExaggerationTransition" ->
602
- setHillshadeExaggerationTransition(layer, styleValue)
603
- "hillshadeShadowColor" ->
604
- setHillshadeShadowColor(layer, styleValue)
605
- "hillshadeShadowColorTransition" ->
606
- setHillshadeShadowColorTransition(layer, styleValue)
607
- "hillshadeHighlightColor" ->
608
- setHillshadeHighlightColor(layer, styleValue)
609
- "hillshadeHighlightColorTransition" ->
610
- setHillshadeHighlightColorTransition(layer, styleValue)
611
- "hillshadeAccentColor" ->
612
- setHillshadeAccentColor(layer, styleValue)
613
- "hillshadeAccentColorTransition" ->
614
- setHillshadeAccentColorTransition(layer, styleValue)
621
+ try {
622
+ val styleValue = style.getStyleValueForKey(styleKey)
623
+
624
+ when (styleKey) {
625
+ "visibility" ->
626
+ setVisibility(layer, styleValue)
627
+ "hillshadeIlluminationDirection" ->
628
+ setHillshadeIlluminationDirection(layer, styleValue)
629
+ "hillshadeIlluminationAnchor" ->
630
+ setHillshadeIlluminationAnchor(layer, styleValue)
631
+ "hillshadeExaggeration" ->
632
+ setHillshadeExaggeration(layer, styleValue)
633
+ "hillshadeExaggerationTransition" ->
634
+ setHillshadeExaggerationTransition(layer, styleValue)
635
+ "hillshadeShadowColor" ->
636
+ setHillshadeShadowColor(layer, styleValue)
637
+ "hillshadeShadowColorTransition" ->
638
+ setHillshadeShadowColorTransition(layer, styleValue)
639
+ "hillshadeHighlightColor" ->
640
+ setHillshadeHighlightColor(layer, styleValue)
641
+ "hillshadeHighlightColorTransition" ->
642
+ setHillshadeHighlightColorTransition(layer, styleValue)
643
+ "hillshadeAccentColor" ->
644
+ setHillshadeAccentColor(layer, styleValue)
645
+ "hillshadeAccentColorTransition" ->
646
+ setHillshadeAccentColorTransition(layer, styleValue)
647
+ }
648
+ } catch (e: MapboxStyleException) {
649
+ Logger.e(LOG_TAG, "Failed to update: $styleKey ${e.message}")
615
650
  }
616
651
  }
617
652
  }
@@ -623,61 +658,65 @@ object RNMBXStyleFactory {
623
658
  }
624
659
 
625
660
  for (styleKey in styleKeys) {
626
- val styleValue = style.getStyleValueForKey(styleKey)
627
-
628
- when (styleKey) {
629
- "visibility" ->
630
- setVisibility(layer, styleValue)
631
- "modelId" ->
632
- setModelId(layer, styleValue)
633
- "modelOpacity" ->
634
- setModelOpacity(layer, styleValue)
635
- "modelOpacityTransition" ->
636
- setModelOpacityTransition(layer, styleValue)
637
- "modelRotation" ->
638
- setModelRotation(layer, styleValue)
639
- "modelRotationTransition" ->
640
- setModelRotationTransition(layer, styleValue)
641
- "modelScale" ->
642
- setModelScale(layer, styleValue)
643
- "modelScaleTransition" ->
644
- setModelScaleTransition(layer, styleValue)
645
- "modelTranslation" ->
646
- setModelTranslation(layer, styleValue)
647
- "modelTranslationTransition" ->
648
- setModelTranslationTransition(layer, styleValue)
649
- "modelColor" ->
650
- setModelColor(layer, styleValue)
651
- "modelColorTransition" ->
652
- setModelColorTransition(layer, styleValue)
653
- "modelColorMixIntensity" ->
654
- setModelColorMixIntensity(layer, styleValue)
655
- "modelColorMixIntensityTransition" ->
656
- setModelColorMixIntensityTransition(layer, styleValue)
657
- "modelType" ->
658
- setModelType(layer, styleValue)
659
- "modelCastShadows" ->
660
- setModelCastShadows(layer, styleValue)
661
- "modelReceiveShadows" ->
662
- setModelReceiveShadows(layer, styleValue)
663
- "modelAmbientOcclusionIntensity" ->
664
- setModelAmbientOcclusionIntensity(layer, styleValue)
665
- "modelAmbientOcclusionIntensityTransition" ->
666
- setModelAmbientOcclusionIntensityTransition(layer, styleValue)
667
- "modelEmissiveStrength" ->
668
- setModelEmissiveStrength(layer, styleValue)
669
- "modelEmissiveStrengthTransition" ->
670
- setModelEmissiveStrengthTransition(layer, styleValue)
671
- "modelRoughness" ->
672
- setModelRoughness(layer, styleValue)
673
- "modelRoughnessTransition" ->
674
- setModelRoughnessTransition(layer, styleValue)
675
- "modelHeightBasedEmissiveStrengthMultiplier" ->
676
- setModelHeightBasedEmissiveStrengthMultiplier(layer, styleValue)
677
- "modelHeightBasedEmissiveStrengthMultiplierTransition" ->
678
- setModelHeightBasedEmissiveStrengthMultiplierTransition(layer, styleValue)
679
- "modelCutoffFadeRange" ->
680
- setModelCutoffFadeRange(layer, styleValue)
661
+ try {
662
+ val styleValue = style.getStyleValueForKey(styleKey)
663
+
664
+ when (styleKey) {
665
+ "visibility" ->
666
+ setVisibility(layer, styleValue)
667
+ "modelId" ->
668
+ setModelId(layer, styleValue)
669
+ "modelOpacity" ->
670
+ setModelOpacity(layer, styleValue)
671
+ "modelOpacityTransition" ->
672
+ setModelOpacityTransition(layer, styleValue)
673
+ "modelRotation" ->
674
+ setModelRotation(layer, styleValue)
675
+ "modelRotationTransition" ->
676
+ setModelRotationTransition(layer, styleValue)
677
+ "modelScale" ->
678
+ setModelScale(layer, styleValue)
679
+ "modelScaleTransition" ->
680
+ setModelScaleTransition(layer, styleValue)
681
+ "modelTranslation" ->
682
+ setModelTranslation(layer, styleValue)
683
+ "modelTranslationTransition" ->
684
+ setModelTranslationTransition(layer, styleValue)
685
+ "modelColor" ->
686
+ setModelColor(layer, styleValue)
687
+ "modelColorTransition" ->
688
+ setModelColorTransition(layer, styleValue)
689
+ "modelColorMixIntensity" ->
690
+ setModelColorMixIntensity(layer, styleValue)
691
+ "modelColorMixIntensityTransition" ->
692
+ setModelColorMixIntensityTransition(layer, styleValue)
693
+ "modelType" ->
694
+ setModelType(layer, styleValue)
695
+ "modelCastShadows" ->
696
+ setModelCastShadows(layer, styleValue)
697
+ "modelReceiveShadows" ->
698
+ setModelReceiveShadows(layer, styleValue)
699
+ "modelAmbientOcclusionIntensity" ->
700
+ setModelAmbientOcclusionIntensity(layer, styleValue)
701
+ "modelAmbientOcclusionIntensityTransition" ->
702
+ setModelAmbientOcclusionIntensityTransition(layer, styleValue)
703
+ "modelEmissiveStrength" ->
704
+ setModelEmissiveStrength(layer, styleValue)
705
+ "modelEmissiveStrengthTransition" ->
706
+ setModelEmissiveStrengthTransition(layer, styleValue)
707
+ "modelRoughness" ->
708
+ setModelRoughness(layer, styleValue)
709
+ "modelRoughnessTransition" ->
710
+ setModelRoughnessTransition(layer, styleValue)
711
+ "modelHeightBasedEmissiveStrengthMultiplier" ->
712
+ setModelHeightBasedEmissiveStrengthMultiplier(layer, styleValue)
713
+ "modelHeightBasedEmissiveStrengthMultiplierTransition" ->
714
+ setModelHeightBasedEmissiveStrengthMultiplierTransition(layer, styleValue)
715
+ "modelCutoffFadeRange" ->
716
+ setModelCutoffFadeRange(layer, styleValue)
717
+ }
718
+ } catch (e: MapboxStyleException) {
719
+ Logger.e(LOG_TAG, "Failed to update: $styleKey ${e.message}")
681
720
  }
682
721
  }
683
722
  }
@@ -689,33 +728,37 @@ object RNMBXStyleFactory {
689
728
  }
690
729
 
691
730
  for (styleKey in styleKeys) {
692
- val styleValue = style.getStyleValueForKey(styleKey)
693
-
694
- when (styleKey) {
695
- "visibility" ->
696
- setVisibility(layer, styleValue)
697
- "backgroundColor" ->
698
- setBackgroundColor(layer, styleValue)
699
- "backgroundColorTransition" ->
700
- setBackgroundColorTransition(layer, styleValue)
701
- "backgroundPattern" ->
702
- style.addImage(styleValue!!, styleKey, object : OnAllImagesLoaded {
703
- override fun onAllImagesLoaded() {
704
- try {
705
- setBackgroundPattern(layer, styleValue)
706
- } catch (exception: RuntimeException) {
707
- e("RNMBXBackground",String.format("Exception failed during setBackgroundPattern: %s", exception.message))
708
- }
709
- }
710
- })
711
- "backgroundOpacity" ->
712
- setBackgroundOpacity(layer, styleValue)
713
- "backgroundOpacityTransition" ->
714
- setBackgroundOpacityTransition(layer, styleValue)
715
- "backgroundEmissiveStrength" ->
716
- setBackgroundEmissiveStrength(layer, styleValue)
717
- "backgroundEmissiveStrengthTransition" ->
718
- setBackgroundEmissiveStrengthTransition(layer, styleValue)
731
+ try {
732
+ val styleValue = style.getStyleValueForKey(styleKey)
733
+
734
+ when (styleKey) {
735
+ "visibility" ->
736
+ setVisibility(layer, styleValue)
737
+ "backgroundColor" ->
738
+ setBackgroundColor(layer, styleValue)
739
+ "backgroundColorTransition" ->
740
+ setBackgroundColorTransition(layer, styleValue)
741
+ "backgroundPattern" ->
742
+ style.addImage(styleValue!!, styleKey, object : OnAllImagesLoaded {
743
+ override fun onAllImagesLoaded() {
744
+ try {
745
+ setBackgroundPattern(layer, styleValue)
746
+ } catch (exception: RuntimeException) {
747
+ Logger.e("RNMBXBackground",String.format("Exception failed during setBackgroundPattern: %s", exception.message))
748
+ }
749
+ }
750
+ })
751
+ "backgroundOpacity" ->
752
+ setBackgroundOpacity(layer, styleValue)
753
+ "backgroundOpacityTransition" ->
754
+ setBackgroundOpacityTransition(layer, styleValue)
755
+ "backgroundEmissiveStrength" ->
756
+ setBackgroundEmissiveStrength(layer, styleValue)
757
+ "backgroundEmissiveStrengthTransition" ->
758
+ setBackgroundEmissiveStrengthTransition(layer, styleValue)
759
+ }
760
+ } catch (e: MapboxStyleException) {
761
+ Logger.e(LOG_TAG, "Failed to update: $styleKey ${e.message}")
719
762
  }
720
763
  }
721
764
  }
@@ -727,31 +770,35 @@ object RNMBXStyleFactory {
727
770
  }
728
771
 
729
772
  for (styleKey in styleKeys) {
730
- val styleValue = style.getStyleValueForKey(styleKey)
731
-
732
- when (styleKey) {
733
- "visibility" ->
734
- setVisibility(layer, styleValue)
735
- "skyType" ->
736
- setSkyType(layer, styleValue)
737
- "skyAtmosphereSun" ->
738
- setSkyAtmosphereSun(layer, styleValue)
739
- "skyAtmosphereSunIntensity" ->
740
- setSkyAtmosphereSunIntensity(layer, styleValue)
741
- "skyGradientCenter" ->
742
- setSkyGradientCenter(layer, styleValue)
743
- "skyGradientRadius" ->
744
- setSkyGradientRadius(layer, styleValue)
745
- "skyGradient" ->
746
- setSkyGradient(layer, styleValue)
747
- "skyAtmosphereHaloColor" ->
748
- setSkyAtmosphereHaloColor(layer, styleValue)
749
- "skyAtmosphereColor" ->
750
- setSkyAtmosphereColor(layer, styleValue)
751
- "skyOpacity" ->
752
- setSkyOpacity(layer, styleValue)
753
- "skyOpacityTransition" ->
754
- setSkyOpacityTransition(layer, styleValue)
773
+ try {
774
+ val styleValue = style.getStyleValueForKey(styleKey)
775
+
776
+ when (styleKey) {
777
+ "visibility" ->
778
+ setVisibility(layer, styleValue)
779
+ "skyType" ->
780
+ setSkyType(layer, styleValue)
781
+ "skyAtmosphereSun" ->
782
+ setSkyAtmosphereSun(layer, styleValue)
783
+ "skyAtmosphereSunIntensity" ->
784
+ setSkyAtmosphereSunIntensity(layer, styleValue)
785
+ "skyGradientCenter" ->
786
+ setSkyGradientCenter(layer, styleValue)
787
+ "skyGradientRadius" ->
788
+ setSkyGradientRadius(layer, styleValue)
789
+ "skyGradient" ->
790
+ setSkyGradient(layer, styleValue)
791
+ "skyAtmosphereHaloColor" ->
792
+ setSkyAtmosphereHaloColor(layer, styleValue)
793
+ "skyAtmosphereColor" ->
794
+ setSkyAtmosphereColor(layer, styleValue)
795
+ "skyOpacity" ->
796
+ setSkyOpacity(layer, styleValue)
797
+ "skyOpacityTransition" ->
798
+ setSkyOpacityTransition(layer, styleValue)
799
+ }
800
+ } catch (e: MapboxStyleException) {
801
+ Logger.e(LOG_TAG, "Failed to update: $styleKey ${e.message}")
755
802
  }
756
803
  }
757
804
  }
@@ -763,23 +810,27 @@ object RNMBXStyleFactory {
763
810
  }
764
811
 
765
812
  for (styleKey in styleKeys) {
766
- val styleValue = style.getStyleValueForKey(styleKey)
767
-
768
- when (styleKey) {
769
- "anchor" ->
770
- setAnchor(layer, styleValue)
771
- "position" ->
772
- setPosition(layer, styleValue)
773
- "positionTransition" ->
774
- setPositionTransition(layer, styleValue)
775
- "color" ->
776
- setColor(layer, styleValue)
777
- "colorTransition" ->
778
- setColorTransition(layer, styleValue)
779
- "intensity" ->
780
- setIntensity(layer, styleValue)
781
- "intensityTransition" ->
782
- setIntensityTransition(layer, styleValue)
813
+ try {
814
+ val styleValue = style.getStyleValueForKey(styleKey)
815
+
816
+ when (styleKey) {
817
+ "anchor" ->
818
+ setAnchor(layer, styleValue)
819
+ "position" ->
820
+ setPosition(layer, styleValue)
821
+ "positionTransition" ->
822
+ setPositionTransition(layer, styleValue)
823
+ "color" ->
824
+ setColor(layer, styleValue)
825
+ "colorTransition" ->
826
+ setColorTransition(layer, styleValue)
827
+ "intensity" ->
828
+ setIntensity(layer, styleValue)
829
+ "intensityTransition" ->
830
+ setIntensityTransition(layer, styleValue)
831
+ }
832
+ } catch (e: MapboxStyleException) {
833
+ Logger.e(LOG_TAG, "Failed to update: $styleKey ${e.message}")
783
834
  }
784
835
  }
785
836
  }
@@ -791,37 +842,41 @@ object RNMBXStyleFactory {
791
842
  }
792
843
 
793
844
  for (styleKey in styleKeys) {
794
- val styleValue = style.getStyleValueForKey(styleKey)
795
-
796
- when (styleKey) {
797
- "range" ->
798
- setRange(layer, styleValue)
799
- "rangeTransition" ->
800
- setRangeTransition(layer, styleValue)
801
- "color" ->
802
- setColor(layer, styleValue)
803
- "colorTransition" ->
804
- setColorTransition(layer, styleValue)
805
- "highColor" ->
806
- setHighColor(layer, styleValue)
807
- "highColorTransition" ->
808
- setHighColorTransition(layer, styleValue)
809
- "spaceColor" ->
810
- setSpaceColor(layer, styleValue)
811
- "spaceColorTransition" ->
812
- setSpaceColorTransition(layer, styleValue)
813
- "horizonBlend" ->
814
- setHorizonBlend(layer, styleValue)
815
- "horizonBlendTransition" ->
816
- setHorizonBlendTransition(layer, styleValue)
817
- "starIntensity" ->
818
- setStarIntensity(layer, styleValue)
819
- "starIntensityTransition" ->
820
- setStarIntensityTransition(layer, styleValue)
821
- "verticalRange" ->
822
- setVerticalRange(layer, styleValue)
823
- "verticalRangeTransition" ->
824
- setVerticalRangeTransition(layer, styleValue)
845
+ try {
846
+ val styleValue = style.getStyleValueForKey(styleKey)
847
+
848
+ when (styleKey) {
849
+ "range" ->
850
+ setRange(layer, styleValue)
851
+ "rangeTransition" ->
852
+ setRangeTransition(layer, styleValue)
853
+ "color" ->
854
+ setColor(layer, styleValue)
855
+ "colorTransition" ->
856
+ setColorTransition(layer, styleValue)
857
+ "highColor" ->
858
+ setHighColor(layer, styleValue)
859
+ "highColorTransition" ->
860
+ setHighColorTransition(layer, styleValue)
861
+ "spaceColor" ->
862
+ setSpaceColor(layer, styleValue)
863
+ "spaceColorTransition" ->
864
+ setSpaceColorTransition(layer, styleValue)
865
+ "horizonBlend" ->
866
+ setHorizonBlend(layer, styleValue)
867
+ "horizonBlendTransition" ->
868
+ setHorizonBlendTransition(layer, styleValue)
869
+ "starIntensity" ->
870
+ setStarIntensity(layer, styleValue)
871
+ "starIntensityTransition" ->
872
+ setStarIntensityTransition(layer, styleValue)
873
+ "verticalRange" ->
874
+ setVerticalRange(layer, styleValue)
875
+ "verticalRangeTransition" ->
876
+ setVerticalRangeTransition(layer, styleValue)
877
+ }
878
+ } catch (e: MapboxStyleException) {
879
+ Logger.e(LOG_TAG, "Failed to update: $styleKey ${e.message}")
825
880
  }
826
881
  }
827
882
  }
@@ -833,11 +888,15 @@ object RNMBXStyleFactory {
833
888
  }
834
889
 
835
890
  for (styleKey in styleKeys) {
836
- val styleValue = style.getStyleValueForKey(styleKey)
891
+ try {
892
+ val styleValue = style.getStyleValueForKey(styleKey)
837
893
 
838
- when (styleKey) {
839
- "exaggeration" ->
840
- setExaggeration(layer, styleValue)
894
+ when (styleKey) {
895
+ "exaggeration" ->
896
+ setExaggeration(layer, styleValue)
897
+ }
898
+ } catch (e: MapboxStyleException) {
899
+ Logger.e(LOG_TAG, "Failed to update: $styleKey ${e.message}")
841
900
  }
842
901
  }
843
902
  }
@@ -848,14 +907,14 @@ object RNMBXStyleFactory {
848
907
  if (expression != null) {
849
908
  layer.fillSortKey(expression)
850
909
  } else {
851
- e("RNMBXFill", "Expression for fillSortKey is null")
910
+ Logger.e("RNMBXFill", "Expression for fillSortKey is null")
852
911
  }
853
912
  } else {
854
913
  val value = styleValue.getDouble(VALUE_KEY)
855
914
  if (value != null) {
856
915
  layer.fillSortKey(value)
857
916
  } else {
858
- e("RNMBXFill", "value for fillSortKey is null")
917
+ Logger.e("RNMBXFill", "value for fillSortKey is null")
859
918
  }
860
919
  }
861
920
  }
@@ -870,14 +929,14 @@ object RNMBXStyleFactory {
870
929
  if (expression != null) {
871
930
  layer.fillAntialias(expression)
872
931
  } else {
873
- e("RNMBXFill", "Expression for fillAntialias is null")
932
+ Logger.e("RNMBXFill", "Expression for fillAntialias is null")
874
933
  }
875
934
  } else {
876
935
  val value = styleValue.getBoolean(VALUE_KEY)
877
936
  if (value != null) {
878
937
  layer.fillAntialias(value)
879
938
  } else {
880
- e("RNMBXFill", "value for fillAntialias is null")
939
+ Logger.e("RNMBXFill", "value for fillAntialias is null")
881
940
  }
882
941
  }
883
942
  }
@@ -888,14 +947,14 @@ object RNMBXStyleFactory {
888
947
  if (expression != null) {
889
948
  layer.fillOpacity(expression)
890
949
  } else {
891
- e("RNMBXFill", "Expression for fillOpacity is null")
950
+ Logger.e("RNMBXFill", "Expression for fillOpacity is null")
892
951
  }
893
952
  } else {
894
953
  val value = styleValue.getDouble(VALUE_KEY)
895
954
  if (value != null) {
896
955
  layer.fillOpacity(value)
897
956
  } else {
898
- e("RNMBXFill", "value for fillOpacity is null")
957
+ Logger.e("RNMBXFill", "value for fillOpacity is null")
899
958
  }
900
959
  }
901
960
  }
@@ -914,14 +973,14 @@ object RNMBXStyleFactory {
914
973
  if (expression != null) {
915
974
  layer.fillColor(expression)
916
975
  } else {
917
- e("RNMBXFill", "Expression for fillColor is null")
976
+ Logger.e("RNMBXFill", "Expression for fillColor is null")
918
977
  }
919
978
  } else {
920
979
  val value = styleValue.getInt(VALUE_KEY)
921
980
  if (value != null) {
922
981
  layer.fillColor(value)
923
982
  } else {
924
- e("RNMBXFill", "value for fillColor is null")
983
+ Logger.e("RNMBXFill", "value for fillColor is null")
925
984
  }
926
985
  }
927
986
  }
@@ -940,14 +999,14 @@ object RNMBXStyleFactory {
940
999
  if (expression != null) {
941
1000
  layer.fillOutlineColor(expression)
942
1001
  } else {
943
- e("RNMBXFill", "Expression for fillOutlineColor is null")
1002
+ Logger.e("RNMBXFill", "Expression for fillOutlineColor is null")
944
1003
  }
945
1004
  } else {
946
1005
  val value = styleValue.getInt(VALUE_KEY)
947
1006
  if (value != null) {
948
1007
  layer.fillOutlineColor(value)
949
1008
  } else {
950
- e("RNMBXFill", "value for fillOutlineColor is null")
1009
+ Logger.e("RNMBXFill", "value for fillOutlineColor is null")
951
1010
  }
952
1011
  }
953
1012
  }
@@ -966,14 +1025,14 @@ object RNMBXStyleFactory {
966
1025
  if (expression != null) {
967
1026
  layer.fillTranslate(expression)
968
1027
  } else {
969
- e("RNMBXFill", "Expression for fillTranslate is null")
1028
+ Logger.e("RNMBXFill", "Expression for fillTranslate is null")
970
1029
  }
971
1030
  } else {
972
1031
  val value = styleValue.getFloatArray(VALUE_KEY)
973
1032
  if (value != null) {
974
1033
  layer.fillTranslate(value)
975
1034
  } else {
976
- e("RNMBXFill", "value for fillTranslate is null")
1035
+ Logger.e("RNMBXFill", "value for fillTranslate is null")
977
1036
  }
978
1037
  }
979
1038
  }
@@ -992,7 +1051,7 @@ object RNMBXStyleFactory {
992
1051
  if (expression != null) {
993
1052
  layer.fillTranslateAnchor(expression)
994
1053
  } else {
995
- e("RNMBXFill", "Expression for fillTranslateAnchor is null")
1054
+ Logger.e("RNMBXFill", "Expression for fillTranslateAnchor is null")
996
1055
  }
997
1056
  } else {
998
1057
  layer.fillTranslateAnchor(FillTranslateAnchor.valueOf(styleValue.getEnumName()))
@@ -1006,14 +1065,14 @@ object RNMBXStyleFactory {
1006
1065
  if (value != null) {
1007
1066
  layer.fillPattern(value)
1008
1067
  } else {
1009
- e("RNMBXFill", "Image for fillPattern is null")
1068
+ Logger.e("RNMBXFill", "Image for fillPattern is null")
1010
1069
  }
1011
1070
  } else {
1012
1071
  val expression = styleValue.getExpression()
1013
1072
  if (expression != null) {
1014
1073
  layer.fillPattern(expression)
1015
1074
  } else {
1016
- e("RNMBXFill", "Expression for fillPattern is null")
1075
+ Logger.e("RNMBXFill", "Expression for fillPattern is null")
1017
1076
  }
1018
1077
  }
1019
1078
  } else {
@@ -1021,7 +1080,7 @@ object RNMBXStyleFactory {
1021
1080
  if (value != null) {
1022
1081
  layer.fillPattern(value);
1023
1082
  } else {
1024
- e("RNMBXFill", "value for fillPattern is null")
1083
+ Logger.e("RNMBXFill", "value for fillPattern is null")
1025
1084
  }
1026
1085
  }
1027
1086
  }
@@ -1032,14 +1091,14 @@ object RNMBXStyleFactory {
1032
1091
  if (expression != null) {
1033
1092
  layer.fillEmissiveStrength(expression)
1034
1093
  } else {
1035
- e("RNMBXFill", "Expression for fillEmissiveStrength is null")
1094
+ Logger.e("RNMBXFill", "Expression for fillEmissiveStrength is null")
1036
1095
  }
1037
1096
  } else {
1038
1097
  val value = styleValue.getDouble(VALUE_KEY)
1039
1098
  if (value != null) {
1040
1099
  layer.fillEmissiveStrength(value)
1041
1100
  } else {
1042
- e("RNMBXFill", "value for fillEmissiveStrength is null")
1101
+ Logger.e("RNMBXFill", "value for fillEmissiveStrength is null")
1043
1102
  }
1044
1103
  }
1045
1104
  }
@@ -1058,7 +1117,7 @@ object RNMBXStyleFactory {
1058
1117
  if (expression != null) {
1059
1118
  layer.lineCap(expression)
1060
1119
  } else {
1061
- e("RNMBXLine", "Expression for lineCap is null")
1120
+ Logger.e("RNMBXLine", "Expression for lineCap is null")
1062
1121
  }
1063
1122
  } else {
1064
1123
  layer.lineCap(LineCap.valueOf(styleValue.getEnumName()))
@@ -1071,7 +1130,7 @@ object RNMBXStyleFactory {
1071
1130
  if (expression != null) {
1072
1131
  layer.lineJoin(expression)
1073
1132
  } else {
1074
- e("RNMBXLine", "Expression for lineJoin is null")
1133
+ Logger.e("RNMBXLine", "Expression for lineJoin is null")
1075
1134
  }
1076
1135
  } else {
1077
1136
  layer.lineJoin(LineJoin.valueOf(styleValue.getEnumName()))
@@ -1084,14 +1143,14 @@ object RNMBXStyleFactory {
1084
1143
  if (expression != null) {
1085
1144
  layer.lineMiterLimit(expression)
1086
1145
  } else {
1087
- e("RNMBXLine", "Expression for lineMiterLimit is null")
1146
+ Logger.e("RNMBXLine", "Expression for lineMiterLimit is null")
1088
1147
  }
1089
1148
  } else {
1090
1149
  val value = styleValue.getDouble(VALUE_KEY)
1091
1150
  if (value != null) {
1092
1151
  layer.lineMiterLimit(value)
1093
1152
  } else {
1094
- e("RNMBXLine", "value for lineMiterLimit is null")
1153
+ Logger.e("RNMBXLine", "value for lineMiterLimit is null")
1095
1154
  }
1096
1155
  }
1097
1156
  }
@@ -1102,14 +1161,14 @@ object RNMBXStyleFactory {
1102
1161
  if (expression != null) {
1103
1162
  layer.lineRoundLimit(expression)
1104
1163
  } else {
1105
- e("RNMBXLine", "Expression for lineRoundLimit is null")
1164
+ Logger.e("RNMBXLine", "Expression for lineRoundLimit is null")
1106
1165
  }
1107
1166
  } else {
1108
1167
  val value = styleValue.getDouble(VALUE_KEY)
1109
1168
  if (value != null) {
1110
1169
  layer.lineRoundLimit(value)
1111
1170
  } else {
1112
- e("RNMBXLine", "value for lineRoundLimit is null")
1171
+ Logger.e("RNMBXLine", "value for lineRoundLimit is null")
1113
1172
  }
1114
1173
  }
1115
1174
  }
@@ -1120,14 +1179,14 @@ object RNMBXStyleFactory {
1120
1179
  if (expression != null) {
1121
1180
  layer.lineSortKey(expression)
1122
1181
  } else {
1123
- e("RNMBXLine", "Expression for lineSortKey is null")
1182
+ Logger.e("RNMBXLine", "Expression for lineSortKey is null")
1124
1183
  }
1125
1184
  } else {
1126
1185
  val value = styleValue.getDouble(VALUE_KEY)
1127
1186
  if (value != null) {
1128
1187
  layer.lineSortKey(value)
1129
1188
  } else {
1130
- e("RNMBXLine", "value for lineSortKey is null")
1189
+ Logger.e("RNMBXLine", "value for lineSortKey is null")
1131
1190
  }
1132
1191
  }
1133
1192
  }
@@ -1142,14 +1201,14 @@ object RNMBXStyleFactory {
1142
1201
  if (expression != null) {
1143
1202
  layer.lineOpacity(expression)
1144
1203
  } else {
1145
- e("RNMBXLine", "Expression for lineOpacity is null")
1204
+ Logger.e("RNMBXLine", "Expression for lineOpacity is null")
1146
1205
  }
1147
1206
  } else {
1148
1207
  val value = styleValue.getDouble(VALUE_KEY)
1149
1208
  if (value != null) {
1150
1209
  layer.lineOpacity(value)
1151
1210
  } else {
1152
- e("RNMBXLine", "value for lineOpacity is null")
1211
+ Logger.e("RNMBXLine", "value for lineOpacity is null")
1153
1212
  }
1154
1213
  }
1155
1214
  }
@@ -1168,14 +1227,14 @@ object RNMBXStyleFactory {
1168
1227
  if (expression != null) {
1169
1228
  layer.lineColor(expression)
1170
1229
  } else {
1171
- e("RNMBXLine", "Expression for lineColor is null")
1230
+ Logger.e("RNMBXLine", "Expression for lineColor is null")
1172
1231
  }
1173
1232
  } else {
1174
1233
  val value = styleValue.getInt(VALUE_KEY)
1175
1234
  if (value != null) {
1176
1235
  layer.lineColor(value)
1177
1236
  } else {
1178
- e("RNMBXLine", "value for lineColor is null")
1237
+ Logger.e("RNMBXLine", "value for lineColor is null")
1179
1238
  }
1180
1239
  }
1181
1240
  }
@@ -1194,14 +1253,14 @@ object RNMBXStyleFactory {
1194
1253
  if (expression != null) {
1195
1254
  layer.lineTranslate(expression)
1196
1255
  } else {
1197
- e("RNMBXLine", "Expression for lineTranslate is null")
1256
+ Logger.e("RNMBXLine", "Expression for lineTranslate is null")
1198
1257
  }
1199
1258
  } else {
1200
1259
  val value = styleValue.getFloatArray(VALUE_KEY)
1201
1260
  if (value != null) {
1202
1261
  layer.lineTranslate(value)
1203
1262
  } else {
1204
- e("RNMBXLine", "value for lineTranslate is null")
1263
+ Logger.e("RNMBXLine", "value for lineTranslate is null")
1205
1264
  }
1206
1265
  }
1207
1266
  }
@@ -1220,7 +1279,7 @@ object RNMBXStyleFactory {
1220
1279
  if (expression != null) {
1221
1280
  layer.lineTranslateAnchor(expression)
1222
1281
  } else {
1223
- e("RNMBXLine", "Expression for lineTranslateAnchor is null")
1282
+ Logger.e("RNMBXLine", "Expression for lineTranslateAnchor is null")
1224
1283
  }
1225
1284
  } else {
1226
1285
  layer.lineTranslateAnchor(LineTranslateAnchor.valueOf(styleValue.getEnumName()))
@@ -1233,14 +1292,14 @@ object RNMBXStyleFactory {
1233
1292
  if (expression != null) {
1234
1293
  layer.lineWidth(expression)
1235
1294
  } else {
1236
- e("RNMBXLine", "Expression for lineWidth is null")
1295
+ Logger.e("RNMBXLine", "Expression for lineWidth is null")
1237
1296
  }
1238
1297
  } else {
1239
1298
  val value = styleValue.getDouble(VALUE_KEY)
1240
1299
  if (value != null) {
1241
1300
  layer.lineWidth(value)
1242
1301
  } else {
1243
- e("RNMBXLine", "value for lineWidth is null")
1302
+ Logger.e("RNMBXLine", "value for lineWidth is null")
1244
1303
  }
1245
1304
  }
1246
1305
  }
@@ -1259,14 +1318,14 @@ object RNMBXStyleFactory {
1259
1318
  if (expression != null) {
1260
1319
  layer.lineGapWidth(expression)
1261
1320
  } else {
1262
- e("RNMBXLine", "Expression for lineGapWidth is null")
1321
+ Logger.e("RNMBXLine", "Expression for lineGapWidth is null")
1263
1322
  }
1264
1323
  } else {
1265
1324
  val value = styleValue.getDouble(VALUE_KEY)
1266
1325
  if (value != null) {
1267
1326
  layer.lineGapWidth(value)
1268
1327
  } else {
1269
- e("RNMBXLine", "value for lineGapWidth is null")
1328
+ Logger.e("RNMBXLine", "value for lineGapWidth is null")
1270
1329
  }
1271
1330
  }
1272
1331
  }
@@ -1285,14 +1344,14 @@ object RNMBXStyleFactory {
1285
1344
  if (expression != null) {
1286
1345
  layer.lineOffset(expression)
1287
1346
  } else {
1288
- e("RNMBXLine", "Expression for lineOffset is null")
1347
+ Logger.e("RNMBXLine", "Expression for lineOffset is null")
1289
1348
  }
1290
1349
  } else {
1291
1350
  val value = styleValue.getDouble(VALUE_KEY)
1292
1351
  if (value != null) {
1293
1352
  layer.lineOffset(value)
1294
1353
  } else {
1295
- e("RNMBXLine", "value for lineOffset is null")
1354
+ Logger.e("RNMBXLine", "value for lineOffset is null")
1296
1355
  }
1297
1356
  }
1298
1357
  }
@@ -1311,14 +1370,14 @@ object RNMBXStyleFactory {
1311
1370
  if (expression != null) {
1312
1371
  layer.lineBlur(expression)
1313
1372
  } else {
1314
- e("RNMBXLine", "Expression for lineBlur is null")
1373
+ Logger.e("RNMBXLine", "Expression for lineBlur is null")
1315
1374
  }
1316
1375
  } else {
1317
1376
  val value = styleValue.getDouble(VALUE_KEY)
1318
1377
  if (value != null) {
1319
1378
  layer.lineBlur(value)
1320
1379
  } else {
1321
- e("RNMBXLine", "value for lineBlur is null")
1380
+ Logger.e("RNMBXLine", "value for lineBlur is null")
1322
1381
  }
1323
1382
  }
1324
1383
  }
@@ -1337,14 +1396,14 @@ object RNMBXStyleFactory {
1337
1396
  if (expression != null) {
1338
1397
  layer.lineDasharray(expression)
1339
1398
  } else {
1340
- e("RNMBXLine", "Expression for lineDasharray is null")
1399
+ Logger.e("RNMBXLine", "Expression for lineDasharray is null")
1341
1400
  }
1342
1401
  } else {
1343
1402
  val value = styleValue.getFloatArray(VALUE_KEY)
1344
1403
  if (value != null) {
1345
1404
  layer.lineDasharray(value)
1346
1405
  } else {
1347
- e("RNMBXLine", "value for lineDasharray is null")
1406
+ Logger.e("RNMBXLine", "value for lineDasharray is null")
1348
1407
  }
1349
1408
  }
1350
1409
  }
@@ -1356,14 +1415,14 @@ object RNMBXStyleFactory {
1356
1415
  if (value != null) {
1357
1416
  layer.linePattern(value)
1358
1417
  } else {
1359
- e("RNMBXLine", "Image for linePattern is null")
1418
+ Logger.e("RNMBXLine", "Image for linePattern is null")
1360
1419
  }
1361
1420
  } else {
1362
1421
  val expression = styleValue.getExpression()
1363
1422
  if (expression != null) {
1364
1423
  layer.linePattern(expression)
1365
1424
  } else {
1366
- e("RNMBXLine", "Expression for linePattern is null")
1425
+ Logger.e("RNMBXLine", "Expression for linePattern is null")
1367
1426
  }
1368
1427
  }
1369
1428
  } else {
@@ -1371,7 +1430,7 @@ object RNMBXStyleFactory {
1371
1430
  if (value != null) {
1372
1431
  layer.linePattern(value);
1373
1432
  } else {
1374
- e("RNMBXLine", "value for linePattern is null")
1433
+ Logger.e("RNMBXLine", "value for linePattern is null")
1375
1434
  }
1376
1435
  }
1377
1436
  }
@@ -1382,7 +1441,7 @@ object RNMBXStyleFactory {
1382
1441
  if (expression != null) {
1383
1442
  layer.lineGradient(expression)
1384
1443
  } else {
1385
- e("RNMBXLine", "Expression for lineGradient is null")
1444
+ Logger.e("RNMBXLine", "Expression for lineGradient is null")
1386
1445
  }
1387
1446
  } else {
1388
1447
  layer.lineGradient(styleValue.getIntExpression(VALUE_KEY))
@@ -1395,14 +1454,14 @@ object RNMBXStyleFactory {
1395
1454
  if (expression != null) {
1396
1455
  layer.lineTrimOffset(expression)
1397
1456
  } else {
1398
- e("RNMBXLine", "Expression for lineTrimOffset is null")
1457
+ Logger.e("RNMBXLine", "Expression for lineTrimOffset is null")
1399
1458
  }
1400
1459
  } else {
1401
1460
  val value = styleValue.getFloatArray(VALUE_KEY)
1402
1461
  if (value != null) {
1403
1462
  layer.lineTrimOffset(value)
1404
1463
  } else {
1405
- e("RNMBXLine", "value for lineTrimOffset is null")
1464
+ Logger.e("RNMBXLine", "value for lineTrimOffset is null")
1406
1465
  }
1407
1466
  }
1408
1467
  }
@@ -1413,14 +1472,14 @@ object RNMBXStyleFactory {
1413
1472
  if (expression != null) {
1414
1473
  layer.lineEmissiveStrength(expression)
1415
1474
  } else {
1416
- e("RNMBXLine", "Expression for lineEmissiveStrength is null")
1475
+ Logger.e("RNMBXLine", "Expression for lineEmissiveStrength is null")
1417
1476
  }
1418
1477
  } else {
1419
1478
  val value = styleValue.getDouble(VALUE_KEY)
1420
1479
  if (value != null) {
1421
1480
  layer.lineEmissiveStrength(value)
1422
1481
  } else {
1423
- e("RNMBXLine", "value for lineEmissiveStrength is null")
1482
+ Logger.e("RNMBXLine", "value for lineEmissiveStrength is null")
1424
1483
  }
1425
1484
  }
1426
1485
  }
@@ -1439,7 +1498,7 @@ object RNMBXStyleFactory {
1439
1498
  if (expression != null) {
1440
1499
  layer.symbolPlacement(expression)
1441
1500
  } else {
1442
- e("RNMBXSymbol", "Expression for symbolPlacement is null")
1501
+ Logger.e("RNMBXSymbol", "Expression for symbolPlacement is null")
1443
1502
  }
1444
1503
  } else {
1445
1504
  layer.symbolPlacement(SymbolPlacement.valueOf(styleValue.getEnumName()))
@@ -1452,14 +1511,14 @@ object RNMBXStyleFactory {
1452
1511
  if (expression != null) {
1453
1512
  layer.symbolSpacing(expression)
1454
1513
  } else {
1455
- e("RNMBXSymbol", "Expression for symbolSpacing is null")
1514
+ Logger.e("RNMBXSymbol", "Expression for symbolSpacing is null")
1456
1515
  }
1457
1516
  } else {
1458
1517
  val value = styleValue.getDouble(VALUE_KEY)
1459
1518
  if (value != null) {
1460
1519
  layer.symbolSpacing(value)
1461
1520
  } else {
1462
- e("RNMBXSymbol", "value for symbolSpacing is null")
1521
+ Logger.e("RNMBXSymbol", "value for symbolSpacing is null")
1463
1522
  }
1464
1523
  }
1465
1524
  }
@@ -1470,14 +1529,14 @@ object RNMBXStyleFactory {
1470
1529
  if (expression != null) {
1471
1530
  layer.symbolAvoidEdges(expression)
1472
1531
  } else {
1473
- e("RNMBXSymbol", "Expression for symbolAvoidEdges is null")
1532
+ Logger.e("RNMBXSymbol", "Expression for symbolAvoidEdges is null")
1474
1533
  }
1475
1534
  } else {
1476
1535
  val value = styleValue.getBoolean(VALUE_KEY)
1477
1536
  if (value != null) {
1478
1537
  layer.symbolAvoidEdges(value)
1479
1538
  } else {
1480
- e("RNMBXSymbol", "value for symbolAvoidEdges is null")
1539
+ Logger.e("RNMBXSymbol", "value for symbolAvoidEdges is null")
1481
1540
  }
1482
1541
  }
1483
1542
  }
@@ -1488,14 +1547,14 @@ object RNMBXStyleFactory {
1488
1547
  if (expression != null) {
1489
1548
  layer.symbolSortKey(expression)
1490
1549
  } else {
1491
- e("RNMBXSymbol", "Expression for symbolSortKey is null")
1550
+ Logger.e("RNMBXSymbol", "Expression for symbolSortKey is null")
1492
1551
  }
1493
1552
  } else {
1494
1553
  val value = styleValue.getDouble(VALUE_KEY)
1495
1554
  if (value != null) {
1496
1555
  layer.symbolSortKey(value)
1497
1556
  } else {
1498
- e("RNMBXSymbol", "value for symbolSortKey is null")
1557
+ Logger.e("RNMBXSymbol", "value for symbolSortKey is null")
1499
1558
  }
1500
1559
  }
1501
1560
  }
@@ -1506,7 +1565,7 @@ object RNMBXStyleFactory {
1506
1565
  if (expression != null) {
1507
1566
  layer.symbolZOrder(expression)
1508
1567
  } else {
1509
- e("RNMBXSymbol", "Expression for symbolZOrder is null")
1568
+ Logger.e("RNMBXSymbol", "Expression for symbolZOrder is null")
1510
1569
  }
1511
1570
  } else {
1512
1571
  layer.symbolZOrder(SymbolZOrder.valueOf(styleValue.getEnumName()))
@@ -1519,14 +1578,14 @@ object RNMBXStyleFactory {
1519
1578
  if (expression != null) {
1520
1579
  layer.iconAllowOverlap(expression)
1521
1580
  } else {
1522
- e("RNMBXSymbol", "Expression for iconAllowOverlap is null")
1581
+ Logger.e("RNMBXSymbol", "Expression for iconAllowOverlap is null")
1523
1582
  }
1524
1583
  } else {
1525
1584
  val value = styleValue.getBoolean(VALUE_KEY)
1526
1585
  if (value != null) {
1527
1586
  layer.iconAllowOverlap(value)
1528
1587
  } else {
1529
- e("RNMBXSymbol", "value for iconAllowOverlap is null")
1588
+ Logger.e("RNMBXSymbol", "value for iconAllowOverlap is null")
1530
1589
  }
1531
1590
  }
1532
1591
  }
@@ -1537,14 +1596,14 @@ object RNMBXStyleFactory {
1537
1596
  if (expression != null) {
1538
1597
  layer.iconIgnorePlacement(expression)
1539
1598
  } else {
1540
- e("RNMBXSymbol", "Expression for iconIgnorePlacement is null")
1599
+ Logger.e("RNMBXSymbol", "Expression for iconIgnorePlacement is null")
1541
1600
  }
1542
1601
  } else {
1543
1602
  val value = styleValue.getBoolean(VALUE_KEY)
1544
1603
  if (value != null) {
1545
1604
  layer.iconIgnorePlacement(value)
1546
1605
  } else {
1547
- e("RNMBXSymbol", "value for iconIgnorePlacement is null")
1606
+ Logger.e("RNMBXSymbol", "value for iconIgnorePlacement is null")
1548
1607
  }
1549
1608
  }
1550
1609
  }
@@ -1555,14 +1614,14 @@ object RNMBXStyleFactory {
1555
1614
  if (expression != null) {
1556
1615
  layer.iconOptional(expression)
1557
1616
  } else {
1558
- e("RNMBXSymbol", "Expression for iconOptional is null")
1617
+ Logger.e("RNMBXSymbol", "Expression for iconOptional is null")
1559
1618
  }
1560
1619
  } else {
1561
1620
  val value = styleValue.getBoolean(VALUE_KEY)
1562
1621
  if (value != null) {
1563
1622
  layer.iconOptional(value)
1564
1623
  } else {
1565
- e("RNMBXSymbol", "value for iconOptional is null")
1624
+ Logger.e("RNMBXSymbol", "value for iconOptional is null")
1566
1625
  }
1567
1626
  }
1568
1627
  }
@@ -1573,7 +1632,7 @@ object RNMBXStyleFactory {
1573
1632
  if (expression != null) {
1574
1633
  layer.iconRotationAlignment(expression)
1575
1634
  } else {
1576
- e("RNMBXSymbol", "Expression for iconRotationAlignment is null")
1635
+ Logger.e("RNMBXSymbol", "Expression for iconRotationAlignment is null")
1577
1636
  }
1578
1637
  } else {
1579
1638
  layer.iconRotationAlignment(IconRotationAlignment.valueOf(styleValue.getEnumName()))
@@ -1586,14 +1645,14 @@ object RNMBXStyleFactory {
1586
1645
  if (expression != null) {
1587
1646
  layer.iconSize(expression)
1588
1647
  } else {
1589
- e("RNMBXSymbol", "Expression for iconSize is null")
1648
+ Logger.e("RNMBXSymbol", "Expression for iconSize is null")
1590
1649
  }
1591
1650
  } else {
1592
1651
  val value = styleValue.getDouble(VALUE_KEY)
1593
1652
  if (value != null) {
1594
1653
  layer.iconSize(value)
1595
1654
  } else {
1596
- e("RNMBXSymbol", "value for iconSize is null")
1655
+ Logger.e("RNMBXSymbol", "value for iconSize is null")
1597
1656
  }
1598
1657
  }
1599
1658
  }
@@ -1604,7 +1663,7 @@ object RNMBXStyleFactory {
1604
1663
  if (expression != null) {
1605
1664
  layer.iconTextFit(expression)
1606
1665
  } else {
1607
- e("RNMBXSymbol", "Expression for iconTextFit is null")
1666
+ Logger.e("RNMBXSymbol", "Expression for iconTextFit is null")
1608
1667
  }
1609
1668
  } else {
1610
1669
  layer.iconTextFit(IconTextFit.valueOf(styleValue.getEnumName()))
@@ -1617,14 +1676,14 @@ object RNMBXStyleFactory {
1617
1676
  if (expression != null) {
1618
1677
  layer.iconTextFitPadding(expression)
1619
1678
  } else {
1620
- e("RNMBXSymbol", "Expression for iconTextFitPadding is null")
1679
+ Logger.e("RNMBXSymbol", "Expression for iconTextFitPadding is null")
1621
1680
  }
1622
1681
  } else {
1623
1682
  val value = styleValue.getFloatArray(VALUE_KEY)
1624
1683
  if (value != null) {
1625
1684
  layer.iconTextFitPadding(value)
1626
1685
  } else {
1627
- e("RNMBXSymbol", "value for iconTextFitPadding is null")
1686
+ Logger.e("RNMBXSymbol", "value for iconTextFitPadding is null")
1628
1687
  }
1629
1688
  }
1630
1689
  }
@@ -1636,14 +1695,14 @@ object RNMBXStyleFactory {
1636
1695
  if (value != null) {
1637
1696
  layer.iconImage(value)
1638
1697
  } else {
1639
- e("RNMBXSymbol", "Image for iconImage is null")
1698
+ Logger.e("RNMBXSymbol", "Image for iconImage is null")
1640
1699
  }
1641
1700
  } else {
1642
1701
  val expression = styleValue.getExpression()
1643
1702
  if (expression != null) {
1644
1703
  layer.iconImage(expression)
1645
1704
  } else {
1646
- e("RNMBXSymbol", "Expression for iconImage is null")
1705
+ Logger.e("RNMBXSymbol", "Expression for iconImage is null")
1647
1706
  }
1648
1707
  }
1649
1708
  } else {
@@ -1651,7 +1710,7 @@ object RNMBXStyleFactory {
1651
1710
  if (value != null) {
1652
1711
  layer.iconImage(value);
1653
1712
  } else {
1654
- e("RNMBXSymbol", "value for iconImage is null")
1713
+ Logger.e("RNMBXSymbol", "value for iconImage is null")
1655
1714
  }
1656
1715
  }
1657
1716
  }
@@ -1662,14 +1721,14 @@ object RNMBXStyleFactory {
1662
1721
  if (expression != null) {
1663
1722
  layer.iconRotate(expression)
1664
1723
  } else {
1665
- e("RNMBXSymbol", "Expression for iconRotate is null")
1724
+ Logger.e("RNMBXSymbol", "Expression for iconRotate is null")
1666
1725
  }
1667
1726
  } else {
1668
1727
  val value = styleValue.getDouble(VALUE_KEY)
1669
1728
  if (value != null) {
1670
1729
  layer.iconRotate(value)
1671
1730
  } else {
1672
- e("RNMBXSymbol", "value for iconRotate is null")
1731
+ Logger.e("RNMBXSymbol", "value for iconRotate is null")
1673
1732
  }
1674
1733
  }
1675
1734
  }
@@ -1680,14 +1739,14 @@ object RNMBXStyleFactory {
1680
1739
  if (expression != null) {
1681
1740
  layer.iconPadding(expression)
1682
1741
  } else {
1683
- e("RNMBXSymbol", "Expression for iconPadding is null")
1742
+ Logger.e("RNMBXSymbol", "Expression for iconPadding is null")
1684
1743
  }
1685
1744
  } else {
1686
1745
  val value = styleValue.getDouble(VALUE_KEY)
1687
1746
  if (value != null) {
1688
1747
  layer.iconPadding(value)
1689
1748
  } else {
1690
- e("RNMBXSymbol", "value for iconPadding is null")
1749
+ Logger.e("RNMBXSymbol", "value for iconPadding is null")
1691
1750
  }
1692
1751
  }
1693
1752
  }
@@ -1698,14 +1757,14 @@ object RNMBXStyleFactory {
1698
1757
  if (expression != null) {
1699
1758
  layer.iconKeepUpright(expression)
1700
1759
  } else {
1701
- e("RNMBXSymbol", "Expression for iconKeepUpright is null")
1760
+ Logger.e("RNMBXSymbol", "Expression for iconKeepUpright is null")
1702
1761
  }
1703
1762
  } else {
1704
1763
  val value = styleValue.getBoolean(VALUE_KEY)
1705
1764
  if (value != null) {
1706
1765
  layer.iconKeepUpright(value)
1707
1766
  } else {
1708
- e("RNMBXSymbol", "value for iconKeepUpright is null")
1767
+ Logger.e("RNMBXSymbol", "value for iconKeepUpright is null")
1709
1768
  }
1710
1769
  }
1711
1770
  }
@@ -1716,14 +1775,14 @@ object RNMBXStyleFactory {
1716
1775
  if (expression != null) {
1717
1776
  layer.iconOffset(expression)
1718
1777
  } else {
1719
- e("RNMBXSymbol", "Expression for iconOffset is null")
1778
+ Logger.e("RNMBXSymbol", "Expression for iconOffset is null")
1720
1779
  }
1721
1780
  } else {
1722
1781
  val value = styleValue.getFloatArray(VALUE_KEY)
1723
1782
  if (value != null) {
1724
1783
  layer.iconOffset(value)
1725
1784
  } else {
1726
- e("RNMBXSymbol", "value for iconOffset is null")
1785
+ Logger.e("RNMBXSymbol", "value for iconOffset is null")
1727
1786
  }
1728
1787
  }
1729
1788
  }
@@ -1734,7 +1793,7 @@ object RNMBXStyleFactory {
1734
1793
  if (expression != null) {
1735
1794
  layer.iconAnchor(expression)
1736
1795
  } else {
1737
- e("RNMBXSymbol", "Expression for iconAnchor is null")
1796
+ Logger.e("RNMBXSymbol", "Expression for iconAnchor is null")
1738
1797
  }
1739
1798
  } else {
1740
1799
  layer.iconAnchor(IconAnchor.valueOf(styleValue.getEnumName()))
@@ -1747,7 +1806,7 @@ object RNMBXStyleFactory {
1747
1806
  if (expression != null) {
1748
1807
  layer.iconPitchAlignment(expression)
1749
1808
  } else {
1750
- e("RNMBXSymbol", "Expression for iconPitchAlignment is null")
1809
+ Logger.e("RNMBXSymbol", "Expression for iconPitchAlignment is null")
1751
1810
  }
1752
1811
  } else {
1753
1812
  layer.iconPitchAlignment(IconPitchAlignment.valueOf(styleValue.getEnumName()))
@@ -1760,7 +1819,7 @@ object RNMBXStyleFactory {
1760
1819
  if (expression != null) {
1761
1820
  layer.textPitchAlignment(expression)
1762
1821
  } else {
1763
- e("RNMBXSymbol", "Expression for textPitchAlignment is null")
1822
+ Logger.e("RNMBXSymbol", "Expression for textPitchAlignment is null")
1764
1823
  }
1765
1824
  } else {
1766
1825
  layer.textPitchAlignment(TextPitchAlignment.valueOf(styleValue.getEnumName()))
@@ -1773,7 +1832,7 @@ object RNMBXStyleFactory {
1773
1832
  if (expression != null) {
1774
1833
  layer.textRotationAlignment(expression)
1775
1834
  } else {
1776
- e("RNMBXSymbol", "Expression for textRotationAlignment is null")
1835
+ Logger.e("RNMBXSymbol", "Expression for textRotationAlignment is null")
1777
1836
  }
1778
1837
  } else {
1779
1838
  layer.textRotationAlignment(TextRotationAlignment.valueOf(styleValue.getEnumName()))
@@ -1786,14 +1845,14 @@ object RNMBXStyleFactory {
1786
1845
  if (expression != null) {
1787
1846
  layer.textField(expression)
1788
1847
  } else {
1789
- e("RNMBXSymbol", "Expression for textField is null")
1848
+ Logger.e("RNMBXSymbol", "Expression for textField is null")
1790
1849
  }
1791
1850
  } else {
1792
1851
  val value = styleValue.getString(VALUE_KEY)
1793
1852
  if (value != null) {
1794
1853
  layer.textField(value)
1795
1854
  } else {
1796
- e("RNMBXSymbol", "value for textField is null")
1855
+ Logger.e("RNMBXSymbol", "value for textField is null")
1797
1856
  }
1798
1857
  }
1799
1858
  }
@@ -1804,14 +1863,14 @@ object RNMBXStyleFactory {
1804
1863
  if (expression != null) {
1805
1864
  layer.textFont(expression)
1806
1865
  } else {
1807
- e("RNMBXSymbol", "Expression for textFont is null")
1866
+ Logger.e("RNMBXSymbol", "Expression for textFont is null")
1808
1867
  }
1809
1868
  } else {
1810
1869
  val value = styleValue.getStringArray(VALUE_KEY)
1811
1870
  if (value != null) {
1812
1871
  layer.textFont(value)
1813
1872
  } else {
1814
- e("RNMBXSymbol", "value for textFont is null")
1873
+ Logger.e("RNMBXSymbol", "value for textFont is null")
1815
1874
  }
1816
1875
  }
1817
1876
  }
@@ -1822,14 +1881,14 @@ object RNMBXStyleFactory {
1822
1881
  if (expression != null) {
1823
1882
  layer.textSize(expression)
1824
1883
  } else {
1825
- e("RNMBXSymbol", "Expression for textSize is null")
1884
+ Logger.e("RNMBXSymbol", "Expression for textSize is null")
1826
1885
  }
1827
1886
  } else {
1828
1887
  val value = styleValue.getDouble(VALUE_KEY)
1829
1888
  if (value != null) {
1830
1889
  layer.textSize(value)
1831
1890
  } else {
1832
- e("RNMBXSymbol", "value for textSize is null")
1891
+ Logger.e("RNMBXSymbol", "value for textSize is null")
1833
1892
  }
1834
1893
  }
1835
1894
  }
@@ -1840,14 +1899,14 @@ object RNMBXStyleFactory {
1840
1899
  if (expression != null) {
1841
1900
  layer.textMaxWidth(expression)
1842
1901
  } else {
1843
- e("RNMBXSymbol", "Expression for textMaxWidth is null")
1902
+ Logger.e("RNMBXSymbol", "Expression for textMaxWidth is null")
1844
1903
  }
1845
1904
  } else {
1846
1905
  val value = styleValue.getDouble(VALUE_KEY)
1847
1906
  if (value != null) {
1848
1907
  layer.textMaxWidth(value)
1849
1908
  } else {
1850
- e("RNMBXSymbol", "value for textMaxWidth is null")
1909
+ Logger.e("RNMBXSymbol", "value for textMaxWidth is null")
1851
1910
  }
1852
1911
  }
1853
1912
  }
@@ -1858,14 +1917,14 @@ object RNMBXStyleFactory {
1858
1917
  if (expression != null) {
1859
1918
  layer.textLineHeight(expression)
1860
1919
  } else {
1861
- e("RNMBXSymbol", "Expression for textLineHeight is null")
1920
+ Logger.e("RNMBXSymbol", "Expression for textLineHeight is null")
1862
1921
  }
1863
1922
  } else {
1864
1923
  val value = styleValue.getDouble(VALUE_KEY)
1865
1924
  if (value != null) {
1866
1925
  layer.textLineHeight(value)
1867
1926
  } else {
1868
- e("RNMBXSymbol", "value for textLineHeight is null")
1927
+ Logger.e("RNMBXSymbol", "value for textLineHeight is null")
1869
1928
  }
1870
1929
  }
1871
1930
  }
@@ -1876,14 +1935,14 @@ object RNMBXStyleFactory {
1876
1935
  if (expression != null) {
1877
1936
  layer.textLetterSpacing(expression)
1878
1937
  } else {
1879
- e("RNMBXSymbol", "Expression for textLetterSpacing is null")
1938
+ Logger.e("RNMBXSymbol", "Expression for textLetterSpacing is null")
1880
1939
  }
1881
1940
  } else {
1882
1941
  val value = styleValue.getDouble(VALUE_KEY)
1883
1942
  if (value != null) {
1884
1943
  layer.textLetterSpacing(value)
1885
1944
  } else {
1886
- e("RNMBXSymbol", "value for textLetterSpacing is null")
1945
+ Logger.e("RNMBXSymbol", "value for textLetterSpacing is null")
1887
1946
  }
1888
1947
  }
1889
1948
  }
@@ -1894,7 +1953,7 @@ object RNMBXStyleFactory {
1894
1953
  if (expression != null) {
1895
1954
  layer.textJustify(expression)
1896
1955
  } else {
1897
- e("RNMBXSymbol", "Expression for textJustify is null")
1956
+ Logger.e("RNMBXSymbol", "Expression for textJustify is null")
1898
1957
  }
1899
1958
  } else {
1900
1959
  layer.textJustify(TextJustify.valueOf(styleValue.getEnumName()))
@@ -1907,14 +1966,14 @@ object RNMBXStyleFactory {
1907
1966
  if (expression != null) {
1908
1967
  layer.textRadialOffset(expression)
1909
1968
  } else {
1910
- e("RNMBXSymbol", "Expression for textRadialOffset is null")
1969
+ Logger.e("RNMBXSymbol", "Expression for textRadialOffset is null")
1911
1970
  }
1912
1971
  } else {
1913
1972
  val value = styleValue.getDouble(VALUE_KEY)
1914
1973
  if (value != null) {
1915
1974
  layer.textRadialOffset(value)
1916
1975
  } else {
1917
- e("RNMBXSymbol", "value for textRadialOffset is null")
1976
+ Logger.e("RNMBXSymbol", "value for textRadialOffset is null")
1918
1977
  }
1919
1978
  }
1920
1979
  }
@@ -1925,14 +1984,14 @@ object RNMBXStyleFactory {
1925
1984
  if (expression != null) {
1926
1985
  layer.textVariableAnchor(expression)
1927
1986
  } else {
1928
- e("RNMBXSymbol", "Expression for textVariableAnchor is null")
1987
+ Logger.e("RNMBXSymbol", "Expression for textVariableAnchor is null")
1929
1988
  }
1930
1989
  } else {
1931
1990
  val value = styleValue.getStringArray(VALUE_KEY)
1932
1991
  if (value != null) {
1933
1992
  layer.textVariableAnchor(value)
1934
1993
  } else {
1935
- e("RNMBXSymbol", "value for textVariableAnchor is null")
1994
+ Logger.e("RNMBXSymbol", "value for textVariableAnchor is null")
1936
1995
  }
1937
1996
  }
1938
1997
  }
@@ -1943,7 +2002,7 @@ object RNMBXStyleFactory {
1943
2002
  if (expression != null) {
1944
2003
  layer.textAnchor(expression)
1945
2004
  } else {
1946
- e("RNMBXSymbol", "Expression for textAnchor is null")
2005
+ Logger.e("RNMBXSymbol", "Expression for textAnchor is null")
1947
2006
  }
1948
2007
  } else {
1949
2008
  layer.textAnchor(TextAnchor.valueOf(styleValue.getEnumName()))
@@ -1956,14 +2015,14 @@ object RNMBXStyleFactory {
1956
2015
  if (expression != null) {
1957
2016
  layer.textMaxAngle(expression)
1958
2017
  } else {
1959
- e("RNMBXSymbol", "Expression for textMaxAngle is null")
2018
+ Logger.e("RNMBXSymbol", "Expression for textMaxAngle is null")
1960
2019
  }
1961
2020
  } else {
1962
2021
  val value = styleValue.getDouble(VALUE_KEY)
1963
2022
  if (value != null) {
1964
2023
  layer.textMaxAngle(value)
1965
2024
  } else {
1966
- e("RNMBXSymbol", "value for textMaxAngle is null")
2025
+ Logger.e("RNMBXSymbol", "value for textMaxAngle is null")
1967
2026
  }
1968
2027
  }
1969
2028
  }
@@ -1974,14 +2033,14 @@ object RNMBXStyleFactory {
1974
2033
  if (expression != null) {
1975
2034
  layer.textWritingMode(expression)
1976
2035
  } else {
1977
- e("RNMBXSymbol", "Expression for textWritingMode is null")
2036
+ Logger.e("RNMBXSymbol", "Expression for textWritingMode is null")
1978
2037
  }
1979
2038
  } else {
1980
2039
  val value = styleValue.getStringArray(VALUE_KEY)
1981
2040
  if (value != null) {
1982
2041
  layer.textWritingMode(value)
1983
2042
  } else {
1984
- e("RNMBXSymbol", "value for textWritingMode is null")
2043
+ Logger.e("RNMBXSymbol", "value for textWritingMode is null")
1985
2044
  }
1986
2045
  }
1987
2046
  }
@@ -1992,14 +2051,14 @@ object RNMBXStyleFactory {
1992
2051
  if (expression != null) {
1993
2052
  layer.textRotate(expression)
1994
2053
  } else {
1995
- e("RNMBXSymbol", "Expression for textRotate is null")
2054
+ Logger.e("RNMBXSymbol", "Expression for textRotate is null")
1996
2055
  }
1997
2056
  } else {
1998
2057
  val value = styleValue.getDouble(VALUE_KEY)
1999
2058
  if (value != null) {
2000
2059
  layer.textRotate(value)
2001
2060
  } else {
2002
- e("RNMBXSymbol", "value for textRotate is null")
2061
+ Logger.e("RNMBXSymbol", "value for textRotate is null")
2003
2062
  }
2004
2063
  }
2005
2064
  }
@@ -2010,14 +2069,14 @@ object RNMBXStyleFactory {
2010
2069
  if (expression != null) {
2011
2070
  layer.textPadding(expression)
2012
2071
  } else {
2013
- e("RNMBXSymbol", "Expression for textPadding is null")
2072
+ Logger.e("RNMBXSymbol", "Expression for textPadding is null")
2014
2073
  }
2015
2074
  } else {
2016
2075
  val value = styleValue.getDouble(VALUE_KEY)
2017
2076
  if (value != null) {
2018
2077
  layer.textPadding(value)
2019
2078
  } else {
2020
- e("RNMBXSymbol", "value for textPadding is null")
2079
+ Logger.e("RNMBXSymbol", "value for textPadding is null")
2021
2080
  }
2022
2081
  }
2023
2082
  }
@@ -2028,14 +2087,14 @@ object RNMBXStyleFactory {
2028
2087
  if (expression != null) {
2029
2088
  layer.textKeepUpright(expression)
2030
2089
  } else {
2031
- e("RNMBXSymbol", "Expression for textKeepUpright is null")
2090
+ Logger.e("RNMBXSymbol", "Expression for textKeepUpright is null")
2032
2091
  }
2033
2092
  } else {
2034
2093
  val value = styleValue.getBoolean(VALUE_KEY)
2035
2094
  if (value != null) {
2036
2095
  layer.textKeepUpright(value)
2037
2096
  } else {
2038
- e("RNMBXSymbol", "value for textKeepUpright is null")
2097
+ Logger.e("RNMBXSymbol", "value for textKeepUpright is null")
2039
2098
  }
2040
2099
  }
2041
2100
  }
@@ -2046,7 +2105,7 @@ object RNMBXStyleFactory {
2046
2105
  if (expression != null) {
2047
2106
  layer.textTransform(expression)
2048
2107
  } else {
2049
- e("RNMBXSymbol", "Expression for textTransform is null")
2108
+ Logger.e("RNMBXSymbol", "Expression for textTransform is null")
2050
2109
  }
2051
2110
  } else {
2052
2111
  layer.textTransform(TextTransform.valueOf(styleValue.getEnumName()))
@@ -2059,14 +2118,14 @@ object RNMBXStyleFactory {
2059
2118
  if (expression != null) {
2060
2119
  layer.textOffset(expression)
2061
2120
  } else {
2062
- e("RNMBXSymbol", "Expression for textOffset is null")
2121
+ Logger.e("RNMBXSymbol", "Expression for textOffset is null")
2063
2122
  }
2064
2123
  } else {
2065
2124
  val value = styleValue.getFloatArray(VALUE_KEY)
2066
2125
  if (value != null) {
2067
2126
  layer.textOffset(value)
2068
2127
  } else {
2069
- e("RNMBXSymbol", "value for textOffset is null")
2128
+ Logger.e("RNMBXSymbol", "value for textOffset is null")
2070
2129
  }
2071
2130
  }
2072
2131
  }
@@ -2077,14 +2136,14 @@ object RNMBXStyleFactory {
2077
2136
  if (expression != null) {
2078
2137
  layer.textAllowOverlap(expression)
2079
2138
  } else {
2080
- e("RNMBXSymbol", "Expression for textAllowOverlap is null")
2139
+ Logger.e("RNMBXSymbol", "Expression for textAllowOverlap is null")
2081
2140
  }
2082
2141
  } else {
2083
2142
  val value = styleValue.getBoolean(VALUE_KEY)
2084
2143
  if (value != null) {
2085
2144
  layer.textAllowOverlap(value)
2086
2145
  } else {
2087
- e("RNMBXSymbol", "value for textAllowOverlap is null")
2146
+ Logger.e("RNMBXSymbol", "value for textAllowOverlap is null")
2088
2147
  }
2089
2148
  }
2090
2149
  }
@@ -2095,14 +2154,14 @@ object RNMBXStyleFactory {
2095
2154
  if (expression != null) {
2096
2155
  layer.textIgnorePlacement(expression)
2097
2156
  } else {
2098
- e("RNMBXSymbol", "Expression for textIgnorePlacement is null")
2157
+ Logger.e("RNMBXSymbol", "Expression for textIgnorePlacement is null")
2099
2158
  }
2100
2159
  } else {
2101
2160
  val value = styleValue.getBoolean(VALUE_KEY)
2102
2161
  if (value != null) {
2103
2162
  layer.textIgnorePlacement(value)
2104
2163
  } else {
2105
- e("RNMBXSymbol", "value for textIgnorePlacement is null")
2164
+ Logger.e("RNMBXSymbol", "value for textIgnorePlacement is null")
2106
2165
  }
2107
2166
  }
2108
2167
  }
@@ -2113,14 +2172,14 @@ object RNMBXStyleFactory {
2113
2172
  if (expression != null) {
2114
2173
  layer.textOptional(expression)
2115
2174
  } else {
2116
- e("RNMBXSymbol", "Expression for textOptional is null")
2175
+ Logger.e("RNMBXSymbol", "Expression for textOptional is null")
2117
2176
  }
2118
2177
  } else {
2119
2178
  val value = styleValue.getBoolean(VALUE_KEY)
2120
2179
  if (value != null) {
2121
2180
  layer.textOptional(value)
2122
2181
  } else {
2123
- e("RNMBXSymbol", "value for textOptional is null")
2182
+ Logger.e("RNMBXSymbol", "value for textOptional is null")
2124
2183
  }
2125
2184
  }
2126
2185
  }
@@ -2135,14 +2194,14 @@ object RNMBXStyleFactory {
2135
2194
  if (expression != null) {
2136
2195
  layer.iconOpacity(expression)
2137
2196
  } else {
2138
- e("RNMBXSymbol", "Expression for iconOpacity is null")
2197
+ Logger.e("RNMBXSymbol", "Expression for iconOpacity is null")
2139
2198
  }
2140
2199
  } else {
2141
2200
  val value = styleValue.getDouble(VALUE_KEY)
2142
2201
  if (value != null) {
2143
2202
  layer.iconOpacity(value)
2144
2203
  } else {
2145
- e("RNMBXSymbol", "value for iconOpacity is null")
2204
+ Logger.e("RNMBXSymbol", "value for iconOpacity is null")
2146
2205
  }
2147
2206
  }
2148
2207
  }
@@ -2161,14 +2220,14 @@ object RNMBXStyleFactory {
2161
2220
  if (expression != null) {
2162
2221
  layer.iconColor(expression)
2163
2222
  } else {
2164
- e("RNMBXSymbol", "Expression for iconColor is null")
2223
+ Logger.e("RNMBXSymbol", "Expression for iconColor is null")
2165
2224
  }
2166
2225
  } else {
2167
2226
  val value = styleValue.getInt(VALUE_KEY)
2168
2227
  if (value != null) {
2169
2228
  layer.iconColor(value)
2170
2229
  } else {
2171
- e("RNMBXSymbol", "value for iconColor is null")
2230
+ Logger.e("RNMBXSymbol", "value for iconColor is null")
2172
2231
  }
2173
2232
  }
2174
2233
  }
@@ -2187,14 +2246,14 @@ object RNMBXStyleFactory {
2187
2246
  if (expression != null) {
2188
2247
  layer.iconHaloColor(expression)
2189
2248
  } else {
2190
- e("RNMBXSymbol", "Expression for iconHaloColor is null")
2249
+ Logger.e("RNMBXSymbol", "Expression for iconHaloColor is null")
2191
2250
  }
2192
2251
  } else {
2193
2252
  val value = styleValue.getInt(VALUE_KEY)
2194
2253
  if (value != null) {
2195
2254
  layer.iconHaloColor(value)
2196
2255
  } else {
2197
- e("RNMBXSymbol", "value for iconHaloColor is null")
2256
+ Logger.e("RNMBXSymbol", "value for iconHaloColor is null")
2198
2257
  }
2199
2258
  }
2200
2259
  }
@@ -2213,14 +2272,14 @@ object RNMBXStyleFactory {
2213
2272
  if (expression != null) {
2214
2273
  layer.iconHaloWidth(expression)
2215
2274
  } else {
2216
- e("RNMBXSymbol", "Expression for iconHaloWidth is null")
2275
+ Logger.e("RNMBXSymbol", "Expression for iconHaloWidth is null")
2217
2276
  }
2218
2277
  } else {
2219
2278
  val value = styleValue.getDouble(VALUE_KEY)
2220
2279
  if (value != null) {
2221
2280
  layer.iconHaloWidth(value)
2222
2281
  } else {
2223
- e("RNMBXSymbol", "value for iconHaloWidth is null")
2282
+ Logger.e("RNMBXSymbol", "value for iconHaloWidth is null")
2224
2283
  }
2225
2284
  }
2226
2285
  }
@@ -2239,14 +2298,14 @@ object RNMBXStyleFactory {
2239
2298
  if (expression != null) {
2240
2299
  layer.iconHaloBlur(expression)
2241
2300
  } else {
2242
- e("RNMBXSymbol", "Expression for iconHaloBlur is null")
2301
+ Logger.e("RNMBXSymbol", "Expression for iconHaloBlur is null")
2243
2302
  }
2244
2303
  } else {
2245
2304
  val value = styleValue.getDouble(VALUE_KEY)
2246
2305
  if (value != null) {
2247
2306
  layer.iconHaloBlur(value)
2248
2307
  } else {
2249
- e("RNMBXSymbol", "value for iconHaloBlur is null")
2308
+ Logger.e("RNMBXSymbol", "value for iconHaloBlur is null")
2250
2309
  }
2251
2310
  }
2252
2311
  }
@@ -2265,14 +2324,14 @@ object RNMBXStyleFactory {
2265
2324
  if (expression != null) {
2266
2325
  layer.iconTranslate(expression)
2267
2326
  } else {
2268
- e("RNMBXSymbol", "Expression for iconTranslate is null")
2327
+ Logger.e("RNMBXSymbol", "Expression for iconTranslate is null")
2269
2328
  }
2270
2329
  } else {
2271
2330
  val value = styleValue.getFloatArray(VALUE_KEY)
2272
2331
  if (value != null) {
2273
2332
  layer.iconTranslate(value)
2274
2333
  } else {
2275
- e("RNMBXSymbol", "value for iconTranslate is null")
2334
+ Logger.e("RNMBXSymbol", "value for iconTranslate is null")
2276
2335
  }
2277
2336
  }
2278
2337
  }
@@ -2291,7 +2350,7 @@ object RNMBXStyleFactory {
2291
2350
  if (expression != null) {
2292
2351
  layer.iconTranslateAnchor(expression)
2293
2352
  } else {
2294
- e("RNMBXSymbol", "Expression for iconTranslateAnchor is null")
2353
+ Logger.e("RNMBXSymbol", "Expression for iconTranslateAnchor is null")
2295
2354
  }
2296
2355
  } else {
2297
2356
  layer.iconTranslateAnchor(IconTranslateAnchor.valueOf(styleValue.getEnumName()))
@@ -2304,14 +2363,14 @@ object RNMBXStyleFactory {
2304
2363
  if (expression != null) {
2305
2364
  layer.textOpacity(expression)
2306
2365
  } else {
2307
- e("RNMBXSymbol", "Expression for textOpacity is null")
2366
+ Logger.e("RNMBXSymbol", "Expression for textOpacity is null")
2308
2367
  }
2309
2368
  } else {
2310
2369
  val value = styleValue.getDouble(VALUE_KEY)
2311
2370
  if (value != null) {
2312
2371
  layer.textOpacity(value)
2313
2372
  } else {
2314
- e("RNMBXSymbol", "value for textOpacity is null")
2373
+ Logger.e("RNMBXSymbol", "value for textOpacity is null")
2315
2374
  }
2316
2375
  }
2317
2376
  }
@@ -2330,14 +2389,14 @@ object RNMBXStyleFactory {
2330
2389
  if (expression != null) {
2331
2390
  layer.textColor(expression)
2332
2391
  } else {
2333
- e("RNMBXSymbol", "Expression for textColor is null")
2392
+ Logger.e("RNMBXSymbol", "Expression for textColor is null")
2334
2393
  }
2335
2394
  } else {
2336
2395
  val value = styleValue.getInt(VALUE_KEY)
2337
2396
  if (value != null) {
2338
2397
  layer.textColor(value)
2339
2398
  } else {
2340
- e("RNMBXSymbol", "value for textColor is null")
2399
+ Logger.e("RNMBXSymbol", "value for textColor is null")
2341
2400
  }
2342
2401
  }
2343
2402
  }
@@ -2356,14 +2415,14 @@ object RNMBXStyleFactory {
2356
2415
  if (expression != null) {
2357
2416
  layer.textHaloColor(expression)
2358
2417
  } else {
2359
- e("RNMBXSymbol", "Expression for textHaloColor is null")
2418
+ Logger.e("RNMBXSymbol", "Expression for textHaloColor is null")
2360
2419
  }
2361
2420
  } else {
2362
2421
  val value = styleValue.getInt(VALUE_KEY)
2363
2422
  if (value != null) {
2364
2423
  layer.textHaloColor(value)
2365
2424
  } else {
2366
- e("RNMBXSymbol", "value for textHaloColor is null")
2425
+ Logger.e("RNMBXSymbol", "value for textHaloColor is null")
2367
2426
  }
2368
2427
  }
2369
2428
  }
@@ -2382,14 +2441,14 @@ object RNMBXStyleFactory {
2382
2441
  if (expression != null) {
2383
2442
  layer.textHaloWidth(expression)
2384
2443
  } else {
2385
- e("RNMBXSymbol", "Expression for textHaloWidth is null")
2444
+ Logger.e("RNMBXSymbol", "Expression for textHaloWidth is null")
2386
2445
  }
2387
2446
  } else {
2388
2447
  val value = styleValue.getDouble(VALUE_KEY)
2389
2448
  if (value != null) {
2390
2449
  layer.textHaloWidth(value)
2391
2450
  } else {
2392
- e("RNMBXSymbol", "value for textHaloWidth is null")
2451
+ Logger.e("RNMBXSymbol", "value for textHaloWidth is null")
2393
2452
  }
2394
2453
  }
2395
2454
  }
@@ -2408,14 +2467,14 @@ object RNMBXStyleFactory {
2408
2467
  if (expression != null) {
2409
2468
  layer.textHaloBlur(expression)
2410
2469
  } else {
2411
- e("RNMBXSymbol", "Expression for textHaloBlur is null")
2470
+ Logger.e("RNMBXSymbol", "Expression for textHaloBlur is null")
2412
2471
  }
2413
2472
  } else {
2414
2473
  val value = styleValue.getDouble(VALUE_KEY)
2415
2474
  if (value != null) {
2416
2475
  layer.textHaloBlur(value)
2417
2476
  } else {
2418
- e("RNMBXSymbol", "value for textHaloBlur is null")
2477
+ Logger.e("RNMBXSymbol", "value for textHaloBlur is null")
2419
2478
  }
2420
2479
  }
2421
2480
  }
@@ -2434,14 +2493,14 @@ object RNMBXStyleFactory {
2434
2493
  if (expression != null) {
2435
2494
  layer.textTranslate(expression)
2436
2495
  } else {
2437
- e("RNMBXSymbol", "Expression for textTranslate is null")
2496
+ Logger.e("RNMBXSymbol", "Expression for textTranslate is null")
2438
2497
  }
2439
2498
  } else {
2440
2499
  val value = styleValue.getFloatArray(VALUE_KEY)
2441
2500
  if (value != null) {
2442
2501
  layer.textTranslate(value)
2443
2502
  } else {
2444
- e("RNMBXSymbol", "value for textTranslate is null")
2503
+ Logger.e("RNMBXSymbol", "value for textTranslate is null")
2445
2504
  }
2446
2505
  }
2447
2506
  }
@@ -2460,7 +2519,7 @@ object RNMBXStyleFactory {
2460
2519
  if (expression != null) {
2461
2520
  layer.textTranslateAnchor(expression)
2462
2521
  } else {
2463
- e("RNMBXSymbol", "Expression for textTranslateAnchor is null")
2522
+ Logger.e("RNMBXSymbol", "Expression for textTranslateAnchor is null")
2464
2523
  }
2465
2524
  } else {
2466
2525
  layer.textTranslateAnchor(TextTranslateAnchor.valueOf(styleValue.getEnumName()))
@@ -2473,14 +2532,14 @@ object RNMBXStyleFactory {
2473
2532
  if (expression != null) {
2474
2533
  layer.symbolZElevate(expression)
2475
2534
  } else {
2476
- e("RNMBXSymbol", "Expression for symbolZElevate is null")
2535
+ Logger.e("RNMBXSymbol", "Expression for symbolZElevate is null")
2477
2536
  }
2478
2537
  } else {
2479
2538
  val value = styleValue.getBoolean(VALUE_KEY)
2480
2539
  if (value != null) {
2481
2540
  layer.symbolZElevate(value)
2482
2541
  } else {
2483
- e("RNMBXSymbol", "value for symbolZElevate is null")
2542
+ Logger.e("RNMBXSymbol", "value for symbolZElevate is null")
2484
2543
  }
2485
2544
  }
2486
2545
  }
@@ -2491,14 +2550,14 @@ object RNMBXStyleFactory {
2491
2550
  if (expression != null) {
2492
2551
  layer.iconEmissiveStrength(expression)
2493
2552
  } else {
2494
- e("RNMBXSymbol", "Expression for iconEmissiveStrength is null")
2553
+ Logger.e("RNMBXSymbol", "Expression for iconEmissiveStrength is null")
2495
2554
  }
2496
2555
  } else {
2497
2556
  val value = styleValue.getDouble(VALUE_KEY)
2498
2557
  if (value != null) {
2499
2558
  layer.iconEmissiveStrength(value)
2500
2559
  } else {
2501
- e("RNMBXSymbol", "value for iconEmissiveStrength is null")
2560
+ Logger.e("RNMBXSymbol", "value for iconEmissiveStrength is null")
2502
2561
  }
2503
2562
  }
2504
2563
  }
@@ -2517,14 +2576,14 @@ object RNMBXStyleFactory {
2517
2576
  if (expression != null) {
2518
2577
  layer.textEmissiveStrength(expression)
2519
2578
  } else {
2520
- e("RNMBXSymbol", "Expression for textEmissiveStrength is null")
2579
+ Logger.e("RNMBXSymbol", "Expression for textEmissiveStrength is null")
2521
2580
  }
2522
2581
  } else {
2523
2582
  val value = styleValue.getDouble(VALUE_KEY)
2524
2583
  if (value != null) {
2525
2584
  layer.textEmissiveStrength(value)
2526
2585
  } else {
2527
- e("RNMBXSymbol", "value for textEmissiveStrength is null")
2586
+ Logger.e("RNMBXSymbol", "value for textEmissiveStrength is null")
2528
2587
  }
2529
2588
  }
2530
2589
  }
@@ -2543,14 +2602,14 @@ object RNMBXStyleFactory {
2543
2602
  if (expression != null) {
2544
2603
  layer.iconImageCrossFade(expression)
2545
2604
  } else {
2546
- e("RNMBXSymbol", "Expression for iconImageCrossFade is null")
2605
+ Logger.e("RNMBXSymbol", "Expression for iconImageCrossFade is null")
2547
2606
  }
2548
2607
  } else {
2549
2608
  val value = styleValue.getDouble(VALUE_KEY)
2550
2609
  if (value != null) {
2551
2610
  layer.iconImageCrossFade(value)
2552
2611
  } else {
2553
- e("RNMBXSymbol", "value for iconImageCrossFade is null")
2612
+ Logger.e("RNMBXSymbol", "value for iconImageCrossFade is null")
2554
2613
  }
2555
2614
  }
2556
2615
  }
@@ -2569,14 +2628,14 @@ object RNMBXStyleFactory {
2569
2628
  if (expression != null) {
2570
2629
  layer.circleSortKey(expression)
2571
2630
  } else {
2572
- e("RNMBXCircle", "Expression for circleSortKey is null")
2631
+ Logger.e("RNMBXCircle", "Expression for circleSortKey is null")
2573
2632
  }
2574
2633
  } else {
2575
2634
  val value = styleValue.getDouble(VALUE_KEY)
2576
2635
  if (value != null) {
2577
2636
  layer.circleSortKey(value)
2578
2637
  } else {
2579
- e("RNMBXCircle", "value for circleSortKey is null")
2638
+ Logger.e("RNMBXCircle", "value for circleSortKey is null")
2580
2639
  }
2581
2640
  }
2582
2641
  }
@@ -2591,14 +2650,14 @@ object RNMBXStyleFactory {
2591
2650
  if (expression != null) {
2592
2651
  layer.circleRadius(expression)
2593
2652
  } else {
2594
- e("RNMBXCircle", "Expression for circleRadius is null")
2653
+ Logger.e("RNMBXCircle", "Expression for circleRadius is null")
2595
2654
  }
2596
2655
  } else {
2597
2656
  val value = styleValue.getDouble(VALUE_KEY)
2598
2657
  if (value != null) {
2599
2658
  layer.circleRadius(value)
2600
2659
  } else {
2601
- e("RNMBXCircle", "value for circleRadius is null")
2660
+ Logger.e("RNMBXCircle", "value for circleRadius is null")
2602
2661
  }
2603
2662
  }
2604
2663
  }
@@ -2617,14 +2676,14 @@ object RNMBXStyleFactory {
2617
2676
  if (expression != null) {
2618
2677
  layer.circleColor(expression)
2619
2678
  } else {
2620
- e("RNMBXCircle", "Expression for circleColor is null")
2679
+ Logger.e("RNMBXCircle", "Expression for circleColor is null")
2621
2680
  }
2622
2681
  } else {
2623
2682
  val value = styleValue.getInt(VALUE_KEY)
2624
2683
  if (value != null) {
2625
2684
  layer.circleColor(value)
2626
2685
  } else {
2627
- e("RNMBXCircle", "value for circleColor is null")
2686
+ Logger.e("RNMBXCircle", "value for circleColor is null")
2628
2687
  }
2629
2688
  }
2630
2689
  }
@@ -2643,14 +2702,14 @@ object RNMBXStyleFactory {
2643
2702
  if (expression != null) {
2644
2703
  layer.circleBlur(expression)
2645
2704
  } else {
2646
- e("RNMBXCircle", "Expression for circleBlur is null")
2705
+ Logger.e("RNMBXCircle", "Expression for circleBlur is null")
2647
2706
  }
2648
2707
  } else {
2649
2708
  val value = styleValue.getDouble(VALUE_KEY)
2650
2709
  if (value != null) {
2651
2710
  layer.circleBlur(value)
2652
2711
  } else {
2653
- e("RNMBXCircle", "value for circleBlur is null")
2712
+ Logger.e("RNMBXCircle", "value for circleBlur is null")
2654
2713
  }
2655
2714
  }
2656
2715
  }
@@ -2669,14 +2728,14 @@ object RNMBXStyleFactory {
2669
2728
  if (expression != null) {
2670
2729
  layer.circleOpacity(expression)
2671
2730
  } else {
2672
- e("RNMBXCircle", "Expression for circleOpacity is null")
2731
+ Logger.e("RNMBXCircle", "Expression for circleOpacity is null")
2673
2732
  }
2674
2733
  } else {
2675
2734
  val value = styleValue.getDouble(VALUE_KEY)
2676
2735
  if (value != null) {
2677
2736
  layer.circleOpacity(value)
2678
2737
  } else {
2679
- e("RNMBXCircle", "value for circleOpacity is null")
2738
+ Logger.e("RNMBXCircle", "value for circleOpacity is null")
2680
2739
  }
2681
2740
  }
2682
2741
  }
@@ -2695,14 +2754,14 @@ object RNMBXStyleFactory {
2695
2754
  if (expression != null) {
2696
2755
  layer.circleTranslate(expression)
2697
2756
  } else {
2698
- e("RNMBXCircle", "Expression for circleTranslate is null")
2757
+ Logger.e("RNMBXCircle", "Expression for circleTranslate is null")
2699
2758
  }
2700
2759
  } else {
2701
2760
  val value = styleValue.getFloatArray(VALUE_KEY)
2702
2761
  if (value != null) {
2703
2762
  layer.circleTranslate(value)
2704
2763
  } else {
2705
- e("RNMBXCircle", "value for circleTranslate is null")
2764
+ Logger.e("RNMBXCircle", "value for circleTranslate is null")
2706
2765
  }
2707
2766
  }
2708
2767
  }
@@ -2721,7 +2780,7 @@ object RNMBXStyleFactory {
2721
2780
  if (expression != null) {
2722
2781
  layer.circleTranslateAnchor(expression)
2723
2782
  } else {
2724
- e("RNMBXCircle", "Expression for circleTranslateAnchor is null")
2783
+ Logger.e("RNMBXCircle", "Expression for circleTranslateAnchor is null")
2725
2784
  }
2726
2785
  } else {
2727
2786
  layer.circleTranslateAnchor(CircleTranslateAnchor.valueOf(styleValue.getEnumName()))
@@ -2734,7 +2793,7 @@ object RNMBXStyleFactory {
2734
2793
  if (expression != null) {
2735
2794
  layer.circlePitchScale(expression)
2736
2795
  } else {
2737
- e("RNMBXCircle", "Expression for circlePitchScale is null")
2796
+ Logger.e("RNMBXCircle", "Expression for circlePitchScale is null")
2738
2797
  }
2739
2798
  } else {
2740
2799
  layer.circlePitchScale(CirclePitchScale.valueOf(styleValue.getEnumName()))
@@ -2747,7 +2806,7 @@ object RNMBXStyleFactory {
2747
2806
  if (expression != null) {
2748
2807
  layer.circlePitchAlignment(expression)
2749
2808
  } else {
2750
- e("RNMBXCircle", "Expression for circlePitchAlignment is null")
2809
+ Logger.e("RNMBXCircle", "Expression for circlePitchAlignment is null")
2751
2810
  }
2752
2811
  } else {
2753
2812
  layer.circlePitchAlignment(CirclePitchAlignment.valueOf(styleValue.getEnumName()))
@@ -2760,14 +2819,14 @@ object RNMBXStyleFactory {
2760
2819
  if (expression != null) {
2761
2820
  layer.circleStrokeWidth(expression)
2762
2821
  } else {
2763
- e("RNMBXCircle", "Expression for circleStrokeWidth is null")
2822
+ Logger.e("RNMBXCircle", "Expression for circleStrokeWidth is null")
2764
2823
  }
2765
2824
  } else {
2766
2825
  val value = styleValue.getDouble(VALUE_KEY)
2767
2826
  if (value != null) {
2768
2827
  layer.circleStrokeWidth(value)
2769
2828
  } else {
2770
- e("RNMBXCircle", "value for circleStrokeWidth is null")
2829
+ Logger.e("RNMBXCircle", "value for circleStrokeWidth is null")
2771
2830
  }
2772
2831
  }
2773
2832
  }
@@ -2786,14 +2845,14 @@ object RNMBXStyleFactory {
2786
2845
  if (expression != null) {
2787
2846
  layer.circleStrokeColor(expression)
2788
2847
  } else {
2789
- e("RNMBXCircle", "Expression for circleStrokeColor is null")
2848
+ Logger.e("RNMBXCircle", "Expression for circleStrokeColor is null")
2790
2849
  }
2791
2850
  } else {
2792
2851
  val value = styleValue.getInt(VALUE_KEY)
2793
2852
  if (value != null) {
2794
2853
  layer.circleStrokeColor(value)
2795
2854
  } else {
2796
- e("RNMBXCircle", "value for circleStrokeColor is null")
2855
+ Logger.e("RNMBXCircle", "value for circleStrokeColor is null")
2797
2856
  }
2798
2857
  }
2799
2858
  }
@@ -2812,14 +2871,14 @@ object RNMBXStyleFactory {
2812
2871
  if (expression != null) {
2813
2872
  layer.circleStrokeOpacity(expression)
2814
2873
  } else {
2815
- e("RNMBXCircle", "Expression for circleStrokeOpacity is null")
2874
+ Logger.e("RNMBXCircle", "Expression for circleStrokeOpacity is null")
2816
2875
  }
2817
2876
  } else {
2818
2877
  val value = styleValue.getDouble(VALUE_KEY)
2819
2878
  if (value != null) {
2820
2879
  layer.circleStrokeOpacity(value)
2821
2880
  } else {
2822
- e("RNMBXCircle", "value for circleStrokeOpacity is null")
2881
+ Logger.e("RNMBXCircle", "value for circleStrokeOpacity is null")
2823
2882
  }
2824
2883
  }
2825
2884
  }
@@ -2838,14 +2897,14 @@ object RNMBXStyleFactory {
2838
2897
  if (expression != null) {
2839
2898
  layer.circleEmissiveStrength(expression)
2840
2899
  } else {
2841
- e("RNMBXCircle", "Expression for circleEmissiveStrength is null")
2900
+ Logger.e("RNMBXCircle", "Expression for circleEmissiveStrength is null")
2842
2901
  }
2843
2902
  } else {
2844
2903
  val value = styleValue.getDouble(VALUE_KEY)
2845
2904
  if (value != null) {
2846
2905
  layer.circleEmissiveStrength(value)
2847
2906
  } else {
2848
- e("RNMBXCircle", "value for circleEmissiveStrength is null")
2907
+ Logger.e("RNMBXCircle", "value for circleEmissiveStrength is null")
2849
2908
  }
2850
2909
  }
2851
2910
  }
@@ -2868,14 +2927,14 @@ object RNMBXStyleFactory {
2868
2927
  if (expression != null) {
2869
2928
  layer.heatmapRadius(expression)
2870
2929
  } else {
2871
- e("RNMBXHeatmap", "Expression for heatmapRadius is null")
2930
+ Logger.e("RNMBXHeatmap", "Expression for heatmapRadius is null")
2872
2931
  }
2873
2932
  } else {
2874
2933
  val value = styleValue.getDouble(VALUE_KEY)
2875
2934
  if (value != null) {
2876
2935
  layer.heatmapRadius(value)
2877
2936
  } else {
2878
- e("RNMBXHeatmap", "value for heatmapRadius is null")
2937
+ Logger.e("RNMBXHeatmap", "value for heatmapRadius is null")
2879
2938
  }
2880
2939
  }
2881
2940
  }
@@ -2894,14 +2953,14 @@ object RNMBXStyleFactory {
2894
2953
  if (expression != null) {
2895
2954
  layer.heatmapWeight(expression)
2896
2955
  } else {
2897
- e("RNMBXHeatmap", "Expression for heatmapWeight is null")
2956
+ Logger.e("RNMBXHeatmap", "Expression for heatmapWeight is null")
2898
2957
  }
2899
2958
  } else {
2900
2959
  val value = styleValue.getDouble(VALUE_KEY)
2901
2960
  if (value != null) {
2902
2961
  layer.heatmapWeight(value)
2903
2962
  } else {
2904
- e("RNMBXHeatmap", "value for heatmapWeight is null")
2963
+ Logger.e("RNMBXHeatmap", "value for heatmapWeight is null")
2905
2964
  }
2906
2965
  }
2907
2966
  }
@@ -2912,14 +2971,14 @@ object RNMBXStyleFactory {
2912
2971
  if (expression != null) {
2913
2972
  layer.heatmapIntensity(expression)
2914
2973
  } else {
2915
- e("RNMBXHeatmap", "Expression for heatmapIntensity is null")
2974
+ Logger.e("RNMBXHeatmap", "Expression for heatmapIntensity is null")
2916
2975
  }
2917
2976
  } else {
2918
2977
  val value = styleValue.getDouble(VALUE_KEY)
2919
2978
  if (value != null) {
2920
2979
  layer.heatmapIntensity(value)
2921
2980
  } else {
2922
- e("RNMBXHeatmap", "value for heatmapIntensity is null")
2981
+ Logger.e("RNMBXHeatmap", "value for heatmapIntensity is null")
2923
2982
  }
2924
2983
  }
2925
2984
  }
@@ -2938,7 +2997,7 @@ object RNMBXStyleFactory {
2938
2997
  if (expression != null) {
2939
2998
  layer.heatmapColor(expression)
2940
2999
  } else {
2941
- e("RNMBXHeatmap", "Expression for heatmapColor is null")
3000
+ Logger.e("RNMBXHeatmap", "Expression for heatmapColor is null")
2942
3001
  }
2943
3002
  } else {
2944
3003
  layer.heatmapColor(styleValue.getIntExpression(VALUE_KEY))
@@ -2951,14 +3010,14 @@ object RNMBXStyleFactory {
2951
3010
  if (expression != null) {
2952
3011
  layer.heatmapOpacity(expression)
2953
3012
  } else {
2954
- e("RNMBXHeatmap", "Expression for heatmapOpacity is null")
3013
+ Logger.e("RNMBXHeatmap", "Expression for heatmapOpacity is null")
2955
3014
  }
2956
3015
  } else {
2957
3016
  val value = styleValue.getDouble(VALUE_KEY)
2958
3017
  if (value != null) {
2959
3018
  layer.heatmapOpacity(value)
2960
3019
  } else {
2961
- e("RNMBXHeatmap", "value for heatmapOpacity is null")
3020
+ Logger.e("RNMBXHeatmap", "value for heatmapOpacity is null")
2962
3021
  }
2963
3022
  }
2964
3023
  }
@@ -2981,14 +3040,14 @@ object RNMBXStyleFactory {
2981
3040
  if (expression != null) {
2982
3041
  layer.fillExtrusionOpacity(expression)
2983
3042
  } else {
2984
- e("RNMBXFillExtrusion", "Expression for fillExtrusionOpacity is null")
3043
+ Logger.e("RNMBXFillExtrusion", "Expression for fillExtrusionOpacity is null")
2985
3044
  }
2986
3045
  } else {
2987
3046
  val value = styleValue.getDouble(VALUE_KEY)
2988
3047
  if (value != null) {
2989
3048
  layer.fillExtrusionOpacity(value)
2990
3049
  } else {
2991
- e("RNMBXFillExtrusion", "value for fillExtrusionOpacity is null")
3050
+ Logger.e("RNMBXFillExtrusion", "value for fillExtrusionOpacity is null")
2992
3051
  }
2993
3052
  }
2994
3053
  }
@@ -3007,14 +3066,14 @@ object RNMBXStyleFactory {
3007
3066
  if (expression != null) {
3008
3067
  layer.fillExtrusionColor(expression)
3009
3068
  } else {
3010
- e("RNMBXFillExtrusion", "Expression for fillExtrusionColor is null")
3069
+ Logger.e("RNMBXFillExtrusion", "Expression for fillExtrusionColor is null")
3011
3070
  }
3012
3071
  } else {
3013
3072
  val value = styleValue.getInt(VALUE_KEY)
3014
3073
  if (value != null) {
3015
3074
  layer.fillExtrusionColor(value)
3016
3075
  } else {
3017
- e("RNMBXFillExtrusion", "value for fillExtrusionColor is null")
3076
+ Logger.e("RNMBXFillExtrusion", "value for fillExtrusionColor is null")
3018
3077
  }
3019
3078
  }
3020
3079
  }
@@ -3033,14 +3092,14 @@ object RNMBXStyleFactory {
3033
3092
  if (expression != null) {
3034
3093
  layer.fillExtrusionTranslate(expression)
3035
3094
  } else {
3036
- e("RNMBXFillExtrusion", "Expression for fillExtrusionTranslate is null")
3095
+ Logger.e("RNMBXFillExtrusion", "Expression for fillExtrusionTranslate is null")
3037
3096
  }
3038
3097
  } else {
3039
3098
  val value = styleValue.getFloatArray(VALUE_KEY)
3040
3099
  if (value != null) {
3041
3100
  layer.fillExtrusionTranslate(value)
3042
3101
  } else {
3043
- e("RNMBXFillExtrusion", "value for fillExtrusionTranslate is null")
3102
+ Logger.e("RNMBXFillExtrusion", "value for fillExtrusionTranslate is null")
3044
3103
  }
3045
3104
  }
3046
3105
  }
@@ -3059,7 +3118,7 @@ object RNMBXStyleFactory {
3059
3118
  if (expression != null) {
3060
3119
  layer.fillExtrusionTranslateAnchor(expression)
3061
3120
  } else {
3062
- e("RNMBXFillExtrusion", "Expression for fillExtrusionTranslateAnchor is null")
3121
+ Logger.e("RNMBXFillExtrusion", "Expression for fillExtrusionTranslateAnchor is null")
3063
3122
  }
3064
3123
  } else {
3065
3124
  layer.fillExtrusionTranslateAnchor(FillExtrusionTranslateAnchor.valueOf(styleValue.getEnumName()))
@@ -3073,14 +3132,14 @@ object RNMBXStyleFactory {
3073
3132
  if (value != null) {
3074
3133
  layer.fillExtrusionPattern(value)
3075
3134
  } else {
3076
- e("RNMBXFillExtrusion", "Image for fillExtrusionPattern is null")
3135
+ Logger.e("RNMBXFillExtrusion", "Image for fillExtrusionPattern is null")
3077
3136
  }
3078
3137
  } else {
3079
3138
  val expression = styleValue.getExpression()
3080
3139
  if (expression != null) {
3081
3140
  layer.fillExtrusionPattern(expression)
3082
3141
  } else {
3083
- e("RNMBXFillExtrusion", "Expression for fillExtrusionPattern is null")
3142
+ Logger.e("RNMBXFillExtrusion", "Expression for fillExtrusionPattern is null")
3084
3143
  }
3085
3144
  }
3086
3145
  } else {
@@ -3088,7 +3147,7 @@ object RNMBXStyleFactory {
3088
3147
  if (value != null) {
3089
3148
  layer.fillExtrusionPattern(value);
3090
3149
  } else {
3091
- e("RNMBXFillExtrusion", "value for fillExtrusionPattern is null")
3150
+ Logger.e("RNMBXFillExtrusion", "value for fillExtrusionPattern is null")
3092
3151
  }
3093
3152
  }
3094
3153
  }
@@ -3099,14 +3158,14 @@ object RNMBXStyleFactory {
3099
3158
  if (expression != null) {
3100
3159
  layer.fillExtrusionHeight(expression)
3101
3160
  } else {
3102
- e("RNMBXFillExtrusion", "Expression for fillExtrusionHeight is null")
3161
+ Logger.e("RNMBXFillExtrusion", "Expression for fillExtrusionHeight is null")
3103
3162
  }
3104
3163
  } else {
3105
3164
  val value = styleValue.getDouble(VALUE_KEY)
3106
3165
  if (value != null) {
3107
3166
  layer.fillExtrusionHeight(value)
3108
3167
  } else {
3109
- e("RNMBXFillExtrusion", "value for fillExtrusionHeight is null")
3168
+ Logger.e("RNMBXFillExtrusion", "value for fillExtrusionHeight is null")
3110
3169
  }
3111
3170
  }
3112
3171
  }
@@ -3125,14 +3184,14 @@ object RNMBXStyleFactory {
3125
3184
  if (expression != null) {
3126
3185
  layer.fillExtrusionBase(expression)
3127
3186
  } else {
3128
- e("RNMBXFillExtrusion", "Expression for fillExtrusionBase is null")
3187
+ Logger.e("RNMBXFillExtrusion", "Expression for fillExtrusionBase is null")
3129
3188
  }
3130
3189
  } else {
3131
3190
  val value = styleValue.getDouble(VALUE_KEY)
3132
3191
  if (value != null) {
3133
3192
  layer.fillExtrusionBase(value)
3134
3193
  } else {
3135
- e("RNMBXFillExtrusion", "value for fillExtrusionBase is null")
3194
+ Logger.e("RNMBXFillExtrusion", "value for fillExtrusionBase is null")
3136
3195
  }
3137
3196
  }
3138
3197
  }
@@ -3151,14 +3210,14 @@ object RNMBXStyleFactory {
3151
3210
  if (expression != null) {
3152
3211
  layer.fillExtrusionVerticalGradient(expression)
3153
3212
  } else {
3154
- e("RNMBXFillExtrusion", "Expression for fillExtrusionVerticalGradient is null")
3213
+ Logger.e("RNMBXFillExtrusion", "Expression for fillExtrusionVerticalGradient is null")
3155
3214
  }
3156
3215
  } else {
3157
3216
  val value = styleValue.getBoolean(VALUE_KEY)
3158
3217
  if (value != null) {
3159
3218
  layer.fillExtrusionVerticalGradient(value)
3160
3219
  } else {
3161
- e("RNMBXFillExtrusion", "value for fillExtrusionVerticalGradient is null")
3220
+ Logger.e("RNMBXFillExtrusion", "value for fillExtrusionVerticalGradient is null")
3162
3221
  }
3163
3222
  }
3164
3223
  }
@@ -3169,14 +3228,14 @@ object RNMBXStyleFactory {
3169
3228
  if (expression != null) {
3170
3229
  layer.fillExtrusionRoundedRoof(expression)
3171
3230
  } else {
3172
- e("RNMBXFillExtrusion", "Expression for fillExtrusionRoundedRoof is null")
3231
+ Logger.e("RNMBXFillExtrusion", "Expression for fillExtrusionRoundedRoof is null")
3173
3232
  }
3174
3233
  } else {
3175
3234
  val value = styleValue.getBoolean(VALUE_KEY)
3176
3235
  if (value != null) {
3177
3236
  layer.fillExtrusionRoundedRoof(value)
3178
3237
  } else {
3179
- e("RNMBXFillExtrusion", "value for fillExtrusionRoundedRoof is null")
3238
+ Logger.e("RNMBXFillExtrusion", "value for fillExtrusionRoundedRoof is null")
3180
3239
  }
3181
3240
  }
3182
3241
  }
@@ -3187,14 +3246,14 @@ object RNMBXStyleFactory {
3187
3246
  if (expression != null) {
3188
3247
  layer.fillExtrusionAmbientOcclusionWallRadius(expression)
3189
3248
  } else {
3190
- e("RNMBXFillExtrusion", "Expression for fillExtrusionAmbientOcclusionWallRadius is null")
3249
+ Logger.e("RNMBXFillExtrusion", "Expression for fillExtrusionAmbientOcclusionWallRadius is null")
3191
3250
  }
3192
3251
  } else {
3193
3252
  val value = styleValue.getDouble(VALUE_KEY)
3194
3253
  if (value != null) {
3195
3254
  layer.fillExtrusionAmbientOcclusionWallRadius(value)
3196
3255
  } else {
3197
- e("RNMBXFillExtrusion", "value for fillExtrusionAmbientOcclusionWallRadius is null")
3256
+ Logger.e("RNMBXFillExtrusion", "value for fillExtrusionAmbientOcclusionWallRadius is null")
3198
3257
  }
3199
3258
  }
3200
3259
  }
@@ -3213,14 +3272,14 @@ object RNMBXStyleFactory {
3213
3272
  if (expression != null) {
3214
3273
  layer.fillExtrusionAmbientOcclusionGroundRadius(expression)
3215
3274
  } else {
3216
- e("RNMBXFillExtrusion", "Expression for fillExtrusionAmbientOcclusionGroundRadius is null")
3275
+ Logger.e("RNMBXFillExtrusion", "Expression for fillExtrusionAmbientOcclusionGroundRadius is null")
3217
3276
  }
3218
3277
  } else {
3219
3278
  val value = styleValue.getDouble(VALUE_KEY)
3220
3279
  if (value != null) {
3221
3280
  layer.fillExtrusionAmbientOcclusionGroundRadius(value)
3222
3281
  } else {
3223
- e("RNMBXFillExtrusion", "value for fillExtrusionAmbientOcclusionGroundRadius is null")
3282
+ Logger.e("RNMBXFillExtrusion", "value for fillExtrusionAmbientOcclusionGroundRadius is null")
3224
3283
  }
3225
3284
  }
3226
3285
  }
@@ -3239,14 +3298,14 @@ object RNMBXStyleFactory {
3239
3298
  if (expression != null) {
3240
3299
  layer.fillExtrusionAmbientOcclusionGroundAttenuation(expression)
3241
3300
  } else {
3242
- e("RNMBXFillExtrusion", "Expression for fillExtrusionAmbientOcclusionGroundAttenuation is null")
3301
+ Logger.e("RNMBXFillExtrusion", "Expression for fillExtrusionAmbientOcclusionGroundAttenuation is null")
3243
3302
  }
3244
3303
  } else {
3245
3304
  val value = styleValue.getDouble(VALUE_KEY)
3246
3305
  if (value != null) {
3247
3306
  layer.fillExtrusionAmbientOcclusionGroundAttenuation(value)
3248
3307
  } else {
3249
- e("RNMBXFillExtrusion", "value for fillExtrusionAmbientOcclusionGroundAttenuation is null")
3308
+ Logger.e("RNMBXFillExtrusion", "value for fillExtrusionAmbientOcclusionGroundAttenuation is null")
3250
3309
  }
3251
3310
  }
3252
3311
  }
@@ -3265,14 +3324,14 @@ object RNMBXStyleFactory {
3265
3324
  if (expression != null) {
3266
3325
  layer.fillExtrusionFloodLightColor(expression)
3267
3326
  } else {
3268
- e("RNMBXFillExtrusion", "Expression for fillExtrusionFloodLightColor is null")
3327
+ Logger.e("RNMBXFillExtrusion", "Expression for fillExtrusionFloodLightColor is null")
3269
3328
  }
3270
3329
  } else {
3271
3330
  val value = styleValue.getInt(VALUE_KEY)
3272
3331
  if (value != null) {
3273
3332
  layer.fillExtrusionFloodLightColor(value)
3274
3333
  } else {
3275
- e("RNMBXFillExtrusion", "value for fillExtrusionFloodLightColor is null")
3334
+ Logger.e("RNMBXFillExtrusion", "value for fillExtrusionFloodLightColor is null")
3276
3335
  }
3277
3336
  }
3278
3337
  }
@@ -3291,14 +3350,14 @@ object RNMBXStyleFactory {
3291
3350
  if (expression != null) {
3292
3351
  layer.fillExtrusionFloodLightIntensity(expression)
3293
3352
  } else {
3294
- e("RNMBXFillExtrusion", "Expression for fillExtrusionFloodLightIntensity is null")
3353
+ Logger.e("RNMBXFillExtrusion", "Expression for fillExtrusionFloodLightIntensity is null")
3295
3354
  }
3296
3355
  } else {
3297
3356
  val value = styleValue.getDouble(VALUE_KEY)
3298
3357
  if (value != null) {
3299
3358
  layer.fillExtrusionFloodLightIntensity(value)
3300
3359
  } else {
3301
- e("RNMBXFillExtrusion", "value for fillExtrusionFloodLightIntensity is null")
3360
+ Logger.e("RNMBXFillExtrusion", "value for fillExtrusionFloodLightIntensity is null")
3302
3361
  }
3303
3362
  }
3304
3363
  }
@@ -3317,14 +3376,14 @@ object RNMBXStyleFactory {
3317
3376
  if (expression != null) {
3318
3377
  layer.fillExtrusionFloodLightWallRadius(expression)
3319
3378
  } else {
3320
- e("RNMBXFillExtrusion", "Expression for fillExtrusionFloodLightWallRadius is null")
3379
+ Logger.e("RNMBXFillExtrusion", "Expression for fillExtrusionFloodLightWallRadius is null")
3321
3380
  }
3322
3381
  } else {
3323
3382
  val value = styleValue.getDouble(VALUE_KEY)
3324
3383
  if (value != null) {
3325
3384
  layer.fillExtrusionFloodLightWallRadius(value)
3326
3385
  } else {
3327
- e("RNMBXFillExtrusion", "value for fillExtrusionFloodLightWallRadius is null")
3386
+ Logger.e("RNMBXFillExtrusion", "value for fillExtrusionFloodLightWallRadius is null")
3328
3387
  }
3329
3388
  }
3330
3389
  }
@@ -3343,14 +3402,14 @@ object RNMBXStyleFactory {
3343
3402
  if (expression != null) {
3344
3403
  layer.fillExtrusionFloodLightGroundRadius(expression)
3345
3404
  } else {
3346
- e("RNMBXFillExtrusion", "Expression for fillExtrusionFloodLightGroundRadius is null")
3405
+ Logger.e("RNMBXFillExtrusion", "Expression for fillExtrusionFloodLightGroundRadius is null")
3347
3406
  }
3348
3407
  } else {
3349
3408
  val value = styleValue.getDouble(VALUE_KEY)
3350
3409
  if (value != null) {
3351
3410
  layer.fillExtrusionFloodLightGroundRadius(value)
3352
3411
  } else {
3353
- e("RNMBXFillExtrusion", "value for fillExtrusionFloodLightGroundRadius is null")
3412
+ Logger.e("RNMBXFillExtrusion", "value for fillExtrusionFloodLightGroundRadius is null")
3354
3413
  }
3355
3414
  }
3356
3415
  }
@@ -3369,14 +3428,14 @@ object RNMBXStyleFactory {
3369
3428
  if (expression != null) {
3370
3429
  layer.fillExtrusionFloodLightGroundAttenuation(expression)
3371
3430
  } else {
3372
- e("RNMBXFillExtrusion", "Expression for fillExtrusionFloodLightGroundAttenuation is null")
3431
+ Logger.e("RNMBXFillExtrusion", "Expression for fillExtrusionFloodLightGroundAttenuation is null")
3373
3432
  }
3374
3433
  } else {
3375
3434
  val value = styleValue.getDouble(VALUE_KEY)
3376
3435
  if (value != null) {
3377
3436
  layer.fillExtrusionFloodLightGroundAttenuation(value)
3378
3437
  } else {
3379
- e("RNMBXFillExtrusion", "value for fillExtrusionFloodLightGroundAttenuation is null")
3438
+ Logger.e("RNMBXFillExtrusion", "value for fillExtrusionFloodLightGroundAttenuation is null")
3380
3439
  }
3381
3440
  }
3382
3441
  }
@@ -3395,14 +3454,14 @@ object RNMBXStyleFactory {
3395
3454
  if (expression != null) {
3396
3455
  layer.fillExtrusionVerticalScale(expression)
3397
3456
  } else {
3398
- e("RNMBXFillExtrusion", "Expression for fillExtrusionVerticalScale is null")
3457
+ Logger.e("RNMBXFillExtrusion", "Expression for fillExtrusionVerticalScale is null")
3399
3458
  }
3400
3459
  } else {
3401
3460
  val value = styleValue.getDouble(VALUE_KEY)
3402
3461
  if (value != null) {
3403
3462
  layer.fillExtrusionVerticalScale(value)
3404
3463
  } else {
3405
- e("RNMBXFillExtrusion", "value for fillExtrusionVerticalScale is null")
3464
+ Logger.e("RNMBXFillExtrusion", "value for fillExtrusionVerticalScale is null")
3406
3465
  }
3407
3466
  }
3408
3467
  }
@@ -3421,14 +3480,14 @@ object RNMBXStyleFactory {
3421
3480
  if (expression != null) {
3422
3481
  layer.fillExtrusionCutoffFadeRange(expression)
3423
3482
  } else {
3424
- e("RNMBXFillExtrusion", "Expression for fillExtrusionCutoffFadeRange is null")
3483
+ Logger.e("RNMBXFillExtrusion", "Expression for fillExtrusionCutoffFadeRange is null")
3425
3484
  }
3426
3485
  } else {
3427
3486
  val value = styleValue.getDouble(VALUE_KEY)
3428
3487
  if (value != null) {
3429
3488
  layer.fillExtrusionCutoffFadeRange(value)
3430
3489
  } else {
3431
- e("RNMBXFillExtrusion", "value for fillExtrusionCutoffFadeRange is null")
3490
+ Logger.e("RNMBXFillExtrusion", "value for fillExtrusionCutoffFadeRange is null")
3432
3491
  }
3433
3492
  }
3434
3493
  }
@@ -3443,14 +3502,14 @@ object RNMBXStyleFactory {
3443
3502
  if (expression != null) {
3444
3503
  layer.rasterOpacity(expression)
3445
3504
  } else {
3446
- e("RNMBXRaster", "Expression for rasterOpacity is null")
3505
+ Logger.e("RNMBXRaster", "Expression for rasterOpacity is null")
3447
3506
  }
3448
3507
  } else {
3449
3508
  val value = styleValue.getDouble(VALUE_KEY)
3450
3509
  if (value != null) {
3451
3510
  layer.rasterOpacity(value)
3452
3511
  } else {
3453
- e("RNMBXRaster", "value for rasterOpacity is null")
3512
+ Logger.e("RNMBXRaster", "value for rasterOpacity is null")
3454
3513
  }
3455
3514
  }
3456
3515
  }
@@ -3469,14 +3528,14 @@ object RNMBXStyleFactory {
3469
3528
  if (expression != null) {
3470
3529
  layer.rasterHueRotate(expression)
3471
3530
  } else {
3472
- e("RNMBXRaster", "Expression for rasterHueRotate is null")
3531
+ Logger.e("RNMBXRaster", "Expression for rasterHueRotate is null")
3473
3532
  }
3474
3533
  } else {
3475
3534
  val value = styleValue.getDouble(VALUE_KEY)
3476
3535
  if (value != null) {
3477
3536
  layer.rasterHueRotate(value)
3478
3537
  } else {
3479
- e("RNMBXRaster", "value for rasterHueRotate is null")
3538
+ Logger.e("RNMBXRaster", "value for rasterHueRotate is null")
3480
3539
  }
3481
3540
  }
3482
3541
  }
@@ -3495,14 +3554,14 @@ object RNMBXStyleFactory {
3495
3554
  if (expression != null) {
3496
3555
  layer.rasterBrightnessMin(expression)
3497
3556
  } else {
3498
- e("RNMBXRaster", "Expression for rasterBrightnessMin is null")
3557
+ Logger.e("RNMBXRaster", "Expression for rasterBrightnessMin is null")
3499
3558
  }
3500
3559
  } else {
3501
3560
  val value = styleValue.getDouble(VALUE_KEY)
3502
3561
  if (value != null) {
3503
3562
  layer.rasterBrightnessMin(value)
3504
3563
  } else {
3505
- e("RNMBXRaster", "value for rasterBrightnessMin is null")
3564
+ Logger.e("RNMBXRaster", "value for rasterBrightnessMin is null")
3506
3565
  }
3507
3566
  }
3508
3567
  }
@@ -3521,14 +3580,14 @@ object RNMBXStyleFactory {
3521
3580
  if (expression != null) {
3522
3581
  layer.rasterBrightnessMax(expression)
3523
3582
  } else {
3524
- e("RNMBXRaster", "Expression for rasterBrightnessMax is null")
3583
+ Logger.e("RNMBXRaster", "Expression for rasterBrightnessMax is null")
3525
3584
  }
3526
3585
  } else {
3527
3586
  val value = styleValue.getDouble(VALUE_KEY)
3528
3587
  if (value != null) {
3529
3588
  layer.rasterBrightnessMax(value)
3530
3589
  } else {
3531
- e("RNMBXRaster", "value for rasterBrightnessMax is null")
3590
+ Logger.e("RNMBXRaster", "value for rasterBrightnessMax is null")
3532
3591
  }
3533
3592
  }
3534
3593
  }
@@ -3547,14 +3606,14 @@ object RNMBXStyleFactory {
3547
3606
  if (expression != null) {
3548
3607
  layer.rasterSaturation(expression)
3549
3608
  } else {
3550
- e("RNMBXRaster", "Expression for rasterSaturation is null")
3609
+ Logger.e("RNMBXRaster", "Expression for rasterSaturation is null")
3551
3610
  }
3552
3611
  } else {
3553
3612
  val value = styleValue.getDouble(VALUE_KEY)
3554
3613
  if (value != null) {
3555
3614
  layer.rasterSaturation(value)
3556
3615
  } else {
3557
- e("RNMBXRaster", "value for rasterSaturation is null")
3616
+ Logger.e("RNMBXRaster", "value for rasterSaturation is null")
3558
3617
  }
3559
3618
  }
3560
3619
  }
@@ -3573,14 +3632,14 @@ object RNMBXStyleFactory {
3573
3632
  if (expression != null) {
3574
3633
  layer.rasterContrast(expression)
3575
3634
  } else {
3576
- e("RNMBXRaster", "Expression for rasterContrast is null")
3635
+ Logger.e("RNMBXRaster", "Expression for rasterContrast is null")
3577
3636
  }
3578
3637
  } else {
3579
3638
  val value = styleValue.getDouble(VALUE_KEY)
3580
3639
  if (value != null) {
3581
3640
  layer.rasterContrast(value)
3582
3641
  } else {
3583
- e("RNMBXRaster", "value for rasterContrast is null")
3642
+ Logger.e("RNMBXRaster", "value for rasterContrast is null")
3584
3643
  }
3585
3644
  }
3586
3645
  }
@@ -3599,7 +3658,7 @@ object RNMBXStyleFactory {
3599
3658
  if (expression != null) {
3600
3659
  layer.rasterResampling(expression)
3601
3660
  } else {
3602
- e("RNMBXRaster", "Expression for rasterResampling is null")
3661
+ Logger.e("RNMBXRaster", "Expression for rasterResampling is null")
3603
3662
  }
3604
3663
  } else {
3605
3664
  layer.rasterResampling(RasterResampling.valueOf(styleValue.getEnumName()))
@@ -3612,14 +3671,14 @@ object RNMBXStyleFactory {
3612
3671
  if (expression != null) {
3613
3672
  layer.rasterFadeDuration(expression)
3614
3673
  } else {
3615
- e("RNMBXRaster", "Expression for rasterFadeDuration is null")
3674
+ Logger.e("RNMBXRaster", "Expression for rasterFadeDuration is null")
3616
3675
  }
3617
3676
  } else {
3618
3677
  val value = styleValue.getDouble(VALUE_KEY)
3619
3678
  if (value != null) {
3620
3679
  layer.rasterFadeDuration(value)
3621
3680
  } else {
3622
- e("RNMBXRaster", "value for rasterFadeDuration is null")
3681
+ Logger.e("RNMBXRaster", "value for rasterFadeDuration is null")
3623
3682
  }
3624
3683
  }
3625
3684
  }
@@ -3630,14 +3689,14 @@ object RNMBXStyleFactory {
3630
3689
  if (expression != null) {
3631
3690
  layer.rasterColor(expression)
3632
3691
  } else {
3633
- e("RNMBXRaster", "Expression for rasterColor is null")
3692
+ Logger.e("RNMBXRaster", "Expression for rasterColor is null")
3634
3693
  }
3635
3694
  } else {
3636
3695
  val value = styleValue.getInt(VALUE_KEY)
3637
3696
  if (value != null) {
3638
3697
  layer.rasterColor(value)
3639
3698
  } else {
3640
- e("RNMBXRaster", "value for rasterColor is null")
3699
+ Logger.e("RNMBXRaster", "value for rasterColor is null")
3641
3700
  }
3642
3701
  }
3643
3702
  }
@@ -3648,14 +3707,14 @@ object RNMBXStyleFactory {
3648
3707
  if (expression != null) {
3649
3708
  layer.rasterColorMix(expression)
3650
3709
  } else {
3651
- e("RNMBXRaster", "Expression for rasterColorMix is null")
3710
+ Logger.e("RNMBXRaster", "Expression for rasterColorMix is null")
3652
3711
  }
3653
3712
  } else {
3654
3713
  val value = styleValue.getFloatArray(VALUE_KEY)
3655
3714
  if (value != null) {
3656
3715
  layer.rasterColorMix(value)
3657
3716
  } else {
3658
- e("RNMBXRaster", "value for rasterColorMix is null")
3717
+ Logger.e("RNMBXRaster", "value for rasterColorMix is null")
3659
3718
  }
3660
3719
  }
3661
3720
  }
@@ -3674,14 +3733,14 @@ object RNMBXStyleFactory {
3674
3733
  if (expression != null) {
3675
3734
  layer.rasterColorRange(expression)
3676
3735
  } else {
3677
- e("RNMBXRaster", "Expression for rasterColorRange is null")
3736
+ Logger.e("RNMBXRaster", "Expression for rasterColorRange is null")
3678
3737
  }
3679
3738
  } else {
3680
3739
  val value = styleValue.getFloatArray(VALUE_KEY)
3681
3740
  if (value != null) {
3682
3741
  layer.rasterColorRange(value)
3683
3742
  } else {
3684
- e("RNMBXRaster", "value for rasterColorRange is null")
3743
+ Logger.e("RNMBXRaster", "value for rasterColorRange is null")
3685
3744
  }
3686
3745
  }
3687
3746
  }
@@ -3704,14 +3763,14 @@ object RNMBXStyleFactory {
3704
3763
  if (expression != null) {
3705
3764
  layer.hillshadeIlluminationDirection(expression)
3706
3765
  } else {
3707
- e("RNMBXHillshade", "Expression for hillshadeIlluminationDirection is null")
3766
+ Logger.e("RNMBXHillshade", "Expression for hillshadeIlluminationDirection is null")
3708
3767
  }
3709
3768
  } else {
3710
3769
  val value = styleValue.getDouble(VALUE_KEY)
3711
3770
  if (value != null) {
3712
3771
  layer.hillshadeIlluminationDirection(value)
3713
3772
  } else {
3714
- e("RNMBXHillshade", "value for hillshadeIlluminationDirection is null")
3773
+ Logger.e("RNMBXHillshade", "value for hillshadeIlluminationDirection is null")
3715
3774
  }
3716
3775
  }
3717
3776
  }
@@ -3722,7 +3781,7 @@ object RNMBXStyleFactory {
3722
3781
  if (expression != null) {
3723
3782
  layer.hillshadeIlluminationAnchor(expression)
3724
3783
  } else {
3725
- e("RNMBXHillshade", "Expression for hillshadeIlluminationAnchor is null")
3784
+ Logger.e("RNMBXHillshade", "Expression for hillshadeIlluminationAnchor is null")
3726
3785
  }
3727
3786
  } else {
3728
3787
  layer.hillshadeIlluminationAnchor(HillshadeIlluminationAnchor.valueOf(styleValue.getEnumName()))
@@ -3735,14 +3794,14 @@ object RNMBXStyleFactory {
3735
3794
  if (expression != null) {
3736
3795
  layer.hillshadeExaggeration(expression)
3737
3796
  } else {
3738
- e("RNMBXHillshade", "Expression for hillshadeExaggeration is null")
3797
+ Logger.e("RNMBXHillshade", "Expression for hillshadeExaggeration is null")
3739
3798
  }
3740
3799
  } else {
3741
3800
  val value = styleValue.getDouble(VALUE_KEY)
3742
3801
  if (value != null) {
3743
3802
  layer.hillshadeExaggeration(value)
3744
3803
  } else {
3745
- e("RNMBXHillshade", "value for hillshadeExaggeration is null")
3804
+ Logger.e("RNMBXHillshade", "value for hillshadeExaggeration is null")
3746
3805
  }
3747
3806
  }
3748
3807
  }
@@ -3761,14 +3820,14 @@ object RNMBXStyleFactory {
3761
3820
  if (expression != null) {
3762
3821
  layer.hillshadeShadowColor(expression)
3763
3822
  } else {
3764
- e("RNMBXHillshade", "Expression for hillshadeShadowColor is null")
3823
+ Logger.e("RNMBXHillshade", "Expression for hillshadeShadowColor is null")
3765
3824
  }
3766
3825
  } else {
3767
3826
  val value = styleValue.getInt(VALUE_KEY)
3768
3827
  if (value != null) {
3769
3828
  layer.hillshadeShadowColor(value)
3770
3829
  } else {
3771
- e("RNMBXHillshade", "value for hillshadeShadowColor is null")
3830
+ Logger.e("RNMBXHillshade", "value for hillshadeShadowColor is null")
3772
3831
  }
3773
3832
  }
3774
3833
  }
@@ -3787,14 +3846,14 @@ object RNMBXStyleFactory {
3787
3846
  if (expression != null) {
3788
3847
  layer.hillshadeHighlightColor(expression)
3789
3848
  } else {
3790
- e("RNMBXHillshade", "Expression for hillshadeHighlightColor is null")
3849
+ Logger.e("RNMBXHillshade", "Expression for hillshadeHighlightColor is null")
3791
3850
  }
3792
3851
  } else {
3793
3852
  val value = styleValue.getInt(VALUE_KEY)
3794
3853
  if (value != null) {
3795
3854
  layer.hillshadeHighlightColor(value)
3796
3855
  } else {
3797
- e("RNMBXHillshade", "value for hillshadeHighlightColor is null")
3856
+ Logger.e("RNMBXHillshade", "value for hillshadeHighlightColor is null")
3798
3857
  }
3799
3858
  }
3800
3859
  }
@@ -3813,14 +3872,14 @@ object RNMBXStyleFactory {
3813
3872
  if (expression != null) {
3814
3873
  layer.hillshadeAccentColor(expression)
3815
3874
  } else {
3816
- e("RNMBXHillshade", "Expression for hillshadeAccentColor is null")
3875
+ Logger.e("RNMBXHillshade", "Expression for hillshadeAccentColor is null")
3817
3876
  }
3818
3877
  } else {
3819
3878
  val value = styleValue.getInt(VALUE_KEY)
3820
3879
  if (value != null) {
3821
3880
  layer.hillshadeAccentColor(value)
3822
3881
  } else {
3823
- e("RNMBXHillshade", "value for hillshadeAccentColor is null")
3882
+ Logger.e("RNMBXHillshade", "value for hillshadeAccentColor is null")
3824
3883
  }
3825
3884
  }
3826
3885
  }
@@ -3843,14 +3902,14 @@ object RNMBXStyleFactory {
3843
3902
  if (expression != null) {
3844
3903
  layer.modelId(expression)
3845
3904
  } else {
3846
- e("RNMBXModel", "Expression for modelId is null")
3905
+ Logger.e("RNMBXModel", "Expression for modelId is null")
3847
3906
  }
3848
3907
  } else {
3849
3908
  val value = styleValue.getString(VALUE_KEY)
3850
3909
  if (value != null) {
3851
3910
  layer.modelId(value)
3852
3911
  } else {
3853
- e("RNMBXModel", "value for modelId is null")
3912
+ Logger.e("RNMBXModel", "value for modelId is null")
3854
3913
  }
3855
3914
  }
3856
3915
  }
@@ -3861,14 +3920,14 @@ object RNMBXStyleFactory {
3861
3920
  if (expression != null) {
3862
3921
  layer.modelOpacity(expression)
3863
3922
  } else {
3864
- e("RNMBXModel", "Expression for modelOpacity is null")
3923
+ Logger.e("RNMBXModel", "Expression for modelOpacity is null")
3865
3924
  }
3866
3925
  } else {
3867
3926
  val value = styleValue.getDouble(VALUE_KEY)
3868
3927
  if (value != null) {
3869
3928
  layer.modelOpacity(value)
3870
3929
  } else {
3871
- e("RNMBXModel", "value for modelOpacity is null")
3930
+ Logger.e("RNMBXModel", "value for modelOpacity is null")
3872
3931
  }
3873
3932
  }
3874
3933
  }
@@ -3887,14 +3946,14 @@ object RNMBXStyleFactory {
3887
3946
  if (expression != null) {
3888
3947
  layer.modelRotation(expression)
3889
3948
  } else {
3890
- e("RNMBXModel", "Expression for modelRotation is null")
3949
+ Logger.e("RNMBXModel", "Expression for modelRotation is null")
3891
3950
  }
3892
3951
  } else {
3893
3952
  val value = styleValue.getFloatArray(VALUE_KEY)
3894
3953
  if (value != null) {
3895
3954
  layer.modelRotation(value)
3896
3955
  } else {
3897
- e("RNMBXModel", "value for modelRotation is null")
3956
+ Logger.e("RNMBXModel", "value for modelRotation is null")
3898
3957
  }
3899
3958
  }
3900
3959
  }
@@ -3913,14 +3972,14 @@ object RNMBXStyleFactory {
3913
3972
  if (expression != null) {
3914
3973
  layer.modelScale(expression)
3915
3974
  } else {
3916
- e("RNMBXModel", "Expression for modelScale is null")
3975
+ Logger.e("RNMBXModel", "Expression for modelScale is null")
3917
3976
  }
3918
3977
  } else {
3919
3978
  val value = styleValue.getFloatArray(VALUE_KEY)
3920
3979
  if (value != null) {
3921
3980
  layer.modelScale(value)
3922
3981
  } else {
3923
- e("RNMBXModel", "value for modelScale is null")
3982
+ Logger.e("RNMBXModel", "value for modelScale is null")
3924
3983
  }
3925
3984
  }
3926
3985
  }
@@ -3939,14 +3998,14 @@ object RNMBXStyleFactory {
3939
3998
  if (expression != null) {
3940
3999
  layer.modelTranslation(expression)
3941
4000
  } else {
3942
- e("RNMBXModel", "Expression for modelTranslation is null")
4001
+ Logger.e("RNMBXModel", "Expression for modelTranslation is null")
3943
4002
  }
3944
4003
  } else {
3945
4004
  val value = styleValue.getFloatArray(VALUE_KEY)
3946
4005
  if (value != null) {
3947
4006
  layer.modelTranslation(value)
3948
4007
  } else {
3949
- e("RNMBXModel", "value for modelTranslation is null")
4008
+ Logger.e("RNMBXModel", "value for modelTranslation is null")
3950
4009
  }
3951
4010
  }
3952
4011
  }
@@ -3965,14 +4024,14 @@ object RNMBXStyleFactory {
3965
4024
  if (expression != null) {
3966
4025
  layer.modelColor(expression)
3967
4026
  } else {
3968
- e("RNMBXModel", "Expression for modelColor is null")
4027
+ Logger.e("RNMBXModel", "Expression for modelColor is null")
3969
4028
  }
3970
4029
  } else {
3971
4030
  val value = styleValue.getInt(VALUE_KEY)
3972
4031
  if (value != null) {
3973
4032
  layer.modelColor(value)
3974
4033
  } else {
3975
- e("RNMBXModel", "value for modelColor is null")
4034
+ Logger.e("RNMBXModel", "value for modelColor is null")
3976
4035
  }
3977
4036
  }
3978
4037
  }
@@ -3991,14 +4050,14 @@ object RNMBXStyleFactory {
3991
4050
  if (expression != null) {
3992
4051
  layer.modelColorMixIntensity(expression)
3993
4052
  } else {
3994
- e("RNMBXModel", "Expression for modelColorMixIntensity is null")
4053
+ Logger.e("RNMBXModel", "Expression for modelColorMixIntensity is null")
3995
4054
  }
3996
4055
  } else {
3997
4056
  val value = styleValue.getDouble(VALUE_KEY)
3998
4057
  if (value != null) {
3999
4058
  layer.modelColorMixIntensity(value)
4000
4059
  } else {
4001
- e("RNMBXModel", "value for modelColorMixIntensity is null")
4060
+ Logger.e("RNMBXModel", "value for modelColorMixIntensity is null")
4002
4061
  }
4003
4062
  }
4004
4063
  }
@@ -4017,7 +4076,7 @@ object RNMBXStyleFactory {
4017
4076
  if (expression != null) {
4018
4077
  layer.modelType(expression)
4019
4078
  } else {
4020
- e("RNMBXModel", "Expression for modelType is null")
4079
+ Logger.e("RNMBXModel", "Expression for modelType is null")
4021
4080
  }
4022
4081
  } else {
4023
4082
  layer.modelType(ModelType.valueOf(styleValue.getEnumName()))
@@ -4030,14 +4089,14 @@ object RNMBXStyleFactory {
4030
4089
  if (expression != null) {
4031
4090
  layer.modelCastShadows(expression)
4032
4091
  } else {
4033
- e("RNMBXModel", "Expression for modelCastShadows is null")
4092
+ Logger.e("RNMBXModel", "Expression for modelCastShadows is null")
4034
4093
  }
4035
4094
  } else {
4036
4095
  val value = styleValue.getBoolean(VALUE_KEY)
4037
4096
  if (value != null) {
4038
4097
  layer.modelCastShadows(value)
4039
4098
  } else {
4040
- e("RNMBXModel", "value for modelCastShadows is null")
4099
+ Logger.e("RNMBXModel", "value for modelCastShadows is null")
4041
4100
  }
4042
4101
  }
4043
4102
  }
@@ -4048,14 +4107,14 @@ object RNMBXStyleFactory {
4048
4107
  if (expression != null) {
4049
4108
  layer.modelReceiveShadows(expression)
4050
4109
  } else {
4051
- e("RNMBXModel", "Expression for modelReceiveShadows is null")
4110
+ Logger.e("RNMBXModel", "Expression for modelReceiveShadows is null")
4052
4111
  }
4053
4112
  } else {
4054
4113
  val value = styleValue.getBoolean(VALUE_KEY)
4055
4114
  if (value != null) {
4056
4115
  layer.modelReceiveShadows(value)
4057
4116
  } else {
4058
- e("RNMBXModel", "value for modelReceiveShadows is null")
4117
+ Logger.e("RNMBXModel", "value for modelReceiveShadows is null")
4059
4118
  }
4060
4119
  }
4061
4120
  }
@@ -4066,14 +4125,14 @@ object RNMBXStyleFactory {
4066
4125
  if (expression != null) {
4067
4126
  layer.modelAmbientOcclusionIntensity(expression)
4068
4127
  } else {
4069
- e("RNMBXModel", "Expression for modelAmbientOcclusionIntensity is null")
4128
+ Logger.e("RNMBXModel", "Expression for modelAmbientOcclusionIntensity is null")
4070
4129
  }
4071
4130
  } else {
4072
4131
  val value = styleValue.getDouble(VALUE_KEY)
4073
4132
  if (value != null) {
4074
4133
  layer.modelAmbientOcclusionIntensity(value)
4075
4134
  } else {
4076
- e("RNMBXModel", "value for modelAmbientOcclusionIntensity is null")
4135
+ Logger.e("RNMBXModel", "value for modelAmbientOcclusionIntensity is null")
4077
4136
  }
4078
4137
  }
4079
4138
  }
@@ -4092,14 +4151,14 @@ object RNMBXStyleFactory {
4092
4151
  if (expression != null) {
4093
4152
  layer.modelEmissiveStrength(expression)
4094
4153
  } else {
4095
- e("RNMBXModel", "Expression for modelEmissiveStrength is null")
4154
+ Logger.e("RNMBXModel", "Expression for modelEmissiveStrength is null")
4096
4155
  }
4097
4156
  } else {
4098
4157
  val value = styleValue.getDouble(VALUE_KEY)
4099
4158
  if (value != null) {
4100
4159
  layer.modelEmissiveStrength(value)
4101
4160
  } else {
4102
- e("RNMBXModel", "value for modelEmissiveStrength is null")
4161
+ Logger.e("RNMBXModel", "value for modelEmissiveStrength is null")
4103
4162
  }
4104
4163
  }
4105
4164
  }
@@ -4118,14 +4177,14 @@ object RNMBXStyleFactory {
4118
4177
  if (expression != null) {
4119
4178
  layer.modelRoughness(expression)
4120
4179
  } else {
4121
- e("RNMBXModel", "Expression for modelRoughness is null")
4180
+ Logger.e("RNMBXModel", "Expression for modelRoughness is null")
4122
4181
  }
4123
4182
  } else {
4124
4183
  val value = styleValue.getDouble(VALUE_KEY)
4125
4184
  if (value != null) {
4126
4185
  layer.modelRoughness(value)
4127
4186
  } else {
4128
- e("RNMBXModel", "value for modelRoughness is null")
4187
+ Logger.e("RNMBXModel", "value for modelRoughness is null")
4129
4188
  }
4130
4189
  }
4131
4190
  }
@@ -4144,14 +4203,14 @@ object RNMBXStyleFactory {
4144
4203
  if (expression != null) {
4145
4204
  layer.modelHeightBasedEmissiveStrengthMultiplier(expression)
4146
4205
  } else {
4147
- e("RNMBXModel", "Expression for modelHeightBasedEmissiveStrengthMultiplier is null")
4206
+ Logger.e("RNMBXModel", "Expression for modelHeightBasedEmissiveStrengthMultiplier is null")
4148
4207
  }
4149
4208
  } else {
4150
4209
  val value = styleValue.getFloatArray(VALUE_KEY)
4151
4210
  if (value != null) {
4152
4211
  layer.modelHeightBasedEmissiveStrengthMultiplier(value)
4153
4212
  } else {
4154
- e("RNMBXModel", "value for modelHeightBasedEmissiveStrengthMultiplier is null")
4213
+ Logger.e("RNMBXModel", "value for modelHeightBasedEmissiveStrengthMultiplier is null")
4155
4214
  }
4156
4215
  }
4157
4216
  }
@@ -4170,14 +4229,14 @@ object RNMBXStyleFactory {
4170
4229
  if (expression != null) {
4171
4230
  layer.modelCutoffFadeRange(expression)
4172
4231
  } else {
4173
- e("RNMBXModel", "Expression for modelCutoffFadeRange is null")
4232
+ Logger.e("RNMBXModel", "Expression for modelCutoffFadeRange is null")
4174
4233
  }
4175
4234
  } else {
4176
4235
  val value = styleValue.getDouble(VALUE_KEY)
4177
4236
  if (value != null) {
4178
4237
  layer.modelCutoffFadeRange(value)
4179
4238
  } else {
4180
- e("RNMBXModel", "value for modelCutoffFadeRange is null")
4239
+ Logger.e("RNMBXModel", "value for modelCutoffFadeRange is null")
4181
4240
  }
4182
4241
  }
4183
4242
  }
@@ -4192,14 +4251,14 @@ object RNMBXStyleFactory {
4192
4251
  if (expression != null) {
4193
4252
  layer.backgroundColor(expression)
4194
4253
  } else {
4195
- e("RNMBXBackground", "Expression for backgroundColor is null")
4254
+ Logger.e("RNMBXBackground", "Expression for backgroundColor is null")
4196
4255
  }
4197
4256
  } else {
4198
4257
  val value = styleValue.getInt(VALUE_KEY)
4199
4258
  if (value != null) {
4200
4259
  layer.backgroundColor(value)
4201
4260
  } else {
4202
- e("RNMBXBackground", "value for backgroundColor is null")
4261
+ Logger.e("RNMBXBackground", "value for backgroundColor is null")
4203
4262
  }
4204
4263
  }
4205
4264
  }
@@ -4219,14 +4278,14 @@ object RNMBXStyleFactory {
4219
4278
  if (value != null) {
4220
4279
  layer.backgroundPattern(value)
4221
4280
  } else {
4222
- e("RNMBXBackground", "Image for backgroundPattern is null")
4281
+ Logger.e("RNMBXBackground", "Image for backgroundPattern is null")
4223
4282
  }
4224
4283
  } else {
4225
4284
  val expression = styleValue.getExpression()
4226
4285
  if (expression != null) {
4227
4286
  layer.backgroundPattern(expression)
4228
4287
  } else {
4229
- e("RNMBXBackground", "Expression for backgroundPattern is null")
4288
+ Logger.e("RNMBXBackground", "Expression for backgroundPattern is null")
4230
4289
  }
4231
4290
  }
4232
4291
  } else {
@@ -4234,7 +4293,7 @@ object RNMBXStyleFactory {
4234
4293
  if (value != null) {
4235
4294
  layer.backgroundPattern(value);
4236
4295
  } else {
4237
- e("RNMBXBackground", "value for backgroundPattern is null")
4296
+ Logger.e("RNMBXBackground", "value for backgroundPattern is null")
4238
4297
  }
4239
4298
  }
4240
4299
  }
@@ -4245,14 +4304,14 @@ object RNMBXStyleFactory {
4245
4304
  if (expression != null) {
4246
4305
  layer.backgroundOpacity(expression)
4247
4306
  } else {
4248
- e("RNMBXBackground", "Expression for backgroundOpacity is null")
4307
+ Logger.e("RNMBXBackground", "Expression for backgroundOpacity is null")
4249
4308
  }
4250
4309
  } else {
4251
4310
  val value = styleValue.getDouble(VALUE_KEY)
4252
4311
  if (value != null) {
4253
4312
  layer.backgroundOpacity(value)
4254
4313
  } else {
4255
- e("RNMBXBackground", "value for backgroundOpacity is null")
4314
+ Logger.e("RNMBXBackground", "value for backgroundOpacity is null")
4256
4315
  }
4257
4316
  }
4258
4317
  }
@@ -4271,14 +4330,14 @@ object RNMBXStyleFactory {
4271
4330
  if (expression != null) {
4272
4331
  layer.backgroundEmissiveStrength(expression)
4273
4332
  } else {
4274
- e("RNMBXBackground", "Expression for backgroundEmissiveStrength is null")
4333
+ Logger.e("RNMBXBackground", "Expression for backgroundEmissiveStrength is null")
4275
4334
  }
4276
4335
  } else {
4277
4336
  val value = styleValue.getDouble(VALUE_KEY)
4278
4337
  if (value != null) {
4279
4338
  layer.backgroundEmissiveStrength(value)
4280
4339
  } else {
4281
- e("RNMBXBackground", "value for backgroundEmissiveStrength is null")
4340
+ Logger.e("RNMBXBackground", "value for backgroundEmissiveStrength is null")
4282
4341
  }
4283
4342
  }
4284
4343
  }
@@ -4301,7 +4360,7 @@ object RNMBXStyleFactory {
4301
4360
  if (expression != null) {
4302
4361
  layer.skyType(expression)
4303
4362
  } else {
4304
- e("RNMBXSky", "Expression for skyType is null")
4363
+ Logger.e("RNMBXSky", "Expression for skyType is null")
4305
4364
  }
4306
4365
  } else {
4307
4366
  layer.skyType(SkyType.valueOf(styleValue.getEnumName()))
@@ -4314,14 +4373,14 @@ object RNMBXStyleFactory {
4314
4373
  if (expression != null) {
4315
4374
  layer.skyAtmosphereSun(expression)
4316
4375
  } else {
4317
- e("RNMBXSky", "Expression for skyAtmosphereSun is null")
4376
+ Logger.e("RNMBXSky", "Expression for skyAtmosphereSun is null")
4318
4377
  }
4319
4378
  } else {
4320
4379
  val value = styleValue.getFloatArray(VALUE_KEY)
4321
4380
  if (value != null) {
4322
4381
  layer.skyAtmosphereSun(value)
4323
4382
  } else {
4324
- e("RNMBXSky", "value for skyAtmosphereSun is null")
4383
+ Logger.e("RNMBXSky", "value for skyAtmosphereSun is null")
4325
4384
  }
4326
4385
  }
4327
4386
  }
@@ -4332,14 +4391,14 @@ object RNMBXStyleFactory {
4332
4391
  if (expression != null) {
4333
4392
  layer.skyAtmosphereSunIntensity(expression)
4334
4393
  } else {
4335
- e("RNMBXSky", "Expression for skyAtmosphereSunIntensity is null")
4394
+ Logger.e("RNMBXSky", "Expression for skyAtmosphereSunIntensity is null")
4336
4395
  }
4337
4396
  } else {
4338
4397
  val value = styleValue.getDouble(VALUE_KEY)
4339
4398
  if (value != null) {
4340
4399
  layer.skyAtmosphereSunIntensity(value)
4341
4400
  } else {
4342
- e("RNMBXSky", "value for skyAtmosphereSunIntensity is null")
4401
+ Logger.e("RNMBXSky", "value for skyAtmosphereSunIntensity is null")
4343
4402
  }
4344
4403
  }
4345
4404
  }
@@ -4350,14 +4409,14 @@ object RNMBXStyleFactory {
4350
4409
  if (expression != null) {
4351
4410
  layer.skyGradientCenter(expression)
4352
4411
  } else {
4353
- e("RNMBXSky", "Expression for skyGradientCenter is null")
4412
+ Logger.e("RNMBXSky", "Expression for skyGradientCenter is null")
4354
4413
  }
4355
4414
  } else {
4356
4415
  val value = styleValue.getFloatArray(VALUE_KEY)
4357
4416
  if (value != null) {
4358
4417
  layer.skyGradientCenter(value)
4359
4418
  } else {
4360
- e("RNMBXSky", "value for skyGradientCenter is null")
4419
+ Logger.e("RNMBXSky", "value for skyGradientCenter is null")
4361
4420
  }
4362
4421
  }
4363
4422
  }
@@ -4368,14 +4427,14 @@ object RNMBXStyleFactory {
4368
4427
  if (expression != null) {
4369
4428
  layer.skyGradientRadius(expression)
4370
4429
  } else {
4371
- e("RNMBXSky", "Expression for skyGradientRadius is null")
4430
+ Logger.e("RNMBXSky", "Expression for skyGradientRadius is null")
4372
4431
  }
4373
4432
  } else {
4374
4433
  val value = styleValue.getDouble(VALUE_KEY)
4375
4434
  if (value != null) {
4376
4435
  layer.skyGradientRadius(value)
4377
4436
  } else {
4378
- e("RNMBXSky", "value for skyGradientRadius is null")
4437
+ Logger.e("RNMBXSky", "value for skyGradientRadius is null")
4379
4438
  }
4380
4439
  }
4381
4440
  }
@@ -4386,7 +4445,7 @@ object RNMBXStyleFactory {
4386
4445
  if (expression != null) {
4387
4446
  layer.skyGradient(expression)
4388
4447
  } else {
4389
- e("RNMBXSky", "Expression for skyGradient is null")
4448
+ Logger.e("RNMBXSky", "Expression for skyGradient is null")
4390
4449
  }
4391
4450
  } else {
4392
4451
  layer.skyGradient(styleValue.getIntExpression(VALUE_KEY))
@@ -4399,14 +4458,14 @@ object RNMBXStyleFactory {
4399
4458
  if (expression != null) {
4400
4459
  layer.skyAtmosphereHaloColor(expression)
4401
4460
  } else {
4402
- e("RNMBXSky", "Expression for skyAtmosphereHaloColor is null")
4461
+ Logger.e("RNMBXSky", "Expression for skyAtmosphereHaloColor is null")
4403
4462
  }
4404
4463
  } else {
4405
4464
  val value = styleValue.getInt(VALUE_KEY)
4406
4465
  if (value != null) {
4407
4466
  layer.skyAtmosphereHaloColor(value)
4408
4467
  } else {
4409
- e("RNMBXSky", "value for skyAtmosphereHaloColor is null")
4468
+ Logger.e("RNMBXSky", "value for skyAtmosphereHaloColor is null")
4410
4469
  }
4411
4470
  }
4412
4471
  }
@@ -4417,14 +4476,14 @@ object RNMBXStyleFactory {
4417
4476
  if (expression != null) {
4418
4477
  layer.skyAtmosphereColor(expression)
4419
4478
  } else {
4420
- e("RNMBXSky", "Expression for skyAtmosphereColor is null")
4479
+ Logger.e("RNMBXSky", "Expression for skyAtmosphereColor is null")
4421
4480
  }
4422
4481
  } else {
4423
4482
  val value = styleValue.getInt(VALUE_KEY)
4424
4483
  if (value != null) {
4425
4484
  layer.skyAtmosphereColor(value)
4426
4485
  } else {
4427
- e("RNMBXSky", "value for skyAtmosphereColor is null")
4486
+ Logger.e("RNMBXSky", "value for skyAtmosphereColor is null")
4428
4487
  }
4429
4488
  }
4430
4489
  }
@@ -4435,14 +4494,14 @@ object RNMBXStyleFactory {
4435
4494
  if (expression != null) {
4436
4495
  layer.skyOpacity(expression)
4437
4496
  } else {
4438
- e("RNMBXSky", "Expression for skyOpacity is null")
4497
+ Logger.e("RNMBXSky", "Expression for skyOpacity is null")
4439
4498
  }
4440
4499
  } else {
4441
4500
  val value = styleValue.getDouble(VALUE_KEY)
4442
4501
  if (value != null) {
4443
4502
  layer.skyOpacity(value)
4444
4503
  } else {
4445
- e("RNMBXSky", "value for skyOpacity is null")
4504
+ Logger.e("RNMBXSky", "value for skyOpacity is null")
4446
4505
  }
4447
4506
  }
4448
4507
  }
@@ -4461,7 +4520,7 @@ object RNMBXStyleFactory {
4461
4520
  if (expression != null) {
4462
4521
  layer.anchor(expression)
4463
4522
  } else {
4464
- e("RNMBXLight", "Expression for anchor is null")
4523
+ Logger.e("RNMBXLight", "Expression for anchor is null")
4465
4524
  }
4466
4525
  } else {
4467
4526
  layer.anchor(Anchor.valueOf(styleValue.getEnumName()))
@@ -4474,7 +4533,7 @@ object RNMBXStyleFactory {
4474
4533
  if (expression != null) {
4475
4534
  layer.position(expression)
4476
4535
  } else {
4477
- e("RNMBXLight", "Expression for position is null")
4536
+ Logger.e("RNMBXLight", "Expression for position is null")
4478
4537
  }
4479
4538
  } else {
4480
4539
  layer.position(styleValue.getLightPosition())
@@ -4495,14 +4554,14 @@ object RNMBXStyleFactory {
4495
4554
  if (expression != null) {
4496
4555
  layer.color(expression)
4497
4556
  } else {
4498
- e("RNMBXLight", "Expression for color is null")
4557
+ Logger.e("RNMBXLight", "Expression for color is null")
4499
4558
  }
4500
4559
  } else {
4501
4560
  val value = styleValue.getInt(VALUE_KEY)
4502
4561
  if (value != null) {
4503
4562
  layer.color(value)
4504
4563
  } else {
4505
- e("RNMBXLight", "value for color is null")
4564
+ Logger.e("RNMBXLight", "value for color is null")
4506
4565
  }
4507
4566
  }
4508
4567
  }
@@ -4521,14 +4580,14 @@ object RNMBXStyleFactory {
4521
4580
  if (expression != null) {
4522
4581
  layer.intensity(expression)
4523
4582
  } else {
4524
- e("RNMBXLight", "Expression for intensity is null")
4583
+ Logger.e("RNMBXLight", "Expression for intensity is null")
4525
4584
  }
4526
4585
  } else {
4527
4586
  val value = styleValue.getDouble(VALUE_KEY)
4528
4587
  if (value != null) {
4529
4588
  layer.intensity(value)
4530
4589
  } else {
4531
- e("RNMBXLight", "value for intensity is null")
4590
+ Logger.e("RNMBXLight", "value for intensity is null")
4532
4591
  }
4533
4592
  }
4534
4593
  }
@@ -4547,14 +4606,14 @@ object RNMBXStyleFactory {
4547
4606
  if (expression != null) {
4548
4607
  layer.range(expression)
4549
4608
  } else {
4550
- e("RNMBXAtmosphere", "Expression for range is null")
4609
+ Logger.e("RNMBXAtmosphere", "Expression for range is null")
4551
4610
  }
4552
4611
  } else {
4553
4612
  val value = styleValue.getFloatArray(VALUE_KEY)
4554
4613
  if (value != null) {
4555
4614
  layer.range(value)
4556
4615
  } else {
4557
- e("RNMBXAtmosphere", "value for range is null")
4616
+ Logger.e("RNMBXAtmosphere", "value for range is null")
4558
4617
  }
4559
4618
  }
4560
4619
  }
@@ -4573,14 +4632,14 @@ object RNMBXStyleFactory {
4573
4632
  if (expression != null) {
4574
4633
  layer.color(expression)
4575
4634
  } else {
4576
- e("RNMBXAtmosphere", "Expression for color is null")
4635
+ Logger.e("RNMBXAtmosphere", "Expression for color is null")
4577
4636
  }
4578
4637
  } else {
4579
4638
  val value = styleValue.getInt(VALUE_KEY)
4580
4639
  if (value != null) {
4581
4640
  layer.color(value)
4582
4641
  } else {
4583
- e("RNMBXAtmosphere", "value for color is null")
4642
+ Logger.e("RNMBXAtmosphere", "value for color is null")
4584
4643
  }
4585
4644
  }
4586
4645
  }
@@ -4599,14 +4658,14 @@ object RNMBXStyleFactory {
4599
4658
  if (expression != null) {
4600
4659
  layer.highColor(expression)
4601
4660
  } else {
4602
- e("RNMBXAtmosphere", "Expression for highColor is null")
4661
+ Logger.e("RNMBXAtmosphere", "Expression for highColor is null")
4603
4662
  }
4604
4663
  } else {
4605
4664
  val value = styleValue.getInt(VALUE_KEY)
4606
4665
  if (value != null) {
4607
4666
  layer.highColor(value)
4608
4667
  } else {
4609
- e("RNMBXAtmosphere", "value for highColor is null")
4668
+ Logger.e("RNMBXAtmosphere", "value for highColor is null")
4610
4669
  }
4611
4670
  }
4612
4671
  }
@@ -4625,14 +4684,14 @@ object RNMBXStyleFactory {
4625
4684
  if (expression != null) {
4626
4685
  layer.spaceColor(expression)
4627
4686
  } else {
4628
- e("RNMBXAtmosphere", "Expression for spaceColor is null")
4687
+ Logger.e("RNMBXAtmosphere", "Expression for spaceColor is null")
4629
4688
  }
4630
4689
  } else {
4631
4690
  val value = styleValue.getInt(VALUE_KEY)
4632
4691
  if (value != null) {
4633
4692
  layer.spaceColor(value)
4634
4693
  } else {
4635
- e("RNMBXAtmosphere", "value for spaceColor is null")
4694
+ Logger.e("RNMBXAtmosphere", "value for spaceColor is null")
4636
4695
  }
4637
4696
  }
4638
4697
  }
@@ -4651,14 +4710,14 @@ object RNMBXStyleFactory {
4651
4710
  if (expression != null) {
4652
4711
  layer.horizonBlend(expression)
4653
4712
  } else {
4654
- e("RNMBXAtmosphere", "Expression for horizonBlend is null")
4713
+ Logger.e("RNMBXAtmosphere", "Expression for horizonBlend is null")
4655
4714
  }
4656
4715
  } else {
4657
4716
  val value = styleValue.getDouble(VALUE_KEY)
4658
4717
  if (value != null) {
4659
4718
  layer.horizonBlend(value)
4660
4719
  } else {
4661
- e("RNMBXAtmosphere", "value for horizonBlend is null")
4720
+ Logger.e("RNMBXAtmosphere", "value for horizonBlend is null")
4662
4721
  }
4663
4722
  }
4664
4723
  }
@@ -4677,14 +4736,14 @@ object RNMBXStyleFactory {
4677
4736
  if (expression != null) {
4678
4737
  layer.starIntensity(expression)
4679
4738
  } else {
4680
- e("RNMBXAtmosphere", "Expression for starIntensity is null")
4739
+ Logger.e("RNMBXAtmosphere", "Expression for starIntensity is null")
4681
4740
  }
4682
4741
  } else {
4683
4742
  val value = styleValue.getDouble(VALUE_KEY)
4684
4743
  if (value != null) {
4685
4744
  layer.starIntensity(value)
4686
4745
  } else {
4687
- e("RNMBXAtmosphere", "value for starIntensity is null")
4746
+ Logger.e("RNMBXAtmosphere", "value for starIntensity is null")
4688
4747
  }
4689
4748
  }
4690
4749
  }
@@ -4703,14 +4762,14 @@ object RNMBXStyleFactory {
4703
4762
  if (expression != null) {
4704
4763
  layer.verticalRange(expression)
4705
4764
  } else {
4706
- e("RNMBXAtmosphere", "Expression for verticalRange is null")
4765
+ Logger.e("RNMBXAtmosphere", "Expression for verticalRange is null")
4707
4766
  }
4708
4767
  } else {
4709
4768
  val value = styleValue.getFloatArray(VALUE_KEY)
4710
4769
  if (value != null) {
4711
4770
  layer.verticalRange(value)
4712
4771
  } else {
4713
- e("RNMBXAtmosphere", "value for verticalRange is null")
4772
+ Logger.e("RNMBXAtmosphere", "value for verticalRange is null")
4714
4773
  }
4715
4774
  }
4716
4775
  }
@@ -4729,14 +4788,14 @@ object RNMBXStyleFactory {
4729
4788
  if (expression != null) {
4730
4789
  layer.exaggeration(expression)
4731
4790
  } else {
4732
- e("RNMBXTerrain", "Expression for exaggeration is null")
4791
+ Logger.e("RNMBXTerrain", "Expression for exaggeration is null")
4733
4792
  }
4734
4793
  } else {
4735
4794
  val value = styleValue.getDouble(VALUE_KEY)
4736
4795
  if (value != null) {
4737
4796
  layer.exaggeration(value)
4738
4797
  } else {
4739
- e("RNMBXTerrain", "value for exaggeration is null")
4798
+ Logger.e("RNMBXTerrain", "value for exaggeration is null")
4740
4799
  }
4741
4800
  }
4742
4801
  }