react-native-maps 0.31.0 → 1.0.0-alpha.1

package/android/src/main/java/com/rnmaps/maps/MapPolyline.java

@@ -0,0 +1,230 @@
+package com.rnmaps.maps;
+
+import android.content.Context;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.common.MapBuilder;
+import com.google.android.gms.maps.model.ButtCap;
+import com.google.android.gms.maps.model.Cap;
+import com.google.android.gms.maps.model.Dash;
+import com.google.android.gms.maps.model.Dot;
+import com.google.android.gms.maps.model.Gap;
+import com.google.android.gms.maps.model.JointType;
+import com.google.android.gms.maps.model.LatLng;
+import com.google.android.gms.maps.model.PatternItem;
+import com.google.android.gms.maps.model.Polyline;
+import com.google.android.gms.maps.model.PolylineOptions;
+import com.google.android.gms.maps.model.RoundCap;
+import com.google.android.gms.maps.model.SquareCap;
+import com.google.android.gms.maps.model.StrokeStyle;
+import com.google.android.gms.maps.model.StyleSpan;
+import com.google.maps.android.collections.PolylineManager;
+import com.rnmaps.fabric.event.OnPressEvent;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class MapPolyline extends MapFeature {
+
+    private PolylineOptions polylineOptions;
+    private Polyline polyline;
+
+    private List<LatLng> coordinates;
+    private int color;
+    private float width;
+    private boolean tappable;
+    private boolean geodesic;
+    private float zIndex;
+    private Cap lineCap = new RoundCap();
+    private ReadableArray patternValues;
+    private List<PatternItem> pattern;
+
+    public MapPolyline(Context context) {
+        super(context);
+    }
+
+    public void setCoordinates(ReadableArray coordinates) {
+        this.coordinates = new ArrayList<>(coordinates.size());
+        for (int i = 0; i < coordinates.size(); i++) {
+            ReadableMap coordinate = coordinates.getMap(i);
+            this.coordinates.add(i,
+                    new LatLng(coordinate.getDouble("latitude"), coordinate.getDouble("longitude")));
+        }
+        if (polyline != null) {
+            polyline.setPoints(this.coordinates);
+        }
+    }
+
+    public void setColor(int color) {
+        this.color = color;
+        if (polyline != null) {
+            polyline.setColor(color);
+        }
+    }
+
+    public void setStrokeColors(ReadableArray strokeColors) {
+        List<StyleSpan> spans = new ArrayList<>();
+        for (int i = 0; i < strokeColors.size(); i++) {
+            StrokeStyle stroke;
+
+            if (i == 0) {
+                stroke = StrokeStyle.colorBuilder(strokeColors.getInt(i)).build();
+            } else {
+                stroke = StrokeStyle.gradientBuilder(strokeColors.getInt(i - 1), strokeColors.getInt(i)).build();
+            }
+            spans.add(new StyleSpan(stroke));
+        }
+
+        polyline.setSpans(spans);
+    }
+
+    public void setWidth(float width) {
+        this.width = width;
+        if (polyline != null) {
+            polyline.setWidth(width);
+        }
+    }
+
+    public void setZIndex(float zIndex) {
+        this.zIndex = zIndex;
+        if (polyline != null) {
+            polyline.setZIndex(zIndex);
+        }
+    }
+
+    public void setTappable(boolean tapabble) {
+        this.tappable = tapabble;
+        if (polyline != null) {
+            polyline.setClickable(tappable);
+        }
+    }
+
+    public void setGeodesic(boolean geodesic) {
+        this.geodesic = geodesic;
+        if (polyline != null) {
+            polyline.setGeodesic(geodesic);
+        }
+    }
+
+    public void setLineCap(Cap cap) {
+        this.lineCap = cap;
+        if (polyline != null) {
+            polyline.setStartCap(cap);
+            polyline.setEndCap(cap);
+        }
+        this.applyPattern();
+    }
+
+    public void setLineDashPattern(ReadableArray patternValues) {
+        this.patternValues = patternValues;
+        this.applyPattern();
+    }
+
+    private void applyPattern() {
+        if (patternValues == null) {
+            return;
+        }
+        this.pattern = new ArrayList<>(patternValues.size());
+        for (int i = 0; i < patternValues.size(); i++) {
+            float patternValue = (float) patternValues.getDouble(i);
+            boolean isGap = i % 2 != 0;
+            if (isGap) {
+                this.pattern.add(new Gap(patternValue));
+            } else {
+                PatternItem patternItem;
+                boolean isLineCapRound = this.lineCap instanceof RoundCap;
+                if (isLineCapRound) {
+                    patternItem = new Dot();
+                } else {
+                    patternItem = new Dash(patternValue);
+                }
+                this.pattern.add(patternItem);
+            }
+        }
+        if (polyline != null) {
+            polyline.setPattern(this.pattern);
+        }
+    }
+
+    public PolylineOptions getPolylineOptions() {
+        if (polylineOptions == null) {
+            polylineOptions = createPolylineOptions();
+        }
+        return polylineOptions;
+    }
+
+    private PolylineOptions createPolylineOptions() {
+        PolylineOptions options = new PolylineOptions();
+        options.addAll(coordinates);
+        options.color(color);
+        options.width(width);
+        options.geodesic(geodesic);
+        options.zIndex(zIndex);
+        options.startCap(lineCap);
+        options.endCap(lineCap);
+        options.pattern(this.pattern);
+        return options;
+    }
+
+    @Override
+    public Object getFeature() {
+        return polyline;
+    }
+
+    @Override
+    public void addToMap(Object collection) {
+        PolylineManager.Collection polylineCollection = (PolylineManager.Collection) collection;
+        polyline = polylineCollection.addPolyline(getPolylineOptions());
+        polyline.setClickable(this.tappable);
+    }
+
+    @Override
+    public void removeFromMap(Object collection) {
+        PolylineManager.Collection polylineCollection = (PolylineManager.Collection) collection;
+        polylineCollection.remove(polyline);
+    }
+
+    public void setLineCap(String lineCap) {
+        Cap cap;
+        switch (lineCap) {
+            case "round":
+                cap = new RoundCap();
+                break;
+            case "square":
+                cap = new SquareCap();
+                break;
+            case "butt":
+            default:
+                cap = new ButtCap();
+                break;
+        }
+        setLineCap(cap);
+    }
+
+    public static Map<String, Object> getExportedCustomBubblingEventTypeConstants() {
+        MapBuilder.Builder<String, Object> builder = MapBuilder.builder();
+        builder.put(OnPressEvent.EVENT_NAME, MapBuilder.of("registrationName", OnPressEvent.EVENT_NAME));
+        return builder.build();
+    }
+
+    public void setLineJoin(String lineJoin) {
+        int type;
+        switch (lineJoin) {
+            case "round":
+                type = JointType.ROUND;
+                break;
+            case "bevel":
+                type = JointType.BEVEL;
+                break;
+            case "miter":
+            default:
+                type = JointType.DEFAULT;
+                break;
+        }
+        if (polyline != null) {
+            polyline.setJointType(type);
+        }
+    }
+}

