2014-11-21 3 views
10

का उपयोग कर उपयोगकर्ता गतिविधि (चलाना, साइकिल चलाना, ड्राइविंग) का पता लगाएं मेरे एंड्रॉइड डिवाइस का उपयोग करके मैं कैसे पता लगा सकता हूं कि उपयोगकर्ता चल रहा है, साइकिल चलाना या गाड़ी चला रहा है या नहीं? मैंने Google Fit app. चेक किया है यह चलने, साइकिल चलाने और ड्राइविंग के बीच अंतर करता है। मैं इस गतिविधि के बीच अंतर करने के लिए उपयोग करने वाले एल्गोरिदम के बारे में परेशान हूं।एंड्रॉइड

मुझे पता है कि मुझे एक्सेलेरोमीटर सेंसर का उपयोग करना होगा। लेकिन फिर भी मैं इन गतिविधियों को अलग नहीं कर सकता।

उत्तर

10

आप इसके लिए Google PlayServices का उपयोग कर सकते हैं।

यह गतिविधि पहचान के लिए विशेष एपिस प्रदान करता है, जो उपयोगकर्ता गतिविधि को प्रत्येक के लिए आत्मविश्वास स्तर के साथ देता है।

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

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

+0

यह अच्छा रहेगा. वहाँ किसी भी न्यूनतम API अपेक्षित स्तर, या सिर्फ खेलने सेवाओं lib काम करेंगे है? –

+0

@MayurMore इसकी एंड्रॉयड 2.2 के बाद से समर्थित ... –

+0

दोनों लिंक अब –

2

आप पूर्वनिर्धारित प्रकार की गतिविधियों के बीच अंतर करने के लिए DetectActivity का उपयोग कर सकते हैं।

13

यह सवाल काफी पुराना है, लेकिन बाद से वहाँ नई प्रौद्योगिकियों सारे हैं, मैं सोचा था कि यह, उल्लेख के लायक था अगर किसी को अब भी इस समस्या का सामना कर रहा है। नहीं Activity recognition और receiving location updates का उपयोग कर, हालांकि मैं इतना नहीं करने के लिए सलाह देते हैं, करते हैं -

  1. आप चलने का पता लगाने, ड्राइविंग, साइकिल चालन के लिए अपनी खुद की तकनीक को लागू कर सकते हैं:

    मैं 3 विकल्पों के साथ आ सकते हैं पहिया को फिर से शुरू करें, पहले से ही अच्छे एपिस विकसित हुए हैं, यह 2016 है।

  2. आप Neura के एक मुक्त एसडीके जो आप एक घटना भेज सकते हैं जब आपके उपयोगकर्ता शुरू होता है/समाप्त कर ले, ड्राइविंग शुरू/खत्म चलने इस्तेमाल कर सकते हैं, शुरू/खत्म चल रहा है, read more of the events you can get from Neura

    यह git project देखें: असल में, इस परियोजना में सभी घटनाएं हैं जो नुएरा का पता लगा सकते हैं। बस इस परियोजना को लेना और इसे स्वयं बनाना बहुत आसान है।

    मैं अत्यधिक इस Neura एसडीके विकल्प का उपयोग करने की सलाह देते हैं।

  3. आप बाड़ घोषित करने के लिए Google के FenceApi का उपयोग कर सकते हैं। उदाहरण के लिए, यह एक ड्राइविंग बाड़ का पता लगाने के लिए एक कोड है।

    हालांकि यह दृष्टिकोण अच्छा लगता है, लेकिन मुझे इस तथ्य का सामना करना पड़ा कि घटनाओं के दौरान कभी-कभी मुझे यह नहीं बताया गया था, और कभी-कभी मुझे चलने/चलाने के बाद काफी समय लगा जब एपी ने मुझे बताया वह घटना

    ए। अपने ऐप की build.gradle फ़ाइल पर निर्भरता शामिल करें:

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

    बी। प्रकट परिभाषाएँ:

    <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: आप एक महत्वपूर्ण here उत्पन्न करने के लिए की जरूरत है।

    सी। - अपने MainActivity वर्ग स्पष्टीकरण कोड से जुड़ी:

    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; 
          } 
         } 
        } 
    } 
    

    यह नमूना है केवल पता लगाने के राज्य ड्राइविंग, लेकिन, आप 'createFence' जैसे अन्य गतिविधि के तरीकों के साथ कॉल कर सकते हैं के लिए:

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