目录

To use the location service API of HUAWEI Location Kit, you need to download and install HMS Core (APK) on your device, and integrate related SDKs into your project. For details, please refer to Preparations.

1. Location Service Development Procedure

1.1 Assigning App Permissions

The Android OS provides two location permissions: ACCESS_COARSE_LOCATION (approximate location permission) and ACCESS_FINE_LOCATION (precise location permission). You need to apply for the permissions in the Manifest file.

  1. <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
  2. <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>

In Android Q, if your app needs to continuously locate the device location when it runs in the background, you need to apply for the ACCESS_BACKGROUND_LOCATION permission in the Manifest file.

  1. <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />

After adding the preceding information to the Manifest file, you need to dynamically apply for the permissions in the code (according to risky permission requirements in Android 6.0).

  1. if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.P) {
  2.     Log.i(TAG, "sdk < 28 Q");
  3.     if (ActivityCompat.checkSelfPermission(this,
  4.         Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED
  5.         || ActivityCompat.checkSelfPermission(this,
  6.             Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
  7.         String[] strings =
  8.             {Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION};
  9.         ActivityCompat.requestPermissions(this, strings, 1);
  10.     }
  11. } else {
  12.     if (ActivityCompat.checkSelfPermission(this,
  13.         Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED
  14.         || ActivityCompat.checkSelfPermission(this,
  15.             Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED
  16.         || ActivityCompat.checkSelfPermission(this,
  17.             "android.permission.ACCESS_BACKGROUND_LOCATION") != PackageManager.PERMISSION_GRANTED) {
  18.         String[] strings = {android.Manifest.permission.ACCESS_FINE_LOCATION,
  19.             android.Manifest.permission.ACCESS_COARSE_LOCATION,
  20.             "android.permission.ACCESS_BACKGROUND_LOCATION"};
  21.         ActivityCompat.requestPermissions(this, strings, 2);
  22.     }
  23. }

1.2 Creating a Location Service Client

Create a FusedLocationProviderClient instance in the OnCreate()method of the activity and use the instance to call location-related APIs.

  1. private FusedLocationProviderClient fusedLocationProviderClient;
  2. private LocationRequest mLocationRequest;
  3. protected void onCreate(Bundle savedInstanceState) {
  4.     fusedLocationProviderClient = LocationServices.getFusedLocationProviderClient(this);
  5. }

1.3 Checking the Device Location Settings

Device location settings will affect the location result of HUAWEI Location Kit. For example, if the location function is disabled on a device, the device location cannot be obtained. Therefore, you are advised to check whether the device settings meet the location requirements before continuously obtaining location information. HUAWEI Location Kit provides the capability of checking device location settings. Your app can obtain the SettingsClient instance using getSettingsClient(Activity activity) of LocationServices and call the checkLocationSettings( LocationSettingsRequest locationSettingsRequest) API to obtain the device location settings. If the location settings do not meet the location requirements, your app can prompt users to enable related permissions. (The location permission must be enabled for HMS Core. In Android Q, Location must be set to Always for HMS Core.)

Step 1: Obtain the service API of SettingsClient.

  1. SettingsClient settingsClient = LocationServices.getSettingsClient(this);

Step 2: Call checkLocationSettings() to check the device settings.

  1. LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder();
  2. mLocationRequest = new LocationRequest();
  3. builder.addLocationRequest(mLocationRequest);
  4. LocationSettingsRequest locationSettingsRequest = builder.build();
  5. //check Location Settings
  6. settingsClient.checkLocationSettings(locationSettingsRequest)
  7.         .addOnSuccessListener(new OnSuccessListener<LocationSettingsResponse>() {
  8.             @Override
  9.             public void onSuccess(LocationSettingsResponse locationSettingsResponse) {
  10.                 //Have permissions， send requests
  11.                 fusedLocationProviderClient
  12.                         .requestLocationUpdates(mLocationRequest, mLocationCallback, Looper.getMainLooper())
  13.                         .addOnSuccessListener(new OnSuccessListener<Void>() {
  14.                             @Override
  15.                             public void onSuccess(Void aVoid) {
  16.                                 //Interface call successfully processed
  17.                             }
  18.                         });
  19.             }
  20.         })
  21.         .addOnFailureListener(new OnFailureListener() {
  22.             @Override
  23.             public void onFailure(Exception e) {
  24.                 //Settings do not meet targeting criteria
  25.                 int statusCode = ((ApiException) e).getStatusCode();
  26.                 switch (statusCode) {
  27.                     case LocationSettingsStatusCodes.RESOLUTION_REQUIRED:
  28.                         try {
  29.                             ResolvableApiException rae = (ResolvableApiException) e;
  30.                             //Calling startResolutionForResult can pop up a window to prompt the user to open the corresponding permissions
  31.                             rae.startResolutionForResult(MainActivity.this, 0);
  32.                         } catch (IntentSender.SendIntentException sie) {
  33.                             //…
  34.                         }
  35.                         break;
  36.                 }
  37.             }
  38.         });


1.4 Continuously Obtaining the Location Information

To enable your app to continuously obtain the device location, you can use the requestLocationUpdates() API provided by the HUAWEI Location Kit service. This API returns the location information in two different forms based on the input parameter type. One form is to call the defined LocationCallback.onLocationResult() method to return a LocationResult object containing the location information. The other form is to return the location information in the extended information of the PendingIntent object.

If your app does not need to receive location updates anymore, you shall stop location updates to reduce power consumption. To stop location updates, you can call the removeLocationUpdates() method, and transfer the LocationCallback or PendingIntent object corresponding to the requestLocationupdates() API.

Here, the callback method is used as an example. The code is as follows. For details about parameters, please refer to the location API description.

1. Set continuous location request parameters.

  1. LocationRequest mLocationRequest = new LocationRequest();        
  2. //Set the location update interval (int milliseconds).        
  3. mLocationRequest.setInterval(10000);        
  4. //Set the weight.        
  5. mLocationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);

2. Define the location update callback. 

  1. LocationCallback mLocationCallback;        
  2. mLocationCallback = new LocationCallback() {        
  3.                @Override        
  4.                public void onLocationResult(LocationResult locationResult) {        
  5.                    if (locationResult != null) {        
  6.                        //Process the location callback result.        
  7.                    }        
  8.                }        
  9. };

3. Call requestLocationUpdates() for continuous location.

  1. fusedLocationProviderClient        
  2.                    .requestLocationUpdates(mLocationRequest, mLocationCallback, Looper.getMainLooper())        
  3.                    .addOnSuccessListener(new OnSuccessListener<Void>() {        
  4.                        @Override        
  5.                        public void onSuccess(Void aVoid) {        
  6.                            //Processing when the API call is successful.        
  7.                        }        
  8.                    })        
  9.                    .addOnFailureListener(new OnFailureListener() {        
  10.                        @Override        
  11.                        public void onFailure(Exception e) {        
  12.                            //Processing when the API call fails.        
  13.                        }        
  14.                    });
Notice:
If the API is called successfully but the location fails to be obtained, please refer to question3 in FAQs. 

4. Call removeLocationUpdates() to stop location updates.

  1. //Note: When location updates are stopped, the mLocationCallback object must be the same as that of requestLocationUpdates().
  2. fusedLocationProviderClient.removeLocationUpdates(mLocationCallback)        
  3.                .addOnSuccessListener(new OnSuccessListener<Void>() {        
  4.                    @Override        
  5.                    public void onSuccess(Void aVoid) {        
  6.                        //Location updates are stopped successfully.        
  7.                    }        
  8.                })        
  9.                .addOnFailureListener(new OnFailureListener() {        
  10.                    @Override        
  11.                    public void onFailure(Exception e) {        
  12.                        //Failed to stop location updates.      
  13.                    }        
  14.                });

1.5 Obtaining the Last Known Location

An app can use the HUAWEI Location Kit service API to obtain the last known location of a device. In most cases, the last known location is the current location of the device. The following is the sample code for calling the getLastLocation() method to obtain the last known location:

  1. Task<Location> task = fusedLocationProviderClient.getLastLocation()        
  2.                .addOnSuccessListener(new OnSuccessListener<Location>() {        
  3.                    @Override        
  4.                    public void onSuccess(Location location) {        
  5.                        if (location == null) {        
  6.                            return;        
  7.                        }        
  8.                        //Processing logic of the Location object.        
  9.                    }        
  10.                })        
  11.                .addOnFailureListener(new OnFailureListener() {        
  12.                    @Override        
  13.                    public void onFailure(Exception e) {        
  14.                        //Exception handling logic.        
  15.                    }        
  16.                });

1.6 Using the Mock Location

To use the mock location function, go to Settings > System & updates > Developer options > Select mock location app and select the app for using the mock location function. (If Developer options is unavailable, go to Settings > About phone and tap Build number for seven consecutive times. Then, Developer options will be displayed on System & updates.) The sample code is as follows:

1. Call setMockMode(boolean isMockMode) to set the mock mode.

  1. fusedLocationProviderClient.setMockMode(mockFlag)
  2.                         .addOnSuccessListener(new OnSuccessListener<Void>() {
  3.                             @Override
  4.                             public void onSuccess(Void aVoid) {
  5.                                 Log.i(TAG, "setMockMode onSuccess");
  6.                             }
  7.                         })
  8.                         .addOnFailureListener(new OnFailureListener() {
  9.                             @Override
  10.                             public void onFailure(Exception e) {
  11.                                 Log.i(TAG, "setMockMode onFailure:" + e.getMessage());
  12.                             }
  13.                         });

2. Call setMockLocation(Location mockLocation) to set the mock location.

  1. fusedLocationProviderClient.setMockLocation(mockLocation)
  2.                         .addOnSuccessListener(new OnSuccessListener<Void>() {
  3.                             @Override
  4.                             public void onSuccess(Void aVoid) {
  5.                                 Log.i(TAG, "setMockLocation onSuccess");
  6.                             }
  7.                         })
  8.                         .addOnFailureListener(new OnFailureListener() {
  9.                             @Override
  10.                             public void onFailure(Exception e) {
  11.                                 Log.i(TAG, "setMockLocation onFailure:" + e.getMessage());
  12.                             }
  13.                         });

2.Activity Identification Service Development Procedure

To use the activity identification service API of HUAWEI Location Kit, you need to download and install HMS Core (APK) on your device, and integrate related SDKs into your project. For details, please refer to Preparations.

2.1 Assigning App Permissions

1. To use the activity identification service in versions earlier than Android Q, you need to configure the following permissions in the Manifest file:

  1. <uses-permission android:name="com.huawei.hms.permission.ACTIVITY_RECOGNITION"/>

2. To use the activity identification service in Android Q and later versions, you need to configure the following permissions in the Manifest file:

  1. <uses-permission android:name="android.permission.ACTIVITY_RECOGNITION" />
NOTE：
The preceding permissions are risky permissions and need to be dynamically applied.

2.2 Creating an Activity Identification Service Client

Create an ActivityIdentificationService instance in the OnCreate() method of the activity and use the instance to call APIs related to activity identification.

  1. //The way to get the PendingIntent and callback results can be customized. Here we use broadcast as an example.
  2. private PendingIntent pendingIntent;
  3. private ActivityIdentificationService activityIdentificationService;
  4. protected void onCreate(Bundle savedInstanceState) {
  5.     activityIdentificationService = ActivityIdentification.getService(this);
  6.     pendingIntent = getPendingIntent();
  7. };

2.3 Registering Receiving of Activity Identification Updates

To use the activity identification service, you need to register receiving of activity identification updates to check the current user status, such as walking, bicycling, and motionless.

1. Create new PendingIntent.

  1. private PendingIntent getPendingIntent() {
  2.     //The LocationBroadcastReceiver class is a custom class. For detailed implementation methods, please refer to the sample code.
  3.     Intent intent = new Intent(this, LocationBroadcastReceiver.class);
  4.     intent.setAction(LocationBroadcastReceiver.ACTION_PROCESS_LOCATION);
  5.     return PendingIntent.getBroadcast(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
  6. }

2. Listen on activity identification update requests.

Call the createActivityIdentificationUpdates (long detectionIntervalMillis, PendingIntent pendingIntent) method. In the method, the first parameter indicates the detection interval and the second parameter indicates pendingIntent.

  1. activityIdentificationService.createActivityIdentificationUpdates(5000, pendingIntent)
  2.                 .addOnSuccessListener(new OnSuccessListener<Void>() {
  3.                     @Override
  4.                     public void onSuccess(Void aVoid) {
  5.                         Log.i(TAG, "createActivityIdentificationUpdates onSuccess");
  6.                     }
  7.                 })
  8.                 .addOnFailureListener(new OnFailureListener() {
  9.                     @Override
  10.                     public void onFailure(Exception e) {
  11.                         Log.e(TAG, "createActivityIdentificationUpdates onFailure:" + e.getMessage());
  12.                     }
  13.                 });

3. Deregister receiving of activity identificationupdates.

After using activity identification, you need to remove the listening on activity identification update requests. The value of PendingIntent must be the same as that of createActivityIdentificationUpdates (long detectionIntervalMillis, PendingIntent callbackIntent).

  1. activityIdentificationService.deleteActivityIdentificationUpdates(pendingIntent)
  2.     .addOnSuccessListener(new OnSuccessListener<Void>() {
  3.         @Override
  4.         public void onSuccess(Void aVoid) {
  5.             Log.i(TAG, "deleteActivityIdentificationUpdates onSuccess");
  6.         }
  7.     })
  8.     .addOnFailureListener(new OnFailureListener() {
  9.         @Override
  10.         public void onFailure(Exception e) {
  11.             Log.e(TAG, "deleteActivityIdentificationUpdates onFailure:" + e.getMessage());
  12.         }
  13.     });

4. Process the activity identification results.

 Activity identification result

  1. public class LocationBroadcastReceiver extends BroadcastReceiver {
  2.     public static final String ACTION_PROCESS_LOCATION = "com.huawei.hms.location.ACTION_PROCESS_LOCATION";
  3.     @Override
  4.     public void onReceive(Context context, Intent intent) {
  5.         if (intent != null) {
  6.             final String action = intent.getAction();
  7.             if (ACTION_PROCESS_LOCATION.equals(action)) {
  8.                  ActivityIdentificationResponse activityIdentificationResponse = ActivityIdentificationResponse.getDataFromIntent(intent);
  9.                  List<ActivityIdentificationData> list = activityIdentificationResponse .getActivityIdentificationDatas();
  10.             }
  11.         }
  12.     }
  13. }

2.4 Registering Receiving of Activity Conversion Updates

The function of detecting activity conversions (activity entering and exit) is provided. For example, to detect user status change from walking to bicycling, the app can call the createActivityConversionUpdates(request, pendingIntent) method to obtain the activity conversion status change.

1. Set parameters for listening to activity conversion requests.

  1. int STILL = 103;
  2. ActivityConversionInfo activityConversionInfo1 = new ActivityConversionInfo(STILL, ActivityConversionInfo.ENTER_ACTIVITY_CONVERSION);
  3. ActivityConversionInfo activityConversionInfo2 = new ActivityConversionInfo(STILL, ActivityConversionInfo.EXIT_ACTIVITY_CONVERSION);
  4. List<ActivityConversionInfo> activityConversionInfos = new ArrayList<>();
  5. activityConversionInfos.add(activityConversionInfo1);
  6. activityConversionInfos.add(activityConversionInfo2);
  7. ActivityConversionRequest request = new ActivityConversionRequest();
  8. request.setActivityConversions(activityConversionInfos);

2. Listen to activity conversion updates.

  1. Task<Void> task = activityIdentificationService.createActivityConversionUpdates(request, pendingIntent);
  2.     task.addOnSuccessListener(new OnSuccessListener<Void>() {
  3.         @Override
  4.         public void onSuccess(Void aVoid) {
  5.             Log.i(TAG, "createActivityConversionUpdates onSuccess");
  6.         }
  7.     }).addOnFailureListener(new OnFailureListener() {
  8.         @Override
  9.         public void onFailure(Exception e) {
  10.             Log.e(TAG, "createActivityConversionUpdates onFailure:" + e.getMessage());
  11.         }
  12.     });

3. Deregister receiving of activity conversion updates.

If your app does not need to listen to activity conversions anymore, you need to call deleteActivityConversionUpdates(PendingIntent pendingIntent) to deregister receiving of activity conversion updates.

  1. activityIdentificationService.deleteActivityConversionUpdates(pendingIntent)
  2.     .addOnSuccessListener(new OnSuccessListener<Void>() {
  3.         @Override
  4.         public void onSuccess(Void aVoid) {
  5.             Log.i(TAG, "deleteActivityConversionUpdates onSuccess");
  6.         }
  7.     })
  8.     .addOnFailureListener(new OnFailureListener() {
  9.         @Override
  10.         public void onFailure(Exception e) {
  11.             Log.e(TAG, "deleteActivityConversionUpdates onFailure:" + e.getMessage());
  12.         }
  13.     });

4. Process the result.

 Activity conversion result

  1. public class LocationBroadcastReceiver extends BroadcastReceiver {
  2.     public static final String ACTION_PROCESS_LOCATION = "com.huawei.hms.location.ACTION_PROCESS_LOCATION";
  3.     @Override
  4.     public void onReceive(Context context, Intent intent) {
  5.         if (intent != null) {
  6.             final String action = intent.getAction();
  7.             if (ACTION_PROCESS_LOCATION.equals(action)) {
  8.                 ActivityConversionResponse activityConversionResponse = ActivityConversionResponse.getDataFromIntent(intent);
  9.                 List<ActivityConversionData> list = activityConversionResponse .getActivityConversionDatas();
  10.             }
  11.         }
  12.     }
  13. }

3.Developing the Geofence Service

To use the geofence service API of HUAWEI Location Kit, you need to download and install HMS Core (APK) on your device, and integrate related SDKs into your project. For details, please refer to Preparations.

3.1 Assigning App Permissions

1. To use the geofence service API of HUAWEI Location Kit, you need to apply for the ACCESS_FINE_LOCATION permission in the Manifest file.

  1. <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>

2. In Android Q, you need to apply for the ACCESS_BACKGROUND_LOCATION permission in the Manifest file.

  1. <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />

3.2 Creating a Geofence Service Client

Create a GeofenceService instance in the OnCreate() method of Activity and use the instance to call geofence-related APIs.

  1. private GeofenceService geofenceService;
  2. private ArrayList<String> idList;
  3. private ArrayList<Geofence> geofenceList;
  4. private String TAG;
  5. //The way to get the PendingIntent and callback results can be customized. Here we use broadcast as an example.
  6. private PendingIntent pendingIntent;
  7. protected void onCreate(Bundle savedInstanceState) {    
  8.     geofenceService = LocationServices.getGeofenceService(this);
  9.     pendingIntent = getPendingIntent();
  10.     idList = new ArrayList<String>();
  11.     geofenceList = new ArrayList<Geofence>();
  12.     TAG = "geoFence";
  13. }

3.3 Creating and Adding a Geofence

You can create a geofence instance and construct a request to add a geofence. After you send the request, the system will notify you of the request result through Task.

1. Create a geofence instance.

  1. geofenceList.add(new Geofence.Builder()    
  2.                  .setUniqueId("mGeofence")    
  3.                  .setValidContinueTime(10000)    
  4.                  //Incoming latitude and longitude information, radius of circular geofence (unit: meter)
  5.                  .setRoundArea(latitude, longitude, radius)    
  6.                  //Callback when entering or exiting the fence
  7.                  .setConversions(Geofence.ENTER_GEOFENCE_CONVERSION | Geofence.EXIT_GEOFENCE_CONVERSION)    
  8.                  .build());
  9. idList.add("mGeofence");

2. Construct a request to add a geofence.

  1. private GeofenceRequest getAddGeofenceRequest() {    
  2.     GeofenceRequest.Builder builder = new GeofenceRequest.Builder();    
  3.     //When the user is in the fence, the callback is triggered immediately after adding
  4.     builder.setInitConversions(GeofenceRequest.ENTER_INIT_CONVERSION);    
  5.     builder.createGeofenceList(geofenceList);    
  6.     return builder.build();
  7. }

3. Create new PendingIntent.

  1. private PendingIntent getPendingIntent() {
  2. //The GeoFenceBroadcastReceiver class is a custom static broadcast class. For detailed implementation methods, refer to the sample code.
  3.     Intent intent = new Intent(this, GeoFenceBroadcastReceiver.class);
  4.     intent.setAction(GeoFenceBroadcastReceiver.ACTION_PROCESS_LOCATION);
  5.     return PendingIntent.getBroadcast(this,0, intent,  PendingIntent.FLAG_UPDATE_CURRENT);
  6. }

4. Send the request to add a geofence.

  1. public void requestGeoFenceWithNewIntent() {
  2.             geofenceService.createGeofenceList(getAddGeofenceRequest(), pendingIntent)
  3.                     .addOnCompleteListener(new OnCompleteListener<Void>() {
  4.                         @Override
  5.                         public void onComplete(Task<Void> task) {
  6.                             if (task.isSuccessful()) {
  7.                                 Log.i(TAG, "add geofence success！");
  8.                             } else {
  9.                                 Log.w(TAG, "add geofence failed : " + task.getException().getMessage());
  10.                             }
  11.                         }
  12.                     });
  13.     }

5. Delete geofences using an ID list.

  1. public void removeWithID() {
  2.             geofenceService.deleteGeofenceList(idList)
  3.                 .addOnCompleteListener(new OnCompleteListener<Void>() {
  4.                 @Override
  5.                 public void onComplete(Task<Void> task) {
  6.                     if (task.isSuccessful()) {
  7.                         Log.i(TAG, "delete geofence with ID success！");
  8.                     } else {
  9.                         Log.w(TAG, "delete geofence with ID failed ");
  10.                     }
  11.                 }
  12.             });
  13.     }

You can delete a geofence by geofence ID or through PendingIntent.


6. Process a geofence trigger event.

When detecting a geofence trigger event, the system broadcast a notification to the user through PendingIntent.

  1. public class GeoFenceBroadcastReceiver extends BroadcastReceiver {
  2.     public static final String ACTION_PROCESS_LOCATION = "com.huawei.hmssample.geofence.GeoFenceBroadcastReceiver.ACTION_PROCESS_LOCATION";
  3.     @Override
  4.     public void onReceive(Context context, Intent intent) {
  5.         if (intent != null) {
  6.             final String action = intent.getAction();
  7.             StringBuilder sb = new StringBuilder();
  8.             String next = "\n";
  9.             if (ACTION_PROCESS_LOCATION.equals(action)) {
  10.                 GeofenceData geofenceData = GeofenceData.getDataFromIntent(intent);
  11.                 if (geofenceData != null) {
  12.                    int errorCode = geofenceData.getErrorCode();
  13.                    int conversion = geofenceData.getConversion();
  14.                    List<Geofence> list = geofenceData.getConvertingGeofenceList();
  15.                    Location mLocation = geofenceData.getConvertingLocation();
  16.                    boolean status = geofenceData.isSuccess();
  17.                    sb.append("errorcode: " + errorCode + next);
  18.                    sb.append("conversion: " + conversion + next);
  19.                    for(int i = 0;i < list.size();i++){
  20.                        sb.append("geoFence id :" + list.get(i).getUniqueId() + next);
  21.                    }
  22.                    sb.append("location is :" + mLocation.getLongitude() + " " + mLocation.getLatitude() + next);
  23.                    sb.append("is successful :" + status);
  24.                    Log.i(TAG,sb.toString());
  25.                 }
  26.             }
  27.         }
  28.     }
  29. }