我创建了一个应该跟踪POI的小型Android应用。我在路线中导航，并在路线的开头放置了10个可跟踪的POI，并在整个路线上放置了许多其他可跟踪的POI。当我在可跟踪的POI上添加注释时，可以看到它们已被创建。我想用SKPOITrackerManager跟踪它们。但是没有跟踪这些POI。
我实施了SKPOITrackerListener，onUpdatePOIsinRadius()被称为前两次没有添加任何POI。它第三次被调用（我开始应用后约2分钟）它增加了很多POI。但onReceivedPOIs()找不到POI。它只被调用一次。并且List<SKDetectedPOI>只有一个大小为1，检测到的POI的ID等于-1。
这是我的完整代码，包含两个Activites。
MainActivity：
package com.example.michi.mapapplication;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.os.Environment;
import android.os.StatFs;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.Toast;
import com.skobbler.ngx.SKDeveloperKeyException;
import com.skobbler.ngx.SKMaps;
import com.skobbler.ngx.SKMapsInitSettings;
import com.skobbler.ngx.SKPrepareMapTextureListener;
import com.skobbler.ngx.SKPrepareMapTextureThread;
import com.skobbler.ngx.map.SKMapViewStyle;
import com.skobbler.ngx.navigation.SKAdvisorSettings;
import com.skobbler.ngx.util.SKLogging;
import com.skobbler.ngx.versioning.SKMapUpdateListener;
import com.skobbler.ngx.versioning.SKVersioningManager;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class MainActivity extends AppCompatActivity implements SKPrepareMapTextureListener{
private final static String TAG = "MainActivity";
private String mapResourcesDirPath = "";
public static final long KILO = 1024;
public static final long MEGA = KILO * KILO;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
String applicationPath = chooseStoragePath(this);
mapResourcesDirPath = applicationPath + "/" + "SKMaps/";
new SKPrepareMapTextureThread(this, mapResourcesDirPath, "SKMaps.zip", this).start();
if (initializeLibrary(this)) {
finish();
startActivity(new Intent(this, MapActivity.class));
}
}
private boolean initializeLibrary(final Activity context) {
SKLogging.enableLogs(true);
SKMapsInitSettings initMapSettings = new SKMapsInitSettings();
initMapSettings.setMapResourcesPaths(mapResourcesDirPath,
new SKMapViewStyle(mapResourcesDirPath + "daystyle/", "daystyle.json"));
final SKAdvisorSettings advisorSettings = initMapSettings.getAdvisorSettings();
advisorSettings.setAdvisorConfigPath(mapResourcesDirPath +"/Advisor");
advisorSettings.setResourcePath(mapResourcesDirPath +"/Advisor/Languages");
advisorSettings.setLanguage(SKAdvisorSettings.SKAdvisorLanguage.LANGUAGE_DE);
advisorSettings.setAdvisorVoice("en");
initMapSettings.setAdvisorSettings(advisorSettings);
try {
SKMaps.getInstance().initializeSKMaps(context, initMapSettings);
return true;
}catch (SKDeveloperKeyException exception){
exception.printStackTrace();
return false;
}
}
public static String chooseStoragePath(Context context) {
if (getAvailableMemorySize(Environment.getDataDirectory().getPath()) >= 50 * MEGA) {
if (context != null && context.getFilesDir() != null) {
return context.getFilesDir().getPath();
}
} else {
if ((context != null) && (context.getExternalFilesDir(null) != null)) {
if (getAvailableMemorySize(context.getExternalFilesDir(null).toString()) >= 50 * MEGA) {
return context.getExternalFilesDir(null).toString();
}
}
}
SKLogging.writeLog(TAG, "There is not enough memory on any storage, but return internal memory",
SKLogging.LOG_DEBUG);
if (context != null && context.getFilesDir() != null) {
return context.getFilesDir().getPath();
} else {
if ((context != null) && (context.getExternalFilesDir(null) != null)) {
return context.getExternalFilesDir(null).toString();
} else {
return null;
}
}
}
public static long getAvailableMemorySize(String path) {
StatFs statFs = null;
try {
statFs = new StatFs(path);
} catch (IllegalArgumentException ex) {
SKLogging.writeLog("SplashActivity", "Exception when creating StatF ; message = " + ex,
SKLogging.LOG_DEBUG);
}
if (statFs != null) {
Method getAvailableBytesMethod = null;
try {
getAvailableBytesMethod = statFs.getClass().getMethod("getAvailableBytes");
} catch (NoSuchMethodException e) {
SKLogging.writeLog(TAG, "Exception at getAvailableMemorySize method = " + e.getMessage(),
SKLogging.LOG_DEBUG);
}
if (getAvailableBytesMethod != null) {
try {
SKLogging.writeLog(TAG, "Using new API for getAvailableMemorySize method !!!", SKLogging.LOG_DEBUG);
return (Long) getAvailableBytesMethod.invoke(statFs);
} catch (IllegalAccessException e) {
return (long) statFs.getAvailableBlocks() * (long) statFs.getBlockSize();
} catch (InvocationTargetException e) {
return (long) statFs.getAvailableBlocks() * (long) statFs.getBlockSize();
}
} else {
return (long) statFs.getAvailableBlocks() * (long) statFs.getBlockSize();
}
} else {
return 0;
}
}
@Override
public void onMapTexturesPrepared(boolean b) {
initializeLibrary(this);
}
}
MapActivity：
package com.example.michi.mapapplication;
import android.graphics.Color;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.Toast;
import com.skobbler.ngx.SKCoordinate;
import com.skobbler.ngx.map.SKAnimationSettings;
import com.skobbler.ngx.map.SKAnnotation;
import com.skobbler.ngx.map.SKCalloutView;
import com.skobbler.ngx.map.SKCoordinateRegion;
import com.skobbler.ngx.map.SKMapCustomPOI;
import com.skobbler.ngx.map.SKMapPOI;
import com.skobbler.ngx.map.SKMapSettings;
import com.skobbler.ngx.map.SKMapSurfaceListener;
import com.skobbler.ngx.map.SKMapSurfaceView;
import com.skobbler.ngx.map.SKMapViewHolder;
import com.skobbler.ngx.map.SKPOICluster;
import com.skobbler.ngx.map.SKScreenPoint;
import com.skobbler.ngx.navigation.SKNavigationListener;
import com.skobbler.ngx.navigation.SKNavigationManager;
import com.skobbler.ngx.navigation.SKNavigationSettings;
import com.skobbler.ngx.navigation.SKNavigationState;
import com.skobbler.ngx.poitracker.SKDetectedPOI;
import com.skobbler.ngx.poitracker.SKPOITrackerListener;
import com.skobbler.ngx.poitracker.SKPOITrackerManager;
import com.skobbler.ngx.poitracker.SKTrackablePOI;
import com.skobbler.ngx.poitracker.SKTrackablePOIRule;
import com.skobbler.ngx.poitracker.SKTrackablePOIType;
import com.skobbler.ngx.routing.SKRouteInfo;
import com.skobbler.ngx.routing.SKRouteJsonAnswer;
import com.skobbler.ngx.routing.SKRouteListener;
import com.skobbler.ngx.routing.SKRouteManager;
import com.skobbler.ngx.routing.SKRouteSettings;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import butterknife.Bind;
import butterknife.ButterKnife;
import static com.skobbler.ngx.map.SKMapSettings.SKMapDisplayMode.MODE_2D;
import static com.skobbler.ngx.map.SKMapSettings.SKMapDisplayMode.MODE_3D;
public class MapActivity extends AppCompatActivity implements SKMapSurfaceListener, SKRouteListener, SKNavigationListener, SKPOITrackerListener {
public static final double SOURCE_LONGITUDE = 11.5;
public static final double SOURCE_LATITUDE = 48.12;
public static final double DEST_LONGITUDE = 11.5;
public static final double DEST_LATITUDE = 51.12;
private SKNavigationManager navigationManager;
private HashMap<Integer, SKTrackablePOI> trackablePOIs;
private SKPOITrackerManager poiTrackerManager;
protected SKMapSurfaceView mapView;
@Bind(R.id.view_group_map)
protected SKMapViewHolder mapHolder;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_map);
ButterKnife.bind(this);
mapHolder.setMapSurfaceListener(this);
}
@Override
protected void onPause() {
super.onPause();
mapHolder.onPause();
}
@Override
protected void onResume() {
super.onResume();
mapHolder.onResume();
}
@Override
public void onActionPan() {}
@Override
public void onActionZoom() { }
@Override
public void onSurfaceCreated(SKMapViewHolder skMapViewHolder) {
mapView = mapHolder.getMapSurfaceView();
mapView.centerMapOnPosition(new SKCoordinate(11.5, 48.12));
launchRouteCalculation();
}
@Override
public void onMapRegionChanged(SKCoordinateRegion skCoordinateRegion) {
mapView.getMapSettings().setFollowerMode(SKMapSettings.SKMapFollowerMode.NONE);
final SKCalloutView mapPopup = mapHolder.getCalloutView();
mapPopup.setTitle("Fortsetzen").setVisibility(View.VISIBLE);
mapPopup.setViewColor(Color.argb(255, 200, 200, 255));
mapPopup.setOnLeftImageClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Toast.makeText(MapActivity.this, "Left image clicked", Toast.LENGTH_SHORT).show();
mapView.getMapSettings().setFollowerMode(SKMapSettings.SKMapFollowerMode.NAVIGATION);
mapPopup.setVisibility(View.GONE);
}
});
mapPopup.showAtLocation(new SKCoordinate(23.56, 46.77), true);
}
@Override
public void onMapRegionChangeStarted(SKCoordinateRegion skCoordinateRegion) {}
@Override
public void onMapRegionChangeEnded(SKCoordinateRegion skCoordinateRegion) {}
@Override
public void onDoubleTap(SKScreenPoint skScreenPoint) {}
@Override
public void onSingleTap(SKScreenPoint skScreenPoint) {}
@Override
public void onRotateMap() {}
@Override
public void onLongPress(SKScreenPoint skScreenPoint) {}
@Override
public void onInternetConnectionNeeded() {}
@Override
public void onMapActionDown(SKScreenPoint skScreenPoint) {}
@Override
public void onMapActionUp(SKScreenPoint skScreenPoint) {}
@Override
public void onPOIClusterSelected(SKPOICluster skpoiCluster) {}
@Override
public void onMapPOISelected(SKMapPOI skMapPOI) {}
@Override
public void onAnnotationSelected(SKAnnotation skAnnotation) {
}
@Override
public void onCustomPOISelected(SKMapCustomPOI skMapCustomPOI) {}
@Override
public void onCompassSelected() {
}
@Override
public void onCurrentPositionSelected() {}
@Override
public void onObjectSelected(int i) {}
@Override
public void onInternationalisationCalled(int i) {}
@Override
public void onDebugInfo(double v, float v1, double v2) { }
@Override
public void onBoundingBoxImageRendered(int i) {}
@Override
public void onGLInitializationError(String s) {}
private void launchRouteCalculation() {
SKRouteSettings route = new SKRouteSettings();
route.setStartCoordinate(new SKCoordinate(SOURCE_LONGITUDE, SOURCE_LATITUDE));
route.setDestinationCoordinate(new SKCoordinate(DEST_LONGITUDE, DEST_LATITUDE));
route.setNoOfRoutes(1);
route.setRouteMode(SKRouteSettings.SKRouteMode.CAR_FASTEST);
route.setRouteExposed(true);
SKRouteManager.getInstance().setRouteListener(this);
SKRouteManager.getInstance().calculateRoute(route);
}
@Override
public void onRouteCalculationCompleted(SKRouteInfo skRouteInfo) {}
@Override
public void onRouteCalculationFailed(SKRoutingErrorCode skRoutingErrorCode) {}
@Override
public void onAllRoutesCompleted() {
SKNavigationSettings navigationSettings = new SKNavigationSettings();
navigationSettings.setNavigationType(SKNavigationSettings.SKNavigationType.SIMULATION);
navigationManager = SKNavigationManager.getInstance();
navigationManager.setMapView(mapView);
navigationManager.setNavigationListener(this);
navigationManager.startNavigation(navigationSettings);
initTrackablePOIs();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
startPOITracking();
}
private void initTrackablePOIs() {
Log.w(getClass().getName(), "initTrackablePOIs(): ");
trackablePOIs = new HashMap<Integer, SKTrackablePOI>();
initOnlySomePOIs();
int i = 0;
double longitude, latitude;
for (double d = 0; d < 1; d+= 0.01) {
longitude = SOURCE_LONGITUDE + d * (DEST_LONGITUDE - SOURCE_LONGITUDE);
latitude = SOURCE_LATITUDE + d * (DEST_LATITUDE - SOURCE_LATITUDE);
trackablePOIs.put(i, new SKTrackablePOI(i, 1, longitude, latitude, -1, "STREET_NAME " + i));
SKAnnotation skAnnotation = new SKAnnotation(64000 + i);
skAnnotation.setAnnotationType(SKAnnotation.SK_ANNOTATION_TYPE_MARKER);
skAnnotation.setLocation(new SKCoordinate(longitude, latitude));
mapView.addAnnotation(skAnnotation, SKAnimationSettings.ANIMATION_PIN_DROP);
i++;
}
}
private void initOnlySomePOIs() {
double longitude, latitude;
longitude = SOURCE_LONGITUDE + 0.001;
latitude = SOURCE_LATITUDE + 0.001;
trackablePOIs.put(101, new SKTrackablePOI(101, 1, longitude, latitude, -1, "STREET_NAME 101"));
SKAnnotation skAnnotation1 = new SKAnnotation(101);
skAnnotation1.setAnnotationType(SKAnnotation.SK_ANNOTATION_TYPE_MARKER);
skAnnotation1.setLocation(new SKCoordinate(longitude, latitude));
mapView.addAnnotation(skAnnotation1, SKAnimationSettings.ANIMATION_PIN_DROP);
longitude = SOURCE_LONGITUDE + 0.001;
latitude = SOURCE_LATITUDE - 0.001;
trackablePOIs.put(102, new SKTrackablePOI(102, 1, longitude, latitude, -1, "STREET_NAME 102"));
SKAnnotation skAnnotation2 = new SKAnnotation(102);
skAnnotation2.setAnnotationType(SKAnnotation.SK_ANNOTATION_TYPE_MARKER);
skAnnotation2.setLocation(new SKCoordinate(longitude, latitude));
mapView.addAnnotation(skAnnotation2, SKAnimationSettings.ANIMATION_PIN_DROP);
longitude = SOURCE_LONGITUDE - 0.001;
latitude = SOURCE_LATITUDE + 0.001;
trackablePOIs.put(103, new SKTrackablePOI(103, 1, longitude, latitude, -1, "STREET_NAME 103"));
SKAnnotation skAnnotation3 = new SKAnnotation(103);
skAnnotation3.setAnnotationType(SKAnnotation.SK_ANNOTATION_TYPE_MARKER);
skAnnotation3.setLocation(new SKCoordinate(longitude, latitude));
mapView.addAnnotation(skAnnotation3, SKAnimationSettings.ANIMATION_PIN_DROP);
longitude = SOURCE_LONGITUDE - 0.001;
latitude = SOURCE_LATITUDE - 0.001;
trackablePOIs.put(104, new SKTrackablePOI(104, 1, longitude, latitude, -1, "STREET_NAME 104"));
SKAnnotation skAnnotation4 = new SKAnnotation(104);
skAnnotation4.setAnnotationType(SKAnnotation.SK_ANNOTATION_TYPE_MARKER);
skAnnotation4.setLocation(new SKCoordinate(longitude, latitude));
mapView.addAnnotation(skAnnotation4, SKAnimationSettings.ANIMATION_PIN_DROP);
longitude = SOURCE_LONGITUDE + 0.002;
latitude = SOURCE_LATITUDE + 0.002;
trackablePOIs.put(105, new SKTrackablePOI(105, 105, longitude, latitude, -1, "STREET_NAME 105"));
SKAnnotation skAnnotation5 = new SKAnnotation(105);
skAnnotation5.setAnnotationType(SKAnnotation.SK_ANNOTATION_TYPE_MARKER);
skAnnotation5.setLocation(new SKCoordinate(longitude, latitude));
mapView.addAnnotation(skAnnotation5, SKAnimationSettings.ANIMATION_PIN_DROP);
longitude = SOURCE_LONGITUDE + 0.002;
latitude = SOURCE_LATITUDE - 0.002;
trackablePOIs.put(106, new SKTrackablePOI(106, 1, longitude, latitude, -1, "STREET_NAME 106"));
SKAnnotation skAnnotation6 = new SKAnnotation(106);
skAnnotation6.setAnnotationType(SKAnnotation.SK_ANNOTATION_TYPE_MARKER);
skAnnotation6.setLocation(new SKCoordinate(longitude, latitude));
mapView.addAnnotation(skAnnotation6, SKAnimationSettings.ANIMATION_PIN_DROP);
longitude = SOURCE_LONGITUDE - 0.002;
latitude = SOURCE_LATITUDE + 0.002;
trackablePOIs.put(107, new SKTrackablePOI(107, 1, longitude, latitude, -1, "STREET_NAME 107"));
SKAnnotation skAnnotation7 = new SKAnnotation(107);
skAnnotation7.setAnnotationType(SKAnnotation.SK_ANNOTATION_TYPE_MARKER);
skAnnotation7.setLocation(new SKCoordinate(longitude, latitude));
mapView.addAnnotation(skAnnotation7, SKAnimationSettings.ANIMATION_PIN_DROP);
longitude = SOURCE_LONGITUDE - 0.001;
latitude = SOURCE_LATITUDE - 0.001;
trackablePOIs.put(108, new SKTrackablePOI(108, 1, longitude, latitude, -1, "STREET_NAME 108"));
SKAnnotation skAnnotation8 = new SKAnnotation(108);
skAnnotation8.setAnnotationType(SKAnnotation.SK_ANNOTATION_TYPE_MARKER);
skAnnotation8.setLocation(new SKCoordinate(longitude, latitude));
mapView.addAnnotation(skAnnotation8, SKAnimationSettings.ANIMATION_PIN_DROP);
longitude = 9.767972;
latitude = 52.378958;
trackablePOIs.put(109, new SKTrackablePOI(109, 1, longitude, latitude, -1, "STREET_NAME 109"));
SKAnnotation skAnnotation9 = new SKAnnotation(109);
skAnnotation9.setAnnotationType(SKAnnotation.SK_ANNOTATION_TYPE_MARKER);
skAnnotation9.setLocation(new SKCoordinate(longitude, latitude));
mapView.addAnnotation(skAnnotation9, SKAnimationSettings.ANIMATION_PIN_DROP);
}
private void startPOITracking() {
SKTrackablePOIRule rule = new SKTrackablePOIRule();
rule.setAerialDistance(5000); // this would be our main constraint, stating that all the POIs with 5000m, aerial distance should be detected
rule.setNumberOfTurns(100); // this has to be increased – otherwise some points will be disconsidered
rule.setRouteDistance(10000);//this has to be increased as the real road route will be longer than the aerial distance
rule.setMinSpeedIgnoreDistanceAfterTurn(20); //decrease this to evaluate all candidates
rule.setMaxDistanceAfterTurn(10000); //increase this to make sure we don't exclude any candidates
rule.setEliminateIfUTurn(false); // setting this to true (default) excludes points that require us to make an U-turn to get to them
rule.setPlayAudioWarning(false);
poiTrackerManager = new SKPOITrackerManager(this);
poiTrackerManager.startPOITrackerWithRadius(1500, 0.5);
poiTrackerManager.setRuleForPOIType(SKTrackablePOIType.SPEEDCAM, rule);
}
@Override
public void onServerLikeRouteCalculationCompleted(SKRouteJsonAnswer skRouteJsonAnswer) {}
@Override
public void onOnlineRouteComputationHanging(int i) {}
@Override
public void onDestinationReached() {}
@Override
public void onSignalNewAdviceWithInstruction(String s) {}
@Override
public void onSignalNewAdviceWithAudioFiles(String[] strings, boolean b) {}
@Override
public void onSpeedExceededWithAudioFiles(String[] strings, boolean b) {}
@Override
public void onSpeedExceededWithInstruction(String s, boolean b) {}
@Override
public void onUpdateNavigationState(SKNavigationState skNavigationState) { Log.v(getClass().getName(), "onUpdateNavigationState: " + skNavigationState.toString());}
@Override
public void onReRoutingStarted() {}
@Override
public void onFreeDriveUpdated(String s, String s1, SKNavigationState.SKStreetType skStreetType, double v, double v1) {}
@Override
public void onViaPointReached(int i) {}
@Override
public void onVisualAdviceChanged(boolean b, boolean b1, SKNavigationState skNavigationState) {}
@Override
public void onTunnelEvent(boolean b) {}
@Override
public void onFcdTripStarted(String s) {}
@Override
public void onUpdatePOIsInRadius(double latitude, double longitude, int radius) {
Log.i(getClass().getName(), "onUpdatePOIsInRadius(): ");
// set the POIs to be tracked by the POI tracker
for (SKTrackablePOI skTrackablePOI : trackablePOIs.values()) {
Log.i(getClass().getName(), "onUpdatePOIsInRadius() skTrackablePOI: " + skTrackablePOI);
}
poiTrackerManager.setTrackedPOIs(SKTrackablePOIType.SPEEDCAM, new ArrayList<SKTrackablePOI>(trackablePOIs.values()));
}
@Override
public void onReceivedPOIs(SKTrackablePOIType type, List<SKDetectedPOI> detectedPois) {
Log.i(getClass().getName(), "onReceivedPOIs() detectedPois.size(): " + detectedPois.size());
if (detectedPois.size() == 1 && detectedPois.get(0).getPoiID() == -1) {
return;
}
for (SKDetectedPOI skDetectedPOI : detectedPois) {
Log.i(getClass().getName(), "onReceivedPOIs() skDetectedPOI: " + skDetectedPOI);
SKAnnotation skAnnotation = new SKAnnotation(skDetectedPOI.getPoiID());
skAnnotation.setAnnotationType(SKAnnotation.SK_ANNOTATION_TYPE_GREEN);
skAnnotation.setLocation(trackablePOIs.get(skDetectedPOI.getPoiID()).getCoordinate());
mapView.addAnnotation(skAnnotation, SKAnimationSettings.ANIMATION_PIN_DROP);
}
}
}
我不知道为什么跟踪器不工作。 ：（
答案 0 :(得分：0)
规则没问题。 您需要将逻辑修改为类似于演示项目的内容：
（以下代码将添加到演示项目中，MapActivity.java，(U|Ü|Ü)mit回调，onAllRoutesCompleted分支）
currentMapOption == MapOption.POI_TRACKING在onUpdatePOIsInRadius中，您必须为跟踪器提供“刷新的”POI列表。一旦达到refreshMargin条件，跟踪器将触发此回调。
poiTrackingManager.startPOITrackerWithRadius(10000, 0.5);
// set warning rules for trackable POIs
// SKTrackablePOIType myType =SKTrackablePOIType.forInt(1000);
SKTrackablePOIRule rule = new SKTrackablePOIRule();
rule.setAerialDistance(5000); // this would be our main constraint, stating that all the POIs with 5000m, aerial distance should be detected
rule.setNumberOfTurns(100); // this has to be increased – otherwise some points will be disconsidered
rule.setRouteDistance(10000);//this has to be increased as the real road route will be longer than the aerial distance
rule.setMinSpeedIgnoreDistanceAfterTurn(20); //decrease this to evaluate all candidates
rule.setMaxDistanceAfterTurn(10000); //increase this to make sure we don't exclude any candidates
rule.setEliminateIfUTurn(false); // setting this to true (default) excludes points that require us to make an U-turn to get to them
rule.setPlayAudioWarning(false);
poiTrackingManager.setRuleForPOIType(SKTrackablePOIType.SPEEDCAM, rule);
launchNavigation();
在onReceivedPOIs中，您将获得有关检测到的POI的信息：
@Override
public void onUpdatePOIsInRadius(double latitude, double longitude, int radius) {
// set the POIs to be tracked by the POI tracker
// SKTrackablePOIType myType =SKTrackablePOIType.forInt(1000);
poiTrackingManager.setTrackedPOIs(SKTrackablePOIType.SPEEDCAM,
new ArrayList<SKTrackablePOI>(trackablePOIs.values()));
}
我使用上面的代码编辑了vanilla演示项目（默认定义了要跟踪的点数），我收到很多通知。
根据您跟踪的POI的“密度”，您可能希望减少refreshMargin（并更频繁地触发POI集更新） - 即public void onReceivedPOIs(SKTrackablePOIType type, List<SKDetectedPOI> detectedPois) {
//add code here to handle the detected POIs
}
有关POI跟踪功能的更多见解，请参阅http://sdkblog.skobbler.com/detecting-tracking-pois-in-your-way/