import com.mapbox.mapboxsdk.offline.OfflineManager; //导入依赖的package包/类
private void createDownload(final OfflineDownload offlineDownload) {
  final OfflineTilePyramidRegionDefinition definition = offlineDownload.getRegionDefinition();
  final byte[] metadata = offlineDownload.getMetadata();
  OfflineManager.getInstance(getApplicationContext())
    .createOfflineRegion(
      definition,
      metadata,
      new OfflineManager.CreateOfflineRegionCallback() {
        @Override
        public void onCreate(OfflineRegion offlineRegion) {
          offlineDownload.setRegionId(offlineRegion.getID());
          OfflineDownloadStateReceiver.dispatchStartBroadcast(getApplicationContext(), offlineDownload);
          regionLongSparseArray.put(offlineDownload.getServiceId(), offlineRegion);

          launchDownload(offlineDownload, offlineRegion);
          showNotification(offlineDownload);
        }

        @Override
        public void onError(String error) {
          OfflineDownloadStateReceiver.dispatchErrorBroadcast(getApplicationContext(), offlineDownload, error);
        }
      });
}
 

import com.mapbox.mapboxsdk.offline.OfflineManager; //导入依赖的package包/类
private void loadOfflineRegion(final long id) {
  OfflineManager.getInstance(this)
    .listOfflineRegions(new OfflineManager.ListOfflineRegionsCallback() {

      @Override
      public void onList(OfflineRegion[] offlineRegions) {
        for (OfflineRegion region : offlineRegions) {
          if (region.getID() == id) {
            offlineRegion = region;
            OfflineTilePyramidRegionDefinition definition =
              (OfflineTilePyramidRegionDefinition) region.getDefinition();
            setupUI(definition);
            return;
          }
        }
      }

      @Override
      public void onError(String error) {
        Timber.e(error);
      }
    });
}
 

import com.mapbox.mapboxsdk.offline.OfflineManager; //导入依赖的package包/类
public void createOfflineRegion(OfflineRegionDefinition definition,
                                final String regionName,
                                final OnOfflineRegionCreatedListener listener) {
    offlineManager.createOfflineRegion(definition,
            encodeRegionName(regionName),
            new OfflineManager.CreateOfflineRegionCallback() {
        @Override
        public void onCreate(OfflineRegion offlineRegion) {
            listener.onOfflineRegionCreated(offlineRegion, regionName);
        }

        @Override
        public void onError(String error) {
            Log.e(TAG, "Create offline region error: " + error);
        }
    });
}
 

import com.mapbox.mapboxsdk.offline.OfflineManager; //导入依赖的package包/类
private void loadOfflineRegions() {
  OfflineManager.getInstance(this).listOfflineRegions(new OfflineManager.ListOfflineRegionsCallback() {
    @Override
    public void onList(OfflineRegion[] offlineRegions) {
      if (offlineRegions != null) {
        adapter.setOfflineRegions(Arrays.asList(offlineRegions));
      }
    }

    @Override
    public void onError(String error) {
      Toast.makeText(OfflineRegionListActivity.this, "Error loading regions " + error, Toast.LENGTH_LONG).show();
    }
  });
}
 

import com.mapbox.mapboxsdk.offline.OfflineManager; //导入依赖的package包/类
private static void offlinePlaceStartDownload(final Place place) {
    final Context context = SjekkUTApplication.getContext();

    // Set up the OfflineManager
    OfflineManager offlineManager = OfflineManager.getInstance(context.getApplicationContext());

    // Create a bounding box for the offline region
    LatLngBounds latLngBounds = Utils.getLatLngBounds(place.getLocation(), MAP_OFFLINE_RADIUS);

    // Define the offline region
    OfflineTilePyramidRegionDefinition definition = new OfflineTilePyramidRegionDefinition(
            context.getString(R.string.mapbox_style),
            latLngBounds,
            MAP_OFFLINE_MINZOOM,
            MAP_OFFLINE_MAXZOOM,
            context.getResources().getDisplayMetrics().density);

    byte[] metaData = GsonSingleton.gson().toJson(new OfflineRegionMetadata(place)).getBytes(Charset.defaultCharset());

    // Create the region asynchronously
    offlineManager.createOfflineRegion(definition, metaData, new OfflineManager.CreateOfflineRegionCallback() {
        @Override
        public void onCreate(OfflineRegion offlineRegion) {
            sOfflineRegionExecutor.schedule(new OfflineRegionTask(place, offlineRegion), OFFLINE_REGIONTASK_DELAY, TimeUnit.SECONDS);
        }

        @Override
        public void onError(String error) {
            Timber.e("Error: %s", error);
        }
    });
}
 

