Android Studio

How to create activity recognition android app in android studio

activity recognition in android studio

Activity Recognition in Android Studio


In this article, I will teach you how to detect user activity through android app, you can detect these user activities like still, walking, running, cycling, tilting, driving etc. In this article, we will be using ActivityRecognitionClient API. This API is frequently used in fitness app for taking user information about number of steps taken and how much distance user travelled in km. So if you learn, this API it will be very useful for you in future.

Practical Implementation in Android Studio

I am using background service for this app, which means i will fetch user activity in background and your app will fetching user activity when app is in background state. so you need to stop fetching user activity explicitly.
 

1. Add this permission in your manifest file.

<uses-permission android:name=”com.google.android.gms.permission.ACTIVITY_RECOGNITION” />
 

2. Add this dependency in gradle file and sync your project. 

implementation com.google.android.gms:play-services-location:17.0.0′
 

3. Create class for background services

import android.app.PendingIntent;
import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.util.Log;
import android.widget.Toast;

import com.google.android.gms.location.ActivityRecognitionClient;
import com.google.android.gms.tasks.OnFailureListener;
import com.google.android.gms.tasks.OnSuccessListener;
import com.google.android.gms.tasks.Task;

public class BackgroundDetectedActivitiesService extends Service {
private static final String TAG = BackgroundDetectedActivitiesService.class.getSimpleName();

private Intent mIntentService;
private PendingIntent mPendingIntent;
private ActivityRecognitionClient mActivityRecognitionClient;

IBinder mBinder = new BackgroundDetectedActivitiesService.LocalBinder();

public class LocalBinder extends Binder {
public BackgroundDetectedActivitiesService getServerInstance() {
return BackgroundDetectedActivitiesService.this;
}
}

public BackgroundDetectedActivitiesService() {

}

@Override
public void onCreate() {
super.onCreate();
mActivityRecognitionClient = new ActivityRecognitionClient(this);
mIntentService = new Intent(this, DetectedActivitiesIntentService.class);
mPendingIntent = PendingIntent.getService(this, 1, mIntentService, PendingIntent.FLAG_UPDATE_CURRENT);
requestActivityUpdatesButtonHandler();
}

@Nullable
@Override
public IBinder onBind(Intent intent) {
return mBinder;
}

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
super.onStartCommand(intent, flags, startId);
return START_STICKY;
}

public void requestActivityUpdatesButtonHandler() {
Task<Void> task = mActivityRecognitionClient.requestActivityUpdates(
Constants.DETECTION_INTERVAL_IN_MILLISECONDS,
mPendingIntent);

task.addOnSuccessListener(new OnSuccessListener<Void>() {
@Override
public void onSuccess(Void result) {
Toast.makeText(getApplicationContext(),
“Successfully requested activity updates”,
Toast.LENGTH_SHORT)
.show();
}
});

task.addOnFailureListener(new OnFailureListener() {
@Override
public void onFailure(@NonNull Exception e) {
Toast.makeText(getApplicationContext(),
“Requesting activity updates failed to start”,
Toast.LENGTH_SHORT)
.show();
}
});
}

public void removeActivityUpdatesButtonHandler() {
Task<Void> task = mActivityRecognitionClient.removeActivityUpdates(
mPendingIntent);
task.addOnSuccessListener(new OnSuccessListener<Void>() {
@Override
public void onSuccess(Void result) {
Toast.makeText(getApplicationContext(),
“Removed activity updates successfully!”,
Toast.LENGTH_SHORT)
.show();
}
});

task.addOnFailureListener(new OnFailureListener() {
@Override
public void onFailure(@NonNull Exception e) {
Toast.makeText(getApplicationContext(), “Failed to remove activity updates!”,
Toast.LENGTH_SHORT).show();
}
});
}

@Override
public void onDestroy() {
super.onDestroy();
removeActivityUpdatesButtonHandler();
}
}

4. Create class for constant

public class Constants {

public static final String BROADCAST_DETECTED_ACTIVITY = “activity_intent”;

static final long DETECTION_INTERVAL_IN_MILLISECONDS = 30 * 1000;

public static final int CONFIDENCE = 70;
}

5. Create class for broadcasting user activity

import android.app.IntentService;
import android.content.Intent;
import android.support.v4.content.LocalBroadcastManager;
import android.util.Log;

import com.google.android.gms.location.ActivityRecognitionResult;
import com.google.android.gms.location.DetectedActivity;

import java.util.ArrayList;

public class DetectedActivitiesIntentService extends IntentService {

protected static final String TAG = DetectedActivitiesIntentService.class.getSimpleName();

public DetectedActivitiesIntentService() {
// Use the TAG to name the worker thread.
super(TAG);
}

@Override
public void onCreate() {
super.onCreate();
}

@SuppressWarnings(“unchecked”)
@Override
protected void onHandleIntent(Intent intent) {
ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);

// Get the list of the probable activities associated with the current state of the
// device. Each activity is associated with a confidence level, which is an int between
// 0 and 100.
ArrayList<DetectedActivity> detectedActivities = (ArrayList) result.getProbableActivities();

for (DetectedActivity activity : detectedActivities) {
Log.e(TAG, “Detected activity: ” + activity.getType() + “, ” + activity.getConfidence());
broadcastActivity(activity);
}
}

private void broadcastActivity(DetectedActivity activity) {
Intent intent = new Intent(Constants.BROADCAST_DETECTED_ACTIVITY);
intent.putExtra(“type”, activity.getType());
intent.putExtra(“confidence”, activity.getConfidence());
LocalBroadcastManager.getInstance(this).sendBroadcast(intent);
}
}

