Java OfflineRegion类代码示例

import com.mapbox.mapboxsdk.offline.OfflineRegion; //导入依赖的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.OfflineRegion; //导入依赖的package包/类
private void cancelDownload(final OfflineDownload offlineDownload) {
  int serviceId = offlineDownload.getServiceId();
  OfflineRegion offlineRegion = regionLongSparseArray.get(serviceId);
  offlineRegion.setDownloadState(OfflineRegion.STATE_INACTIVE);
  offlineRegion.setObserver(null);
  offlineRegion.delete(new OfflineRegion.OfflineRegionDeleteCallback() {
    @Override
    public void onDelete() {
    }

    @Override
    public void onError(String error) {
      OfflineDownloadStateReceiver.dispatchErrorBroadcast(getApplicationContext(), offlineDownload, error);
    }
  });
  OfflineDownloadStateReceiver.dispatchCancelBroadcast(getApplicationContext(), offlineDownload);
  notificationManager.cancel(serviceId);
  stopSelf(serviceId);
}
 

import com.mapbox.mapboxsdk.offline.OfflineRegion; //导入依赖的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.OfflineRegion; //导入依赖的package包/类
private static void startDownload(List<Place> places, Map<OfflineRegion, OfflineRegionStatus> regionStatusMap, @SuppressWarnings("UnusedParameters") int numberOfErrors) {
    for (Place place : places) {
        if (place != null && place.hasLocation()) {
            Map.Entry<OfflineRegion, OfflineRegionStatus> regionStatus = findRegionsStatusEntry(place.getId(), regionStatusMap);
            if (regionStatus == null) {
                offlinePlaceStartDownload(place);
                Timber.i("%s map download started", place.getName());
            } else if (regionStatus.getValue() != null && !regionStatus.getValue().isComplete() && regionStatus.getValue().getDownloadState() == OfflineRegion.STATE_INACTIVE) {
                offlinePlaceResumeDownload(place, regionStatus.getKey());
                Timber.i("%s map download resumed", place.getName());
            } else {
                Timber.i("%s map already offlined", place.getName());
            }
        }
    }
}
 

import com.mapbox.mapboxsdk.offline.OfflineRegion; //导入依赖的package包/类
public void setOfflineRegions(OfflineRegion[] offlineRegions) {
    mRegionAndStatus.clear();
    for (final OfflineRegion region : offlineRegions) {
        mRegionAndStatus.add(Pair.<OfflineRegion, OfflineRegionStatus>create(region, null));
        region.getStatus(new OfflineRegion.OfflineRegionStatusCallback() {
            @Override
            public void onStatus(OfflineRegionStatus status) {
                updateStatus(region, status);
            }

            @Override
            public void onError(String error) {
            }
        });
    }
    notifyDataSetChanged();
}
 

import com.mapbox.mapboxsdk.offline.OfflineRegion; //导入依赖的package包/类
private String getRegionName(OfflineRegion offlineRegion) {
    // Get the region name from the offline region metadata
    String regionName;

    try {
        byte[] metadata = offlineRegion.getMetadata();
        String json = new String(metadata, JSON_CHARSET);
        JSONObject jsonObject = new JSONObject(json);
        regionName = jsonObject.getString(JSON_FIELD_REGION_NAME);
    } catch (Exception exception) {
        Crashlytics.log("Failed to decode metadata.");
        Crashlytics.logException(exception);
        regionName = String.format(getString(R.string.region_name), offlineRegion.getID());
    }
    return regionName;
}
 

import com.mapbox.mapboxsdk.offline.OfflineRegion; //导入依赖的package包/类
private void startDownloadIfNeeded(Intent intent, final List<OfflineRegion> presentOfflineRegions) {
    if (intent == null) {
        return;
    }
    final int size = intent.getIntExtra(SIZE_PARAM, -1);
    if (size != -1) {
        int c = 0;
        // There is some regions to download
        for (int i = 0; i < size; i++) {
            ArrayList<String> areasString = intent.getStringArrayListExtra(LIST_PARAM + i);
            LatLngBounds bounds = convertToLatLngBounds(areasString);
            OfflineRegion presentOfflineRegion = containsInOfflineRegion(presentOfflineRegions, bounds);
            if (presentOfflineRegion == null) {
                // The region has never been downloaded
                String regionName = intent.getStringExtra(REGION_NAME_PARAM);
                regionName = regionName == null ? "Region " + (presentOfflineRegions.size() + c)
                        : regionName;
                c++;
                downloadOfflineRegion(bounds, regionName);
            } else {
                //The region is already downloaded, we check if it was completed
                checkIfRegionDownloadIsCompleted(presentOfflineRegion);
            }
        }
    }
}
 

