گرفتن مکان کاربر در پس زمینه اپلیکیشن ری اکت نیتیو — از صفر تا صد

1package com.rnbglocation.location;
2
3import android.content.BroadcastReceiver;
4import android.content.Context;
5import android.content.Intent;
6import android.content.IntentFilter;
7
8import androidx.core.content.ContextCompat;
9
10import com.facebook.react.bridge.Arguments;
11import com.facebook.react.bridge.ReactApplicationContext;
12import com.facebook.react.bridge.ReactContext;
13import com.facebook.react.bridge.ReactContextBaseJavaModule;
14import com.facebook.react.bridge.ReactMethod;
15import com.facebook.react.bridge.WritableMap;
16import com.facebook.react.modules.core.DeviceEventManagerModule;
17import com.google.gson.Gson;
18
19import java.util.HashMap;
20import java.util.Map;
21
22import javax.annotation.Nonnull;
23import javax.annotation.Nullable;
24
25import static com.rnbglocation.location.LocationForegroundService.LOCATION_EVENT_DATA_NAME;
26
27public class LocationModule extends ReactContextBaseJavaModule implements LocationEventReceiver, JSEventSender {
28    private static final String MODULE_NAME = "LocationManager";
29    private static final String CONST_JS_LOCATION_EVENT_NAME = "JS_LOCATION_EVENT_NAME";
30    private static final String CONST_JS_LOCATION_LAT = "JS_LOCATION_LAT_KEY";
31    private static final String CONST_JS_LOCATION_LON = "JS_LOCATION_LON_KEY";
32    private static final String CONST_JS_LOCATION_TIME = "JS_LOCATION_TIME_KEY";
33
34    private Context mContext;
35    private Intent mForegroundServiceIntent;
36    private BroadcastReceiver mEventReceiver;
37    private Gson mGson;
38
39    LocationModule(@Nonnull ReactApplicationContext reactContext) {
40        super(reactContext);
41        mContext = reactContext;
42        mForegroundServiceIntent = new Intent(mContext, LocationForegroundService.class);
43        mGson = new Gson();
44        createEventReceiver();
45        registerEventReceiver();
46    }
47
48    @ReactMethod
49    public void startBackgroundLocation() {
50        ContextCompat.startForegroundService(mContext, mForegroundServiceIntent);
51    }
52
53    @ReactMethod
54    public void stopBackgroundLocation() {
55        mContext.stopService(mForegroundServiceIntent);
56    }
57
58    @Nullable
59    @Override
60    public Map<String, Object> getConstants() {
61        final Map<String, Object> constants = new HashMap<>();
62        constants.put(CONST_JS_LOCATION_EVENT_NAME, LocationForegroundService.JS_LOCATION_EVENT_NAME);
63        constants.put(CONST_JS_LOCATION_LAT, LocationForegroundService.JS_LOCATION_LAT_KEY);
64        constants.put(CONST_JS_LOCATION_LON, LocationForegroundService.JS_LOCATION_LON_KEY);
65        constants.put(CONST_JS_LOCATION_TIME, LocationForegroundService.JS_LOCATION_TIME_KEY);
66        return constants;
67    }
68
69    @Nonnull
70    @Override
71    public String getName() {
72        return MODULE_NAME;
73    }
74
75    @Override
76    public void createEventReceiver() {
77        mEventReceiver = new BroadcastReceiver() {
78            @Override
79            public void onReceive(Context context, Intent intent) {
80                LocationCoordinates locationCoordinates = mGson.fromJson(
81                        intent.getStringExtra(LOCATION_EVENT_DATA_NAME), LocationCoordinates.class);
82                WritableMap eventData = Arguments.createMap();
83                eventData.putDouble(
84                        LocationForegroundService.JS_LOCATION_LAT_KEY,
85                        locationCoordinates.getLatitude());
86                eventData.putDouble(
87                        LocationForegroundService.JS_LOCATION_LON_KEY,
88                        locationCoordinates.getLongitude());
89                eventData.putDouble(
90                        LocationForegroundService.JS_LOCATION_TIME_KEY,
91                        locationCoordinates.getTimestamp());
92                // if you actually want to send events to JS side, it needs to be in the "Module"
93                sendEventToJS(getReactApplicationContext(),
94                        LocationForegroundService.JS_LOCATION_EVENT_NAME, eventData);
95            }
96        };
97    }
98
99    @Override
100    public void registerEventReceiver() {
101        IntentFilter eventFilter = new IntentFilter();
102        eventFilter.addAction(LocationForegroundService.LOCATION_EVENT_NAME);
103        mContext.registerReceiver(mEventReceiver, eventFilter);
104    }
105
106    @Override
107    public void sendEventToJS(ReactContext reactContext, String eventName, @Nullable WritableMap params) {
108        reactContext
109                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
110                .emit(eventName, params);
111    }
112}