import com.mapbox.mapboxsdk.offline.OfflineManager; //导入依赖的package包/类
@Override
public void onResume() {
    super.onResume();
    Analytics.log(getActivity(), R.string.analytics_app_show_profilefragment);
    OfflineManager.getInstance(getActivity()).listOfflineRegions(this);
    mUserStats = realm.where(UserStats.class).equalTo("id", PreferenceUtils.getUserId(getContext())).findAll();
    mPlaces = realm.where(Place.class).findAll();
    setUserStats(mUserStats.isEmpty() ? null : mUserStats.first());
    updatePlacesInAdapter(mPlaces);
    mUserStats.addChangeListener(mUserStatsListener);
    mPlaces.addChangeListener(mPlaceListener);

    fetchUserStats();
    fetchVisitedPlaces();
}
 

import com.mapbox.mapboxsdk.offline.OfflineManager; //导入依赖的package包/类
public void listOfflineRegions(final OnOfflineRegionsListedListener listener) {
    offlineManager.listOfflineRegions(new OfflineManager.ListOfflineRegionsCallback() {
        @Override
        public void onList(OfflineRegion[] offlineRegions) {
            listener.onOfflineRegionsListed(Arrays.asList(offlineRegions));
        }

        @Override
        public void onError(String error) {
            Log.e(TAG, "List offline regions error: " + error);
        }
    });
}
 

import com.mapbox.mapboxsdk.offline.OfflineManager; //导入依赖的package包/类
private void downloadRegion(final String regionName) {
    // Define offline region parameters, including bounds,
    // min/max zoom, and metadata

    //Create a record to track usage of Download Map Region
    Answers.getInstance().logCustom(new CustomEvent("Offline Map download click"));

    // Start the progressBar
    startProgress();

    // Create offline definition using the current
    // style and boundaries of visible map area
    String styleUrl = mapboxMap.getStyleUrl();
    LatLngBounds bounds = mapboxMap.getProjection().getVisibleRegion().latLngBounds;
    double minZoom = mapboxMap.getCameraPosition().zoom;
    double maxZoom = mapboxMap.getMaxZoomLevel();
    float pixelRatio = this.getResources().getDisplayMetrics().density;
    OfflineTilePyramidRegionDefinition definition = new OfflineTilePyramidRegionDefinition(
            styleUrl, bounds, minZoom, maxZoom, pixelRatio);

    // Build a JSONObject using the user-defined offline region title,
    // convert it into string, and use it to create a metadata variable.
    // The metadata variable will later be passed to createOfflineRegion()
    byte[] metadata;
    try {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put(JSON_FIELD_REGION_NAME, regionName);
        String json = jsonObject.toString();
        metadata = json.getBytes(JSON_CHARSET);
    } catch (Exception exception) {
        Crashlytics.log("Failed to encode metadata.");
        Crashlytics.logException(exception);
        metadata = null;
    }

    // Create the offline region and launch the download
    offlineManager.createOfflineRegion(definition, metadata, new OfflineManager.CreateOfflineRegionCallback() {
        @Override
        public void onCreate(OfflineRegion offlineRegion) {
            Crashlytics.log("Offline region created: " + regionName);
            OfflineManagerActivity.this.offlineRegion = offlineRegion;
            launchDownload();
        }

        @Override
        public void onError(String error) {
            Crashlytics.logException(new Exception("Error: " + error));
        }
    });
}
 

import com.mapbox.mapboxsdk.offline.OfflineManager; //导入依赖的package包/类
@Provides
public OfflineManager provideOfflineManager(Application application) {
    return OfflineManager.getInstance(application);
}
 

