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);
        }
    });
}
 

import com.mapbox.mapboxsdk.offline.OfflineRegion; //导入依赖的package包/类
private static Map.Entry<OfflineRegion, OfflineRegionStatus> findRegionsStatusEntry(String placeId, Map<OfflineRegion, OfflineRegionStatus> regionStatusMap) {
    for (Map.Entry<OfflineRegion, OfflineRegionStatus> entry : regionStatusMap.entrySet()) {
        if (entry.getKey() == null)
            continue;
        try {
            OfflineRegionMetadata metadata = GsonSingleton.gson().fromJson(new String(entry.getKey().getMetadata(), Charset.defaultCharset()), OfflineRegionMetadata.class);
            if (metadata.placeId != null && metadata.placeId.equals(placeId))
                return entry;
        } catch (JsonSyntaxException ignored) {
        }
    }
    return null;
}
 

import com.mapbox.mapboxsdk.offline.OfflineRegion; //导入依赖的package包/类
OfflineRegionTask(Place place, OfflineRegion offlineRegion) {
    Context context = SjekkUTApplication.getContext();
    mLatch = new CountDownLatch(1);
    mOfflineRegion = offlineRegion;
    mOfflineRegion.setDeliverInactiveMessages(true);
    mOfflineRegion.setObserver(new DownloadNotificationObserver(
            context,
            context.getString(R.string.offlinemap_content_progress, place.getName()),
            mLatch));
}
 

import com.mapbox.mapboxsdk.offline.OfflineRegion; //导入依赖的package包/类
@Override
public void onStatusChanged(OfflineRegionStatus status) {
    long currentMillis = System.currentTimeMillis();
    long delta = currentMillis - lastUpdateMillis;
    if (status.isComplete()) {
        mLatch.countDown();
        if (sOfflineRegionExecutor.getQueue().isEmpty()) {
            notificationManager.cancel(R.id.download_notification);
        }
    } else {
        switch (status.getDownloadState()) {
            case OfflineRegion.STATE_INACTIVE:
                mLatch.countDown();
                break;
            case OfflineRegion.STATE_ACTIVE:
                if (status.isRequiredResourceCountPrecise() && delta > PROGRESS_UPDATE_DELTA_MS) {
                    lastUpdateMillis = currentMillis;
                    double percentage = status.getRequiredResourceCount() >= 0
                            ? (100.0 * status.getCompletedResourceCount() / status.getRequiredResourceCount()) :
                            0.0;
                    notificationBuilder.setContentTitle(mContext.getString(R.string.offlinemap_title, getPendingAndActiveMapDownloads()));
                    notificationBuilder.setProgress(100, (int) percentage, false);
                    notificationManager.notify(R.id.download_notification, notificationBuilder.build());
                }
                break;
        }
    }
}
 

import com.mapbox.mapboxsdk.offline.OfflineRegion; //导入依赖的package包/类
@Override
public void onBindViewHolder(final ViewHolder holder, int position) {
    Context context = holder.itemView.getContext();
    Pair<OfflineRegion, OfflineRegionStatus> pair = mRegionAndStatus.get(position);
    String unknown = context.getString(R.string.offlineregion_unknown);
    String regionName = context.getString(R.string.offlineregion_name, unknown);
    String regionId = context.getString(R.string.offlineregion_regionid, unknown);
    String placeId = context.getString(R.string.offlineregion_placeid, unknown);
    String downloadState = context.getString(R.string.offlineregion_downloadState, unknown);
    String downloadComplete = context.getString(R.string.offlineregion_downloadComplete, unknown);
    String regionSize = context.getString(R.string.offlineregion_sizeMB, unknown);
    OfflineRegion region = pair.first;
    if (region != null) {
        regionId = context.getString(R.string.offlineregion_regionid, Long.toString(region.getID()));
        try {
            OfflineRegionMetadata metadata = GsonSingleton.gson().fromJson(new String(region.getMetadata(), Charset.defaultCharset()), OfflineRegionMetadata.class);
            regionName = context.getString(R.string.offlineregion_name, metadata.placeName);
            placeId = context.getString(R.string.offlineregion_placeid, metadata.placeId);
        } catch (JsonSyntaxException ignored) {
        }
    }
    OfflineRegionStatus status = pair.second;
    if (status != null) {
        downloadState = status.getDownloadState() == OfflineRegion.STATE_ACTIVE ?
                context.getString(R.string.offlineregion_downloadState, "Aktiv") :
                context.getString(R.string.offlineregion_downloadState, "Inaktiv");
        downloadComplete = status.isComplete() ?
                context.getString(R.string.offlineregion_downloadComplete, "Ja") :
                context.getString(R.string.offlineregion_downloadComplete, "Nei");
        regionSize = context.getString(R.string.offlineregion_sizeMB, String.format(Locale.getDefault(), "%.2f", status.getCompletedResourceSize() / (1024.0 * 1024.0)));
    }
    holder.mRegionName.setText(regionName);
    holder.mRegionId.setText(regionId);
    holder.mPlaceId.setText(placeId);
    holder.mDownloadState.setText(downloadState);
    holder.mDownloadComplete.setText(downloadComplete);
    holder.mRegionSize.setText(regionSize);
}
 

import com.mapbox.mapboxsdk.offline.OfflineRegion; //导入依赖的package包/类
private void updateStatus(OfflineRegion region, OfflineRegionStatus status) {
    boolean dirty = false;
    for (int i = 0; i < mRegionAndStatus.size(); ++i) {
        Pair<OfflineRegion, OfflineRegionStatus> pair = mRegionAndStatus.get(i);
        if (pair.first != null && pair.first.getID() == region.getID()) {
            mRegionAndStatus.set(i, Pair.create(region, status));
            dirty = true;
        }
    }
    if (dirty) {
        notifyDataSetChanged();
    }
}