Android基于Radar实现后台持续地理围栏监听与通知推送疑问

Hey there! Let's walk through the key next steps to get your Radar geofence notifications working reliably—even when your app is closed.

First, you need to initialize the Radar SDK correctly and enable background location tracking. This should happen early in your app's lifecycle (like in a custom Application class) to ensure tracking starts immediately and persists.

public class MyApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        
        // Initialize Radar with your publishable API key
        Radar.initialize(this, "YOUR_PUBLISHABLE_KEY");
        
        // Set a user ID to associate events with a specific user (critical for geofence triggers)
        Radar.setUserId("unique_user_identifier");
        
        // Start background tracking with an appropriate mode
        // Use EFFICIENT for balanced battery usage, or CONTINUOUS for more frequent updates
        Radar.startTracking(RadarTrackingOptions.EFFICIENT);
    }
}

Don't forget to register this Application class in your AndroidManifest.xml:

<application
    android:name=".MyApplication"
    ...>
    <!-- Your other components -->
</application>

Right now, your receiver only logs events—you need to add code to send actual notifications to the user. Here's how to update your onEventsReceived method:

@Override
public void onEventsReceived(Context context, RadarEvent[] events, RadarUser user) {
    for (RadarEvent event : events){
        if (event.getType() == RadarEvent.RadarEventType.USER_ENTERED_GEOFENCE){
            String geofenceId = event.getGeofence().getExternalId();
            Log.i(TAG, "onEventsReceived: User entered GeoFence ->" + geofenceId);
            // Send entry notification
            sendGeofenceNotification(context, "Entered Geofence", "You've entered " + geofenceId);
        } else if (event.getType() == RadarEvent.RadarEventType.USER_EXITED_GEOFENCE){
            String geofenceId = event.getGeofence().getExternalId();
            Log.i(TAG, "onEventsReceived: User exited GeoFence ->" + geofenceId);
            // Send exit notification
            sendGeofenceNotification(context, "Exited Geofence", "You've left " + geofenceId);
        } else {
            Log.i(TAG, "onEventsReceived: User did some other event");
        }
    }
}

// Helper method to build and show notifications
private void sendGeofenceNotification(Context context, String title, String message) {
    // Create a notification channel (required for Android O and above)
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        NotificationChannel channel = new NotificationChannel(
            "GEOFENCE_CHANNEL",
            "Geofence Alerts",
            NotificationManager.IMPORTANCE_DEFAULT
        );
        channel.setDescription("Notifications for geofence entry/exit events");
        
        NotificationManager notificationManager = context.getSystemService(NotificationManager.class);
        notificationManager.createNotificationChannel(channel);
    }

    // Create an intent to open your app when the notification is tapped
    Intent intent = new Intent(context, MainActivity.class);
    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
    PendingIntent pendingIntent = PendingIntent.getActivity(
        context,
        0,
        intent,
        PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE // Use FLAG_IMMUTABLE for Android 12+
    );

    // Build the notification
    NotificationCompat.Builder builder = new NotificationCompat.Builder(context, "GEOFENCE_CHANNEL")
        .setSmallIcon(R.drawable.ic_notification) // Replace with your app's notification icon
        .setContentTitle(title)
        .setContentText(message)
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)
        .setContentIntent(pendingIntent)
        .setAutoCancel(true);

    // Show the notification
    NotificationManagerCompat notificationManager = NotificationManagerCompat.from(context);
    notificationManager.notify((int) System.currentTimeMillis(), builder.build());
}

Android has strict permissions for background location tracking—make sure you have these set up correctly:

1. Add permissions to your AndroidManifest.xml:

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" /> <!-- Required for Android 10+ -->
<uses-permission android:name="android.permission.POST_NOTIFICATIONS" /> <!-- Required for Android 13+ -->

2. Request these permissions from the user at runtime. Here's an example from an Activity:

private static final int LOCATION_PERMISSION_REQUEST_CODE = 1001;

private void requestLocationPermissions() {
    if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED
            || ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_BACKGROUND_LOCATION) != PackageManager.PERMISSION_GRANTED) {
        ActivityResultContracts.RequestMultiplePermissions contract = new ActivityResultContracts.RequestMultiplePermissions();
        registerForActivityResult(contract, result -> {
            boolean fineGranted = result.getOrDefault(Manifest.permission.ACCESS_FINE_LOCATION, false);
            boolean backgroundGranted = result.getOrDefault(Manifest.permission.ACCESS_BACKGROUND_LOCATION, false);
            boolean notificationsGranted = result.getOrDefault(Manifest.permission.POST_NOTIFICATIONS, true); // Default to true for pre-Android 13

            if (fineGranted && backgroundGranted && notificationsGranted) {
                // Permissions granted—start tracking if not already started
                Radar.startTracking(RadarTrackingOptions.EFFICIENT);
            } else {
                Toast.makeText(this, "Location and notification permissions are required for geofence alerts", Toast.LENGTH_LONG).show();
            }
        }).launch(new String[]{
            Manifest.permission.ACCESS_FINE_LOCATION,
            Manifest.permission.ACCESS_BACKGROUND_LOCATION,
            Manifest.permission.POST_NOTIFICATIONS
        });
    }
}

Call this method when your app first launches (e.g., in MainActivity.onCreate()).

Android's battery optimization features can interfere with background location tracking. Improve reliability by:

• Asking users to exclude your app from battery optimization:

private void requestBatteryOptimizationExclusion(Context context) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
        if (!pm.isIgnoringBatteryOptimizations(context.getPackageName())) {
            Intent intent = new Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS);
            intent.setData(Uri.parse("package:" + context.getPackageName()));
            context.startActivity(intent);
        }
    }
}

• Testing with a physical device (emulators can have inconsistent background behavior).
• Using Radar's EFFICIENT tracking mode (balances battery usage and accuracy) unless you need real-time updates.

Double-check that your geofences are correctly created in the Radar Dashboard and that they're associated with your app's project. Also, ensure the externalId you're logging matches the IDs set in the Dashboard.

Once you've implemented these steps, test by:

1. Granting all required permissions.
2. Moving your app to the background (or closing it).
3. Simulating entry/exit of your geofence (use Radar's Dashboard location simulator or walk/drive to the geofence area with a physical device).

You should see notifications appear when the geofence events are triggered!

内容的提问来源于stack exchange，提问作者user7710654