import com.mapbox.mapboxsdk.offline.OfflineManager; //导入依赖的package包/类
@Provides
public OfflineRegionManager provideOfflineRegionManager(OfflineManager offlineManager) {
    return new OfflineRegionManager(offlineManager);
}
 

import com.mapbox.mapboxsdk.offline.OfflineManager; //导入依赖的package包/类
@Inject
public OfflineRegionManager(OfflineManager offlineManager) {
    this.offlineManager = offlineManager;
}
 

import com.mapbox.mapboxsdk.offline.OfflineManager; //导入依赖的package包/类
private void downloadRegion(final String regionName) {
  // Define offline region parameters, including bounds,
  // min/max zoom, and metadata

  // Start the progressBar
  startProgress();

  // Create offline definition using the current
  // style and boundaries of visible map area
  String styleUrl = map.getStyleUrl();
  LatLngBounds bounds = map.getProjection().getVisibleRegion().latLngBounds;
  double minZoom = map.getCameraPosition().zoom;
  double maxZoom = map.getMaxZoomLevel();
  float pixelRatio = this.getResources().getDisplayMetrics().density;
  OfflineTilePyramidRegionDefinition definition = new OfflineTilePyramidRegionDefinition(
    styleUrl, bounds, minZoom, maxZoom, pixelRatio);

  // Build a JSONObject using the user-defined offline region title,
  // convert it into string, and use it to create a metadata variable.
  // The metadata varaible will later be passed to createOfflineRegion()
  byte[] metadata;
  try {
    JSONObject jsonObject = new JSONObject();
    jsonObject.put(JSON_FIELD_REGION_NAME, regionName);
    String json = jsonObject.toString();
    metadata = json.getBytes(JSON_CHARSET);
  } catch (Exception exception) {
    Log.e(TAG, "Failed to encode metadata: " + exception.getMessage());
    metadata = null;
  }

  // Create the offline region and launch the download
  offlineManager.createOfflineRegion(definition, metadata, new OfflineManager.CreateOfflineRegionCallback() {
    @Override
    public void onCreate(OfflineRegion offlineRegion) {
      Log.d(TAG, "Offline region created: " + regionName);
      offlineRegionDownloaded = offlineRegion;
      launchDownload();
    }

    @Override
    public void onError(String error) {
      Log.e(TAG, "Error: " + error);
    }
  });
}
 

import com.mapbox.mapboxsdk.offline.OfflineManager; //导入依赖的package包/类
private void downloadRegion(final String regionName) {
  // Define offline region parameters, including bounds,
  // min/max zoom, and metadata

  // Start the progressBar
  startProgress();

  // Create offline definition using the current
  // style and boundaries of visible map area
  String styleUrl = map.getStyleUrl();
  LatLngBounds bounds = map.getProjection().getVisibleRegion().latLngBounds;
  double minZoom = map.getCameraPosition().zoom;
  double maxZoom = map.getMaxZoomLevel();
  float pixelRatio = this.getResources().getDisplayMetrics().density;
  OfflineTilePyramidRegionDefinition definition = new OfflineTilePyramidRegionDefinition(
    styleUrl, bounds, minZoom, maxZoom, pixelRatio);

  // Build a JSONObject using the user-defined offline region title,
  // convert it into string, and use it to create a metadata variable.
  // The metadata variable will later be passed to createOfflineRegion()
  byte[] metadata;
  try {
    JSONObject jsonObject = new JSONObject();
    jsonObject.put(JSON_FIELD_REGION_NAME, regionName);
    String json = jsonObject.toString();
    metadata = json.getBytes(JSON_CHARSET);
  } catch (Exception exception) {
    Log.e(TAG, "Failed to encode metadata: " + exception.getMessage());
    metadata = null;
  }

  // Create the offline region and launch the download
  offlineManager.createOfflineRegion(definition, metadata, new OfflineManager.CreateOfflineRegionCallback() {
    @Override
    public void onCreate(OfflineRegion offlineRegion) {
      Log.d(TAG, "Offline region created: " + regionName);
      OfflineManagerActivity.this.offlineRegion = offlineRegion;
      launchDownload();
    }

    @Override
    public void onError(String error) {
      Log.e(TAG, "Error: " + error);
    }
  });
}