import com.mapbox.mapboxsdk.offline.OfflineRegion; //导入依赖的package包/类
private void refreshOfflineRegions() {
    offlineRegionManager.listOfflineRegions(new OfflineRegionManager.OnOfflineRegionsListedListener() {
        @Override
        public void onOfflineRegionsListed(List<OfflineRegion> offlineRegions) {
            for (final OfflineRegion region : offlineRegions) {
                region.getStatus(new OfflineRegion.OfflineRegionStatusCallback() {
                    @Override
                    public void onStatus(OfflineRegionStatus status) {
                        OfflineRegionItem regionItem = new OfflineRegionItem(region, status);
                        if (!adapter.getOfflineRegionItems().contains(regionItem)) {
                            adapter.addOfflineRegion(regionItem);
                            if (adapter.getItemCount() == 1) {
                                selectOfflineRegion(0);
                            }
                        }
                    }

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

import com.mapbox.mapboxsdk.offline.OfflineRegion; //导入依赖的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.OfflineRegion; //导入依赖的package包/类
private void launchDownload(final OfflineDownload offlineDownload, final OfflineRegion offlineRegion) {
  offlineRegion.setObserver(new OfflineRegion.OfflineRegionObserver() {
    @Override
    public void onStatusChanged(OfflineRegionStatus status) {
      if (status.isComplete()) {
        finishDownload(offlineDownload, offlineRegion);
        return;
      }
      progressDownload(offlineDownload, status);
    }

    @Override
    public void onError(OfflineRegionError error) {
      OfflineDownloadStateReceiver.dispatchErrorBroadcast(getApplicationContext(), offlineDownload,
        error.getReason(), error.getMessage());
      stopSelf(offlineDownload.getServiceId());
    }

    @Override
    public void mapboxTileCountLimitExceeded(long limit) {
      OfflineDownloadStateReceiver.dispatchErrorBroadcast(getApplicationContext(), offlineDownload,
        "Mapbox tile count limit exceeded:" + limit);
    }
  });

  // Change the region state
  offlineRegion.setDownloadState(OfflineRegion.STATE_ACTIVE);
}
 

import com.mapbox.mapboxsdk.offline.OfflineRegion; //导入依赖的package包/类
private void finishDownload(OfflineDownload offlineDownload, OfflineRegion offlineRegion) {
  if (notificationBuilder != null) {
    notificationManager.cancel(offlineDownload.getServiceId());
  }
  OfflineDownloadStateReceiver.dispatchSuccessBroadcast(this, offlineDownload);
  offlineRegion.setDownloadState(OfflineRegion.STATE_INACTIVE);
  offlineRegion.setObserver(null);
  regionLongSparseArray.remove(offlineDownload.getServiceId());
  stopSelf(offlineDownload.getServiceId());
}
 

import com.mapbox.mapboxsdk.offline.OfflineRegion; //导入依赖的package包/类
/**
 * Get the OfflineDownload for an offline region, returns null if no download is active for region.
 *
 * @param offlineRegion the offline region to get related offline download for
 * @return the active offline download, null if not downloading the region.
 */
@Nullable
public OfflineDownload getActiveDownloadForOfflineRegion(OfflineRegion offlineRegion) {
  OfflineDownload offlineDownload = null;
  if (!offlineDownloads.isEmpty()) {
    for (OfflineDownload download : offlineDownloads) {
      if (download.getRegionId() == offlineRegion.getID()) {
        offlineDownload = download;
      }
    }
  }
  return offlineDownload;
}
 

import com.mapbox.mapboxsdk.offline.OfflineRegion; //导入依赖的package包/类
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
  OfflineRegion region = adapter.getItem(position);
  Intent intent = new Intent(this, OfflineRegionDetailActivity.class);
  intent.putExtra(OfflineRegionDetailActivity.KEY_REGION_ID_BUNDLE, region.getID());
  startActivity(intent);
}
 

import com.mapbox.mapboxsdk.offline.OfflineRegion; //导入依赖的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.OfflineRegion; //导入依赖的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);
        }
    });
}