6. Create main activity, this is main class. All control are given to this activity and from you can initialize background services and use user activity broadcasting.

public class MainActivity extends AppCompatActivity {
 
    private String TAG = MainActivity.class.getSimpleName();
    BroadcastReceiver broadcastReceiver;
 
    private TextView txtActivitytxtConfidence;
    private ImageView imgActivity;
    private Button btnStartTrckingbtnStopTracking;
 
 
    BackgroundDetectedActivitiesService ab;
    static int 0;
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 
        txtActivity = findViewById(R.id.txt_activity);
        txtConfidence = findViewById(R.id.txt_confidence);
        imgActivity = findViewById(R.id.img_activity);
        btnStartTrcking = findViewById(R.id.btn_start_tracking);
        btnStopTracking = findViewById(R.id.btn_stop_tracking);
 
        TextView pri = (TextView) findViewById(R.id.textView);
 
 
 
 
        pri.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                startActivity(new Intent(MainActivity.this , privacy_policy.class));
            }
        });
 
        btnStartTrcking.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
 
                ab new BackgroundDetectedActivitiesService();
                // services not running already
                // start services
                if (!isMyServiceRunning(ab.getClass())) {
 
 
                    txtActivity.setText(“Loading ….. “);
                    txtConfidence.setText(“”);
                    imgActivity.setImageResource(android.R.drawable.screen_background_light_transparent);
 
                    =0;
                    startTracking();
 
                }
 
                else{
 
                    Toast.makeText(MainActivity.this  “Service Already Running”, Toast.LENGTH_LONG).show();
 
                }
 
 
            }
        });
 
        btnStopTracking.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                stopTracking();
            }
        });
 
        broadcastReceiver new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                if (intent.getAction().equals(Constants.BROADCAST_DETECTED_ACTIVITY)) {
                    int type = intent.getIntExtra(“type”, –1);
                    int confidence = intent.getIntExtra(“confidence”0);
                    handleUserActivity(type, confidence);
                }
            }
        };
 
    }
 
    private void handleUserActivity(int type, int confidence) {
        String label = getString(R.string.activity_unknown);
        int icon = R.drawable.ic_still;
 
 
        switch (type) {
            case DetectedActivity.IN_VEHICLE: {
                label = getString(R.string.activity_in_vehicle);
                icon = R.drawable.ic_driving;
                break;
            }
            case DetectedActivity.ON_BICYCLE: {
                label = getString(R.string.activity_on_bicycle);
                icon = R.drawable.ic_on_bicycle;
                break;
            }
            case DetectedActivity.ON_FOOT: {
                label = getString(R.string.activity_on_foot);
                icon = R.drawable.ic_walking;
                break;
            }
            case DetectedActivity.RUNNING: {
                label = getString(R.string.activity_running);
                icon = R.drawable.ic_running;
                break;
            }
            case DetectedActivity.STILL: {
                label = getString(R.string.activity_still);
                icon = R.drawable.ic_still;
 
                break;
            }
            case DetectedActivity.TILTING: {
                label = getString(R.string.activity_tilting);
                icon = R.drawable.ic_tilting;
                break;
            }
            case DetectedActivity.WALKING: {
                label = getString(R.string.activity_walking);
                icon = R.drawable.ic_walking;
                break;
            }
            case DetectedActivity.UNKNOWN: {
                label = getString(R.string.activity_unknown);
                icon = R.drawable.unknown;
 
                break;
            }
        }
 
        Log.e(TAG“User activity: ” + label + “, Confidence: ” + confidence);
 
 
 
        if(==){
 
 
            = confidence;
            txtActivity.setText(label);
            txtConfidence.setText(“Confidence: ” + confidence);
            imgActivity.setImageResource(icon);
 
        }
        else{
 
 
            if(confidence > 50){
 
                = confidence;
                txtActivity.setText(label);
                txtConfidence.setText(“Confidence: ” + confidence);
                imgActivity.setImageResource(icon);
 
 
            }
 
            else if (<= confidence) {
 
                txtActivity.setText(label);
                txtConfidence.setText(“Confidence: ” + confidence);
                imgActivity.setImageResource(icon);
            }
 
 
 
        }
 
    }
 
 
 
    // check your background services
    private boolean isMyServiceRunning(Class<?> serviceClass) {
        ActivityManager manager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
        for (ActivityManager.RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) {
            if (serviceClass.getName().equals(service.service.getClassName())) {
                Log.(“Service status”“Running”);
                return true;
            }
        }
        Log.(“Service status”“Not running”);
        return false;
    }
 
 
    @Override
    protected void onResume() {
        super.onResume();
 
        LocalBroadcastManager.getInstance(this).registerReceiver(broadcastReceiver,
                new IntentFilter(Constants.BROADCAST_DETECTED_ACTIVITY));
    }
 
    @Override
    protected void onPause() {
        super.onPause();
 
        LocalBroadcastManager.getInstance(this).unregisterReceiver(broadcastReceiver);
    }
 
    private void startTracking() {
        Intent intent = new Intent(MainActivity.this, BackgroundDetectedActivitiesService.class);
        startService(intent);
    }
 
    private void stopTracking() {
        Intent intent = new Intent(MainActivity.this, BackgroundDetectedActivitiesService.class);
        stopService(intent);
    }
}

Thats it 🙂 Any question and issue, Feel free to ask anything . Thank you

Leave a Reply

Your email address will not be published. Required fields are marked *