web-dev-qa-db-fra.com

Détecter l'activité des utilisateurs (course à pied, vélo, conduite) à l'aide d'Android

À l'aide de mon appareil Android, comment savoir si l'utilisateur marche, conduit à vélo ou conduit? J'ai vérifié l'application Google Fit. Il fait la différence entre courir, faire du vélo et conduire. Je suis perplexe quant aux algorithmes que je devrais utiliser pour différencier ces activités.

Je sais que je devrais utiliser le capteur de l'accéléromètre. Mais je ne peux toujours pas différencier ces activités.

androidaccelerometerandroid-sensorsgyroscope
11
Mayur More

Vous pouvez utiliser GooglePlayServices pour cela.

Il fournit des apis spéciaux pour ActivityRecognition, qui renvoie l'activité de l'utilisateur avec un niveau de confiance pour chacun.

https://developer.Android.com/reference/com/google/Android/gms/location/ActivityRecognitionClient.html

http://developer.Android.com/training/location/activity-recognition.html

12
Eldhose M Babu

Cette question est assez ancienne, mais étant donné qu’il existe de nouvelles technologies, j’ai pensé que cela valait la peine d’être mentionné, si quelqu'un rencontrait encore ce problème. 

Je peux proposer 3 options: 

  1. Vous pouvez mettre en œuvre votre propre technique pour détecter la marche, la conduite, le cyclisme - en utilisant reconnaissance d'activité et en recevant des mises à jour d'emplacement , bien que je recommande de ne pas le faire , ne pas Pour ne pas réinventer la roue, de bons apis sont déjà développés, nous sommes en 2016 maintenant.

  2. Vous pouvez utiliser un sdk gratuit de Neura qui peut vous envoyer un événement lorsque votre utilisateur démarre/termine de conduire, commence/finit de marcher, commence/finit de courir, lisez davantage d’événements auxquels vous pouvez accéder). Neura .

    Découvrez ce projet git } _: En gros, le projet contient tous les événements que Nuera peut détecter. Il est très facile de prendre ce projet et de le personnaliser.

    Je recommande fortement d'utiliser cette option Neura sdk.

  3. Vous pouvez utiliser FenceApi de Google pour déclarer des clôtures. Par exemple, il s’agit d’un code permettant de détecter une aire de conduite.

    Bien que cette approche semble bonne, j'ai été confrontée au fait que cette api ne me disait pas parfois quand les événements se produisaient, et parfois cela prenait beaucoup de temps après que j'ai commencé à marcher/courir lorsque l'api m'a dit de cet événement.

    une. inclure la dépendance au fichier build.gradle de votre application: 

       compile 'com.google.Android.gms:play-services-location:+'

   compile 'com.google.Android.gms:play-services-contextmanager:+'

    b. Définitions manifestes: 

    <uses-permission Android:name="com.google.Android.gms.permission.ACTIVITY_RECOGNITION" />
<uses-permission Android:name="Android.permission.INTERNET" />
<uses-permission Android:name="Android.permission.ACCESS_FINE_LOCATION" />

<application
    Android:allowBackup="true"
    Android:icon="@mipmap/ic_launcher"
    Android:label="@string/app_name"
    Android:supportsRtl="true"
    Android:theme="@style/AppTheme" >

    <meta-data
        Android:name="com.google.Android.awareness.API_KEY"
        Android:value="PUT_YOUR_AWARENESS_KEY_HERE" />

    <activity Android:name=".MainActivity" >
        <intent-filter>
            <action Android:name="Android.intent.action.MAIN" />

            <category Android:name="Android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>
</application>

    PUT_YOUR_AWARENESS_KEY_HERE: Vous devez générer une clé ici .

    c. Votre classe MainActivity - explications attachées au code: 

    public class MainActivity extends Activity {

    private GoogleApiClient mGoogleApiClient;
    private PendingIntent mPendingIntent;
    private FenceReceiver mFenceReceiver;

    // The intent action which will be fired when your fence is triggered.
    private final String FENCE_RECEIVER_ACTION = BuildConfig.APPLICATION_ID + "FENCE_RECEIVER_ACTION";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mGoogleApiClient = new GoogleApiClient.Builder(this).addApi(Awareness.API).build();
        mGoogleApiClient.connect();
        // Set up the PendingIntent that will be fired when the fence is triggered.
        mPendingIntent = PendingIntent.getBroadcast(this, 0, new Intent(FENCE_RECEIVER_ACTION), 0);
        // The broadcast receiver that will receive intents when a fence is triggered.
        mFenceReceiver = new FenceReceiver();
        registerReceiver(mFenceReceiver, new IntentFilter(FENCE_RECEIVER_ACTION));
        createFence(DetectedActivityFence.IN_VEHICLE, "InVehicleFence");
    }

    @Override
    public void onDestroy() {
        try {
            unregisterReceiver(mFenceReceiver); //Don't forget to unregister the receiver
        } catch (Exception e) {
            e.printStackTrace();
        }
        super.onDestroy();
    }

    private void createFence(int detectedActivityFence, final String fenceKey) {
        AwarenessFence fence = DetectedActivityFence.during(detectedActivityFence);
        // Register the fence to receive callbacks.
        Awareness.FenceApi.updateFences(
                mGoogleApiClient, new FenceUpdateRequest.Builder().addFence(fenceKey, fence, mPendingIntent)
                        .build()).setResultCallback(new ResultCallback<Status>() {
            @Override
            public void onResult(@NonNull Status status) {
                if (status.isSuccess()) {
                    Log.i(getClass().getSimpleName(), "Successfully registered.");
                } else {
                    Log.e(getClass().getSimpleName(), "Could not be registered: " + status);
                }
            }
        });
    }

    // Handle the callback on the Intent.
    public class FenceReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            FenceState fenceState = FenceState.extract(intent);
            switch (fenceState.getCurrentState()) {
                case FenceState.TRUE:
                    Log.i(fenceState.getFenceKey(), "Active");
                    break;
                case FenceState.FALSE:
                    Log.i(fenceState.getFenceKey(), "Not Active");
                    break;
            }
        }
    }
}

    Cet exemple sert uniquement à détecter l'état de conduite, mais vous pouvez appeler 'createFence' avec d'autres méthodes d'activité telles que: 

    createFence(DetectedActivityFence.TILTING, "TiltingFence");
createFence(DetectedActivityFence.WALKING, "WalkingFence");
createFence(DetectedActivityFence.ON_FOOT, "OnFootFence");
createFence(DetectedActivityFence.RUNNING, "RunningFence");
16
Dus

Vous pouvez utiliser DetectActivity pour différencier les types d’activités prédéfinis.

2
Mojo Risin

Jetez un coup d’œil à la API de reconnaissance d’emplacement et d’activité Google . Je pense que c'est exactement ce que vous recherchez.

0
Wirling