1package com.rnbglocation.location;
2
3import android.app.AlarmManager;
4import android.app.Notification;
5import android.app.NotificationChannel;
6import android.app.NotificationManager;
7import android.app.PendingIntent;
8import android.app.Service;
9import android.content.BroadcastReceiver;
10import android.content.Context;
11import android.content.Intent;
12import android.content.IntentFilter;
13import android.os.Build;
14import android.os.IBinder;
15
16import androidx.annotation.Nullable;
17import androidx.core.app.NotificationCompat;
18
19import com.google.gson.Gson;
20import com.rnbglocation.MainActivity;
21
22public class LocationForegroundService extends Service implements LocationEventReceiver {
23    public static final String CHANNEL_ID = "ForegroundServiceChannel";
24    public static final int NOTIFICATION_ID = 1;
25    public static final String LOCATION_EVENT_NAME = "com.rnbglocation.LOCATION_INFO";
26    public static final String LOCATION_EVENT_DATA_NAME = "LocationData";
27    public static final int LOCATION_UPDATE_INTERVAL = 60000;
28    public static final String JS_LOCATION_LAT_KEY = "latitude";
29    public static final String JS_LOCATION_LON_KEY = "longitude";
30    public static final String JS_LOCATION_TIME_KEY = "timestamp";
31    public static final String JS_LOCATION_EVENT_NAME = "location_received";
32
33    private AlarmManager mAlarmManager;
34    private BroadcastReceiver mEventReceiver;
35    private PendingIntent mLocationBackgroundServicePendingIntent;
36    private Gson mGson;
37
38    @Override
39    public void onCreate() {
40        super.onCreate();
41        mAlarmManager = (AlarmManager) getApplicationContext().getSystemService(Context.ALARM_SERVICE);
42        mGson = new Gson();
43        createEventReceiver();
44        registerEventReceiver();
45    }
46
47    @Override
48    public int onStartCommand(Intent intent, int flags, int startId) {
49        createNotificationChannel();
50        startForeground(NOTIFICATION_ID, createNotification());
51
52        createLocationPendingIntent();
53        mAlarmManager.setRepeating(
54            AlarmManager.RTC,
55            System.currentTimeMillis(),
56            LOCATION_UPDATE_INTERVAL,
57            mLocationBackgroundServicePendingIntent
58        );
59
60        return START_NOT_STICKY;
61    }
62
63    @Override
64    public void createEventReceiver() {
65        mEventReceiver = new BroadcastReceiver() {
66            @Override
67            public void onReceive(Context context, Intent intent) {
68                LocationCoordinates locationCoordinates = mGson.fromJson(
69                        intent.getStringExtra(LOCATION_EVENT_DATA_NAME), LocationCoordinates.class);
70                /*
71                TODO: do any kind of logic in here with the LocationCoordinates class
72                e.g. like a request to an API, etc --> all on the native side
73                */
74            }
75        };
76    }
77
78    @Override
79    public void registerEventReceiver() {
80        IntentFilter eventFilter = new IntentFilter();
81        eventFilter.addAction(LOCATION_EVENT_NAME);
82        registerReceiver(mEventReceiver, eventFilter);
83    }
84
85    @Nullable
86    @Override
87    public IBinder onBind(Intent intent) {
88        return null;
89    }
90
91    @Override
92    public void onDestroy() {
93        unregisterReceiver(mEventReceiver);
94        mAlarmManager.cancel(mLocationBackgroundServicePendingIntent);
95        stopSelf();
96        super.onDestroy();
97    }
98
99    private void createNotificationChannel() {
100        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
101            NotificationChannel serviceChannel = new NotificationChannel(
102                    CHANNEL_ID,
103                    "Foreground Service Channel",
104                    NotificationManager.IMPORTANCE_DEFAULT
105            );
106
107            NotificationManager manager = getSystemService(NotificationManager.class);
108            manager.createNotificationChannel(serviceChannel);
109        }
110    }
111
112    private Notification createNotification() {
113        Intent notificationIntent = new Intent(this, MainActivity.class);
114        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notificationIntent, 0);
115
116        return new NotificationCompat.Builder(this, CHANNEL_ID)
117                .setContentIntent(pendingIntent)
118                .build();
119    }
120
121    private void createLocationPendingIntent() {
122        Intent i = new Intent(getApplicationContext(), LocationBackgroundService.class);
123        mLocationBackgroundServicePendingIntent = PendingIntent.getService(getApplicationContext(), 1, i, PendingIntent.FLAG_UPDATE_CURRENT);
124    }
125}