package/android/src/main/java/com/{airbnb/android/react/maps/AirMapPolylineManager.java → rnmaps/maps/MapPolylineManager.java}

@@ -1,8 +1,7 @@
-package com.airbnb.android.react.maps;
+package com.rnmaps.maps;
 
 import android.content.Context;
 import android.graphics.Color;
-import android.os.Build;
 import android.util.DisplayMetrics;
 import android.view.WindowManager;
 
@@ -21,19 +20,15 @@ import com.google.android.gms.maps.model.SquareCap;
 
 import java.util.Map;
 
-public class AirMapPolylineManager extends ViewGroupManager<AirMapPolyline> {
+public class MapPolylineManager extends ViewGroupManager<MapPolyline> {
   private final DisplayMetrics metrics;
 
-  public AirMapPolylineManager(ReactApplicationContext reactContext) {
+  public MapPolylineManager(ReactApplicationContext reactContext) {
     super();
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
-      metrics = new DisplayMetrics();
-      ((WindowManager) reactContext.getSystemService(Context.WINDOW_SERVICE))
-          .getDefaultDisplay()
-          .getRealMetrics(metrics);
-    } else {
-      metrics = reactContext.getResources().getDisplayMetrics();
-    }
+    metrics = new DisplayMetrics();
+    ((WindowManager) reactContext.getSystemService(Context.WINDOW_SERVICE))
+        .getDefaultDisplay()
+        .getRealMetrics(metrics);
   }
 
   @Override
@@ -42,63 +37,48 @@ public class AirMapPolylineManager extends ViewGroupManager<AirMapPolyline> {
   }
 
   @Override
-  public AirMapPolyline createViewInstance(ThemedReactContext context) {
-    return new AirMapPolyline(context);
+  public MapPolyline createViewInstance(ThemedReactContext context) {
+    return new MapPolyline(context);
   }
 
   @ReactProp(name = "coordinates")
-  public void setCoordinate(AirMapPolyline view, ReadableArray coordinates) {
+  public void setCoordinate(MapPolyline view, ReadableArray coordinates) {
     view.setCoordinates(coordinates);
   }
 
   @ReactProp(name = "strokeWidth", defaultFloat = 1f)
-  public void setStrokeWidth(AirMapPolyline view, float widthInPoints) {
+  public void setStrokeWidth(MapPolyline view, float widthInPoints) {
     float widthInScreenPx = metrics.density * widthInPoints; // done for parity with iOS
     view.setWidth(widthInScreenPx);
   }
 
   @ReactProp(name = "strokeColor", defaultInt = Color.RED, customType = "Color")
-  public void setStrokeColor(AirMapPolyline view, int color) {
+  public void setStrokeColor(MapPolyline view, int color) {
     view.setColor(color);
   }
 
   @ReactProp(name = "tappable", defaultBoolean = false)
-  public void setTappable(AirMapPolyline view, boolean tapabble) {
+  public void setTappable(MapPolyline view, boolean tapabble) {
     view.setTappable(tapabble);
   }
 
   @ReactProp(name = "geodesic", defaultBoolean = false)
-  public void setGeodesic(AirMapPolyline view, boolean geodesic) {
+  public void setGeodesic(MapPolyline view, boolean geodesic) {
     view.setGeodesic(geodesic);
   }
 
   @ReactProp(name = "zIndex", defaultFloat = 1.0f)
-  public void setZIndex(AirMapPolyline view, float zIndex) {
+  public void setZIndex(MapPolyline view, float zIndex) {
     view.setZIndex(zIndex);
   }
 
   @ReactProp(name = "lineCap")
-  public void setlineCap(AirMapPolyline view, String lineCap) {
-    Cap cap = null;
-    switch (lineCap) {
-      case "butt":
-        cap = new ButtCap();
-        break;
-      case "round":
-        cap = new RoundCap();
-        break;
-      case "square":
-        cap = new SquareCap();
-        break;
-      default:
-        cap = new RoundCap();
-        break;
-    }
-    view.setLineCap(cap);
+  public void setlineCap(MapPolyline view, String lineCap) {
+      view.setLineCap(lineCap);
   }
 
   @ReactProp(name = "lineDashPattern")
-  public void setLineDashPattern(AirMapPolyline view, ReadableArray patternValues) {
+  public void setLineDashPattern(MapPolyline view, ReadableArray patternValues) {
       view.setLineDashPattern(patternValues);
   }
 

package/android/src/main/java/com/{airbnb/android/react/maps/AirMapTileProvider.java → rnmaps/maps/MapTileProvider.java}

@@ -1,4 +1,4 @@
-package com.airbnb.android.react.maps;
+package com.rnmaps.maps;
 
 import android.content.Context;
 
@@ -14,12 +14,8 @@ import android.graphics.Color;
 import android.graphics.Paint;
 import android.graphics.Rect;
 
-import androidx.annotation.NonNull;
 import androidx.work.OneTimeWorkRequest;
 import androidx.work.WorkManager;
-import androidx.work.WorkRequest;
-import androidx.work.Worker;
-import androidx.work.WorkerParameters;
 import androidx.work.Data;
 import androidx.work.Constraints;
 import androidx.work.NetworkType;
@@ -27,10 +23,7 @@ import androidx.work.ExistingWorkPolicy;
 import androidx.work.Operation;
 import androidx.work.WorkInfo;
 
-import com.google.android.gms.maps.GoogleMap;
 import com.google.android.gms.maps.model.Tile;
-import com.google.android.gms.maps.model.TileOverlay;
-import com.google.android.gms.maps.model.TileOverlayOptions;
 import com.google.android.gms.maps.model.TileProvider;
 import com.google.android.gms.maps.model.UrlTileProvider;
 
@@ -48,7 +41,7 @@ import java.net.MalformedURLException;
 import java.net.URL;
 import java.net.URLConnection;
 
-public class AirMapTileProvider implements TileProvider {
+public class MapTileProvider implements TileProvider {
 
 	class AIRMapUrlTileProvider extends UrlTileProvider {
     private String urlTemplate;
@@ -61,7 +54,7 @@ public class AirMapTileProvider implements TileProvider {
     @Override
     public URL getTileUrl(int x, int y, int zoom) {
 
-      if (AirMapTileProvider.this.flipY == true) {
+      if (MapTileProvider.this.flipY) {
         y = (1 << zoom) - y - 1;
       }
 
@@ -69,14 +62,14 @@ public class AirMapTileProvider implements TileProvider {
           .replace("{x}", Integer.toString(x))
           .replace("{y}", Integer.toString(y))
           .replace("{z}", Integer.toString(zoom));
-      URL url = null;
+      URL url;
 
-      if(AirMapTileProvider.this.maximumZ > 0 && zoom > AirMapTileProvider.this.maximumZ) {
-        return url;
+      if(MapTileProvider.this.maximumZ > 0 && zoom > MapTileProvider.this.maximumZ) {
+        return null;
       }
 
-      if(AirMapTileProvider.this.minimumZ > 0 && zoom < AirMapTileProvider.this.minimumZ) {
-        return url;
+      if(MapTileProvider.this.minimumZ > 0 && zoom < MapTileProvider.this.minimumZ) {
+        return null;
       }
 
       try {
@@ -108,9 +101,9 @@ public class AirMapTileProvider implements TileProvider {
 	protected Context context;
 	protected boolean customMode;
 
-	public AirMapTileProvider(int tileSizet, boolean doubleTileSize, String urlTemplate, 
-    int maximumZ, int maximumNativeZ, int minimumZ, boolean flipY, String tileCachePath, 
-    int tileCacheMaxAge, boolean offlineMode, Context context, boolean customMode) {
+	public MapTileProvider(int tileSizet, boolean doubleTileSize, String urlTemplate,
+                           int maximumZ, int maximumNativeZ, int minimumZ, boolean flipY, String tileCachePath,
+                           int tileCacheMaxAge, boolean offlineMode, Context context, boolean customMode) {
 		this.tileProvider = new AIRMapUrlTileProvider(tileSizet, tileSizet, urlTemplate);
 
 		this.tileSize = tileSizet;
@@ -152,7 +145,7 @@ public class AirMapTileProvider implements TileProvider {
     if (image == null && this.tileCachePath != null && this.offlineMode) {
       Log.d("urlTile", "findLowerZoomTileForScaling");
       int zoomLevelToStart = (zoom > this.maximumNativeZ) ? this.maximumNativeZ - 1 : zoom - 1; 
-      int minimumZoomToSearch = this.minimumZ >= zoom - 3 ? this.minimumZ : zoom - 3;
+      int minimumZoomToSearch = Math.max(this.minimumZ, zoom - 3);
       for (int tryZoom = zoomLevelToStart; tryZoom >= minimumZoomToSearch; tryZoom--) {
   			image = scaleLowerZoomTile(x, y, zoom, tryZoom);
 	  		if (image != null) {
@@ -166,16 +159,15 @@ public class AirMapTileProvider implements TileProvider {
 
 	byte[] getTileImage(int x, int y, int zoom) {
 		byte[] image = null;
-		boolean fallbackOnSyncFetch = false;
-		
+
 		if (this.tileCachePath != null) {
 			image = readTileImage(x, y, zoom);
 			if (image != null) {
-				Log.d("urlTile: tile cache HIT for ", Integer.toString(zoom) + 
-					"/" + Integer.toString(x) + "/" + Integer.toString(y));
+				Log.d("urlTile", "tile cache HIT for " + zoom +
+					"/" + x + "/" + y);
 			} else {
-				Log.d("urlTile: tile cache MISS for ", Integer.toString(zoom) + 
-        	"/" + Integer.toString(x) + "/" + Integer.toString(y));
+				Log.d("urlTile", "tile cache MISS for " + zoom +
+        	"/" + x + "/" + y);
 			}
 			if (image != null && !this.offlineMode) {
 				checkForRefresh(x, y, zoom);
@@ -187,7 +179,7 @@ public class AirMapTileProvider implements TileProvider {
 			Constraints constraints = new Constraints.Builder()
 				.setRequiredNetworkType(NetworkType.CONNECTED)
 				.build();
-			OneTimeWorkRequest tileRefreshWorkRequest = new OneTimeWorkRequest.Builder(AirMapTileWorker.class)
+			OneTimeWorkRequest tileRefreshWorkRequest = new OneTimeWorkRequest.Builder(MapTileWorker.class)
 				.setConstraints(constraints)
 				.addTag(fileName)
 				.setInputData(
@@ -198,39 +190,35 @@ public class AirMapTileProvider implements TileProvider {
 						.build()
 					)
 				.build();
-			if (tileRefreshWorkRequest != null) {
-				WorkManager workManager = WorkManager.getInstance(this.context.getApplicationContext());
-				Operation fetchOperation = workManager
-					.enqueueUniqueWork(fileName, ExistingWorkPolicy.KEEP, tileRefreshWorkRequest);
-				Future<Operation.State.SUCCESS> operationFuture = fetchOperation.getResult();
-				try {
-					operationFuture.get(1L, TimeUnit.SECONDS);
-					Thread.sleep(500);
-					Future<List<WorkInfo>> fetchFuture = workManager.getWorkInfosByTag(fileName);
-					List<WorkInfo> workInfo = fetchFuture.get(1L, TimeUnit.SECONDS);
-					Log.d("urlTile: ", workInfo.get(0).toString());
-					if (this.tileCachePath != null) {
-						image = readTileImage(x, y, zoom);
-						if (image != null) {
-							Log.d("urlTile: tile cache fetch HIT for ", Integer.toString(zoom) + 
-								"/" + Integer.toString(x) + "/" + Integer.toString(y));
-						} else {
-								Log.d("urlTile: tile cache fetch MISS for ", Integer.toString(zoom) + 
-									"/" + Integer.toString(x) + "/" + Integer.toString(y));
-						}
+			WorkManager workManager = WorkManager.getInstance(this.context.getApplicationContext());
+			Operation fetchOperation = workManager
+				.enqueueUniqueWork(fileName, ExistingWorkPolicy.KEEP, tileRefreshWorkRequest);
+			Future<Operation.State.SUCCESS> operationFuture = fetchOperation.getResult();
+			try {
+				operationFuture.get(1L, TimeUnit.SECONDS);
+				Thread.sleep(500);
+				Future<List<WorkInfo>> fetchFuture = workManager.getWorkInfosByTag(fileName);
+				List<WorkInfo> workInfo = fetchFuture.get(1L, TimeUnit.SECONDS);
+				Log.d("urlTile: ", workInfo.get(0).toString());
+				if (this.tileCachePath != null) {
+					image = readTileImage(x, y, zoom);
+					if (image != null) {
+						Log.d("urlTile","tile cache fetch HIT for " + zoom +
+							"/" + x + "/" + y);
+					} else {
+							Log.d("urlTile","tile cache fetch MISS for " + zoom +
+								"/" + x + "/" + y);
 					}
-				} catch (Exception e) {
-      			e.printStackTrace();
 				}
-			} else {
-				fallbackOnSyncFetch = true;
+			} catch (Exception e) {
+			  e.printStackTrace();
 			}
-		} else if (fallbackOnSyncFetch || (image == null && !this.offlineMode)) {
+		} else if (image == null && !this.offlineMode) {
 			Log.d("urlTile", "Normal fetch");
 			image = fetchTile(x, y, zoom);
 			if (image == null) {
-				Log.d("urlTile: tile fetch TIMEOUT / FAIL for ", Integer.toString(zoom) + 
-					"/" + Integer.toString(x) + "/" + Integer.toString(y));
+				Log.d("urlTile", "tile fetch TIMEOUT / FAIL for " + zoom +
+					"/" + x + "/" + y);
 			}
 		}
 
@@ -304,7 +292,7 @@ public class AirMapTileProvider implements TileProvider {
     int yParent = y >> overZoomLevel;
     int zoomParent = zoom - overZoomLevel;
     
-    int xOffset = x % zoomFactor;;
+    int xOffset = x % zoomFactor;
     int yOffset = y % zoomFactor;
 
     byte[] data;
@@ -340,7 +328,7 @@ public class AirMapTileProvider implements TileProvider {
 			Constraints constraints = new Constraints.Builder()
 				.setRequiredNetworkType(NetworkType.CONNECTED)
 				.build();
-			OneTimeWorkRequest tileRefreshWorkRequest = new OneTimeWorkRequest.Builder(AirMapTileWorker.class)
+			OneTimeWorkRequest tileRefreshWorkRequest = new OneTimeWorkRequest.Builder(MapTileWorker.class)
 				.setConstraints(constraints)
 				.addTag(fileName)
 				.setInputData(
@@ -351,11 +339,9 @@ public class AirMapTileProvider implements TileProvider {
 						.build()
 					)
 				.build();
-			if (tileRefreshWorkRequest != null) {
-				WorkManager.getInstance(this.context.getApplicationContext())
-				.enqueueUniqueWork(fileName, ExistingWorkPolicy.KEEP, tileRefreshWorkRequest);
-			} 
-		} 
+			WorkManager.getInstance(this.context.getApplicationContext())
+			.enqueueUniqueWork(fileName, ExistingWorkPolicy.KEEP, tileRefreshWorkRequest);
+		}
 	}
 
 	byte[] fetchTile(int x, int y, int zoom) {
@@ -377,10 +363,7 @@ public class AirMapTileProvider implements TileProvider {
 			buffer.flush();
 
 			return buffer.toByteArray();
-		} catch (IOException e) {
-			e.printStackTrace();
-			return null;
-		} catch (OutOfMemoryError e) {
+		} catch (IOException | OutOfMemoryError e) {
 			e.printStackTrace();
 			return null;
 		} finally {
@@ -416,10 +399,7 @@ public class AirMapTileProvider implements TileProvider {
 			}
 
 			return buffer.toByteArray();
-		} catch (IOException e) {
-			e.printStackTrace();
-			return null;
-		} catch (OutOfMemoryError e) {
+		} catch (IOException | OutOfMemoryError e) {
 			e.printStackTrace();
 			return null;
 		} finally {
@@ -442,10 +422,7 @@ public class AirMapTileProvider implements TileProvider {
 			out.write(image);
 
 			return true;
-		} catch (IOException e) {
-			e.printStackTrace();
-			return false;
-		} catch (OutOfMemoryError e) {
+		} catch (IOException | OutOfMemoryError e) {
 			e.printStackTrace();
 			return false;
 		} finally {
@@ -457,9 +434,8 @@ public class AirMapTileProvider implements TileProvider {
 		if (this.tileCachePath == null) {
 			return null;
 		}
-		String s = this.tileCachePath + '/' + Integer.toString(zoom) + 
-			"/" + Integer.toString(x) + "/" + Integer.toString(y);
-		return s;
+		return this.tileCachePath + '/' + zoom +
+			"/" + x + "/" + y;
 	}
 	
 	protected URL getTileUrl(int x, int y, int zoom) {
@@ -467,6 +443,10 @@ public class AirMapTileProvider implements TileProvider {
 	}
 	
 	public void setUrlTemplate(String urlTemplate) {
+		if (this.urlTemplate != urlTemplate) {
+			this.tileProvider = new AIRMapUrlTileProvider(tileSize, tileSize, urlTemplate);
+		}
+		
 		this.urlTemplate = urlTemplate;
 	}
 
@@ -510,6 +490,5 @@ public class AirMapTileProvider implements TileProvider {
 	}
 
 	public void setCustomMode() {
-		this.customMode = customMode;
 	}
 }

package/android/src/main/java/com/{airbnb/android/react/maps/AirMapTileWorker.java → rnmaps/maps/MapTileWorker.java}

@@ -1,4 +1,4 @@
-package com.airbnb.android.react.maps;
+package com.rnmaps.maps;
 
 import android.content.Context;
 
@@ -10,7 +10,6 @@ import androidx.work.WorkerParameters;
 
 import java.io.ByteArrayOutputStream;
 import java.io.File;
-import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.InputStream;
 import java.io.OutputStream;
@@ -19,10 +18,10 @@ import java.io.IOException;
 import java.net.MalformedURLException;
 import java.net.URL;
  
-public class AirMapTileWorker extends Worker {
+public class MapTileWorker extends Worker {
 	private static final int BUFFER_SIZE = 16 * 1024;
 
-	public AirMapTileWorker(
+	public MapTileWorker(
 			@NonNull Context context,
 			@NonNull WorkerParameters params) {
 			super(context, params);
@@ -30,8 +29,8 @@ public class AirMapTileWorker extends Worker {
 
 	@Override
 	public Result doWork() {
-		byte[] image = null;
-		URL url = null;
+		byte[] image;
+		URL url;
     String fileName = getInputData().getString("filename");
 
     try {
@@ -84,10 +83,7 @@ public class AirMapTileWorker extends Worker {
         buffer.flush();
 
         return buffer.toByteArray();
-      } catch (IOException e) {
-        e.printStackTrace();
-        return null;
-      } catch (OutOfMemoryError e) {
+      } catch (IOException | OutOfMemoryError e) {
         e.printStackTrace();
         return null;
       } finally {
@@ -109,10 +105,7 @@ public class AirMapTileWorker extends Worker {
         out.write(image);
 
         return true;
-      } catch (IOException e) {
-        e.printStackTrace();
-        return false;
-      } catch (OutOfMemoryError e) {
+      } catch (IOException | OutOfMemoryError e) {
         e.printStackTrace();
         return false;
       } finally {