You can simply do:

if (zoom < 12 || zoom > 18) {
  return null;
}

in getTile.

@#1: Sorry, but you are missing the point completely.

The point of these additions are not for the sake of the TileProvider, but for the GoogleMap instance. Right now, the zoom extents are set to internal constants relative to what Google can provide for its basemaps. The problem comes when the only TileProvider is a custom one (with MAP_TYPE_NONE) and it can only provide a limited set of zoom levels.

Returning null or Tile.NO_TILE from the TileProvider instance does NOT prevent the map from zooming in or out. Instead, the user is presented a black screen or gray grid, which is poor UX. The user is now confused and looses all sense of map location.

The ideal implementation in my honest opinion would be that the GoogleMap instance would ask all of its TileProviders for their min and maximum zoom levels, take the overall min and max, and then limit the map to only these zoom levels. In other words, the pinch gesture and onscreen +/- controls should respect these limited min/max values.

I didn't read your original description carefully. "constrain what zoom levels are available" says it all.

Thinking of it, I would prefer GoogleMap.setMinZoomLevel and GoogleMap.setMaxZoomLevel (also in GoogleMapOptions and in xml). I could imagine an app that doesn't want user to zoom out too much even without custom tiles, e.g. when all markers and other visible objects are in one city.

Yes, agree with #3. Changing description to match.

 Issue 5269  has been merged into this issue.

I've run into this as well, using the Google Maps API but wanting to provide a custom tile set (i.e. it's not a map on Earth).  Is this in the plan?  Is there any kind of work-around until it is?

@#6 [email protected]

http://www.youtube.com/watch?v=-nCZ37HdheY

(No comment was entered for this change.)

Just FYI...  I dealt with this by creating a TileProvider that calls UrlTileProvider and, if it fails then zooming out until it works at which point I extract the proper internal rectangle, scale it up, re-encode it as a PNG from which I create a new Tile (because there doesn't seem to be a way to create a Tile from a Bitmap), and return 
that generated tile.  Works quite well, actually.

Some problems...

The Tile documentation at http://developer.android.com/reference/com/google/android/gms/maps/model/Tile.html is missing what formats are understood in the "byte[] data" and the link to TileCreator returns 404.

Other Tile documentation at https://developers.google.com/maps/documentation/android/reference/com/google/android/gms/maps/model/Tile also has empty data for "CREATOR", no href to TileCreator, and the link at the bottom to "decodeByteArray(...)" is also 404.

The documentation for BitmapFactory is similarly missing what formats can be decoded.  I'd prefer not to re-encode my scaled image as PNG but rather create a new Tile directly from my scaled bitmap.

I've hit this the opposite way.  My TileOverlay has details well beyond what Google Maps has but I can't continue to zoom in past zoom=19.  It  would be great to be able to set it as deep as I want.  If I want to show the notes in the margin of the calendar on a desk in the cabin of a ship in the middle of the Pacific Ocean, then I should be able to zoom in far enough to do so (as long as I'm providing the imagery myself, of course).

Granted, I expect a zoom limit of 31 is probably the largest practical amount.

in general, camera limiting would be very useful on Gmaps. Both in zoom and in bounds/center of the camera. you can use a camerachangedlistener to achieve this, but it's still a weird experience

The iOS Google Maps API has this exact functionality---odd that it's not present in Android.

https://developers.google.com/maps/documentation/ios-sdk/views#zoom