1package com.rnbglocation.location;
2
3import android.annotation.SuppressLint;
4import android.app.IntentService;
5import android.content.Intent;
6import android.location.Location;
7import android.os.Handler;
8
9import androidx.annotation.Nullable;
10
11import com.google.android.gms.location.FusedLocationProviderClient;
12import com.google.android.gms.location.LocationCallback;
13import com.google.android.gms.location.LocationRequest;
14import com.google.android.gms.location.LocationResult;
15import com.google.android.gms.location.LocationServices;
16import com.google.gson.Gson;
17
18import java.util.Date;
19
20public class LocationBackgroundService extends IntentService {
21    private FusedLocationProviderClient mFusedLocationClient;
22    private LocationCallback mLocationCallback;
23    private Gson mGson;
24
25    public LocationBackgroundService() {
26        super(LocationForegroundService.class.getName());
27        mGson = new Gson();
28    }
29
30    @SuppressLint("MissingPermission")
31    @Override
32    protected void onHandleIntent(@Nullable Intent intent) {
33        mFusedLocationClient = LocationServices.getFusedLocationProviderClient(getApplicationContext());
34        mLocationCallback = createLocationRequestCallback();
35
36        LocationRequest locationRequest = LocationRequest.create()
37                .setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY)
38                .setInterval(0)
39                .setFastestInterval(0);
40
41        new Handler(getMainLooper()).post(() -> mFusedLocationClient.requestLocationUpdates(locationRequest, mLocationCallback, null));
42    }
43
44    private LocationCallback createLocationRequestCallback() {
45        return new LocationCallback() {
46            @Override
47            public void onLocationResult(LocationResult locationResult) {
48                if (locationResult == null) {
49                    return;
50                }
51                for (Location location : locationResult.getLocations()) {
52                    LocationCoordinates locationCoordinates = createCoordinates(location.getLatitude(), location.getLongitude());
53                    broadcastLocationReceived(locationCoordinates);
54                    mFusedLocationClient.removeLocationUpdates(mLocationCallback);
55                }
56            }
57        };
58    }
59
60    private LocationCoordinates createCoordinates(double latitude, double longitude) {
61        return new LocationCoordinates()
62                .setLatitude(latitude)
63                .setLongitude(longitude)
64                .setTimestamp(new Date().getTime());
65    }
66
67    private void broadcastLocationReceived(LocationCoordinates locationCoordinates) {
68        Intent eventIntent = new Intent(LocationForegroundService.LOCATION_EVENT_NAME);
69        eventIntent.putExtra(LocationForegroundService.LOCATION_EVENT_DATA_NAME, mGson.toJson(locationCoordinates));
70        getApplicationContext().sendBroadcast(eventIntent);
71    }
72}