ऑनकेडाउन और ऑनकेलप्रेस

Question

मैं चाहता हूं कि मेरा एप्लिकेशन वॉल्यूम बटन के सामान्य और लंबे समय तक दबाए गए कुंजी ईवेंट के लिए अलग-अलग प्रतिक्रिया करे।

मैं पहले से ही this देखा है, लेकिन अगर मैं मात्रा बटन दबाया रखने के लिए, मैं KeyDown घटनाक्रम का एक बहुत मिलता है इससे पहले कि मैं KeyLongPressed घटना मिलता है।

मैं या तो एक घटना या दूसरा होना चाहता हूं, दोनों नहीं, ताकि मैं वॉल्यूम को एक छोटी प्रेस पर समायोजित कर सकूं और एक लंबी प्रेस पर ट्रैक छोड़ सकूं।

क्या आप यहां मेरी मदद कर सकते हैं?

@Override 
public boolean onKeyLongPress(int keyCode, KeyEvent event) { 
    if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) 
    { 
     Log.d("Test", "Long press!"); 
     return true; 
    } 
    return super.onKeyLongPress(keyCode, event); 
} 

@Override 
public boolean onKeyDown(int keyCode, KeyEvent event) { 
    if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) { 
     event.startTracking(); 
     Log.d("Test", "Short"); 
     return true; 
    } 

    return super.onKeyDown(keyCode, event); 
} 

किसी भी मदद की सराहना की:

यह मेरा कोड है! - आइरिस

Answer 1

यहाँ कोड है कि मैंने लिखा है। यह एक सम्मोहन की तरह काम करता है। हो सकता है कि आप इसे बेहतर तर्क के लिए अनुकूलित कर सकें। लेकिन आप इसके साथ बिंदु प्राप्त करेंगे। कुंजी झंडे का उपयोग करना है। शॉर्ट प्रेस एक प्रेस है जहां हम कम समय के लिए वॉल्यूम बटन दबाते हैं और जारी करते हैं। तो ऑनकेप वह है जो हमें छोटी प्रेस का पता लगाने में मदद करेगा। सभी लंबी प्रेस के लिए

package com.example.demo; 

import android.app.Activity; 
import android.os.Bundle; 
import android.util.Log; 
import android.view.KeyEvent; 
import android.view.Menu; 

public class TestVolumeActivity extends Activity { 
    boolean flag = false; 

    boolean flag2 = false; 

    @Override 
    public void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.activity_splash_screen); 
    } 

    @Override 
    public boolean onCreateOptionsMenu(Menu menu) { 
     getMenuInflater().inflate(R.menu.activity_splash_screen, menu); 
     return true; 
    } 

    @Override 
    public boolean onKeyLongPress(int keyCode, KeyEvent event) { 
     if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) { 
      Log.d("Test", "Long press!"); 
      flag = false; 
      flag2 = true; 
      return true; 
     } 
     return super.onKeyLongPress(keyCode, event); 
    } 

    @Override 
    public boolean onKeyDown(int keyCode, KeyEvent event) { 
     if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) { 
      event.startTracking(); 
      if (flag2 == true) { 
       flag = false; 
      } else { 
       flag = true; 
       flag2 = false; 
      } 

      return true; 
     } 
     return super.onKeyDown(keyCode, event); 
    } 

    @Override 
    public boolean onKeyUp(int keyCode, KeyEvent event) { 
     if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) { 

      event.startTracking(); 
      if (flag) { 
       Log.d("Test", "Short"); 
      } 
      flag = true; 
      flag2 = false; 
      return true; 
     } 

     return super.onKeyUp(keyCode, event); 
    } 
} 

Logcat (कोई कम प्रेस का पता चला): सभी छोटे प्रेस के लिए

10-18 02:06:15.369: D/Test(16834): Long press! 
10-18 02:06:18.683: D/Test(16834): Long press! 
10-18 02:06:21.566: D/Test(16834): Long press! 
10-18 02:06:23.738: D/Test(16834): Long press! 

Logcat:

10-18 02:07:42.422: D/Test(16834): Short 
10-18 02:07:43.203: D/Test(16834): Short 
10-18 02:07:43.663: D/Test(16834): Short 
10-18 02:07:44.144: D/Test(16834): Short 

Answer 2

मैं अगर यह उत्तर आपकी समस्या का एक स्वीकार्य समाधान प्रदान करेगा पता नहीं है, एक निरंतर आधार पर लगातारKeyDown घटनाओं में हो रही पर निर्भर करता है के रूप में यह है।

आप सिस्टम का समय याद है जब पिछले KeyDown घटना फेंक दिया जाता है की कोशिश कर सकते (मैं इसे tLast नाम होगा), और सभी KeyDown घटनाओं की अनदेखी जब तक आप एक KeyLongPressed घटना मिलता है।

आदेश "सही" KeyDown घटनाओं (जिन्हें आप पिछले चरण में नजरअंदाज कर दिया) पाने के लिए, आप एक धागा पता चल सके कि मौजूदा सिस्टम का समय और tLast के बीच समय अंतर (मैं इसे नाम करेंगे tDelta) हो सकता था इतना बड़ा है कि एक निरंतर प्रेस नहीं माना जाता है।

यह देखते हुए कि KeyDown घटनाओं का एक बहुत समय की एक छोटी सी अवधि में फेंक दिया जाता है, आप सैद्धांतिक रूप से यह समझ सकते हैं वॉल्यूम बटन (tDelta एक निश्चित मूल्य से अधिक है) जब घटनाओं पर्याप्त स्थान दिया गया है लगातार दबाया नहीं किया गया था।

कम आ रहा है इस समाधान का है कि, उपयोगकर्ता वॉल्यूम बटन वास्तव में तेजी से (प्रेस के बीच tDelta एक सतत प्रेस का मूल्यांकन किया निश्चित मूल्य से कम है) प्रेस अगर, कई कुंजी दबाव नजरअंदाज कर दिया जाएगा/माना जाता है एक सतत कुंजी प्रेस के रूप में।

एक और (मामूली) लघु-आने वाला यह है कि नियमित कुंजी प्रेस की व्याख्या करने से पहले देरी होगी, क्योंकि tDelta को नियमित या निरंतर कुंजी प्रेस से निपटने के दौरान मूल्यांकन किए गए निश्चित मूल्य से अधिक होना होगा ।

सादर,

लुसियान

संपादित करें: हम्म ... दूसरी सोचा: यदि आप एक KeyListener एंड्रॉयड कार्यान्वयन का उपयोग नहीं कर रहे हैं?

यदि आप इसका उपयोग कर रहे हैं, तो इसके लिए परिभाषित onKeyUp विधि देखें।

मुझे लगता है कि अगर आप इस कक्षा (या इसके व्युत्पन्न कक्षाओं में से एक) का विस्तार करेंगे तोविधि का उपयोग यह निर्धारित करने के लिए करें कि आप निरंतर प्रेस से निपट रहे हैं (यानी बटन का समय हो रहा है या नहीं) एक निश्चित मूल्य से अधिक है)।

यदि आप इस विधि का उपयोग कर सकते हैं, तो कृपया इसे करें। यह ऊपर प्रस्तुत किए गए कार्य-आसपास की तुलना में अधिक कुशल, बनाए रखने में आसान और अधिक सरल है।

KeyListener Javadoc

Answer 3

जब मैं के बारे में पोस्ट करने के लिए था मेरी जवाब मैंने पाया कि किसी को पहले से ही किसी तरह का समाधान मिला है ....

लेकिन यहां मेरा, सरल और एक आकर्षण की तरह काम करता है। सिर्फ एक झंडा;)

यह कोड शॉर्टप्रेस और लम्बे समय का पता लगाता है, जब एक लम्बाई होती है तो कोई शॉर्टप्रेस नहीं निकाल दिया जाएगा!

नोट: आप सामान्य ऊपर मात्रा और नीचे व्यवहार इस तरह onKeyPress विधि में वापसी सच सुपर कॉल करने के लिए बदल चाहते हैं:

private boolean shortPress = false; 

@Override 
public boolean onKeyLongPress(int keyCode, KeyEvent event) { 
    if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) { 
     shortPress = false; 
     Toast.makeText(this, "longPress", Toast.LENGTH_LONG).show(); 
     return true; 
    } 
    //Just return false because the super call does always the same (returning false) 
    return false; 
} 

@Override 
public boolean onKeyDown(int keyCode, KeyEvent event) { 
    if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) { 
     if(event.getAction() == KeyEvent.ACTION_DOWN){ 
      event.startTracking(); 
      if(event.getRepeatCount() == 0){ 
       shortPress = true; 
      } 
      return true; 
     } 
    } 
    return super.onKeyDown(keyCode, event); 
} 

@Override 
public boolean onKeyUp(int keyCode, KeyEvent event) { 
    if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) { 
     if(shortPress){ 
      Toast.makeText(this, "shortPress", Toast.LENGTH_LONG).show(); 
     } else { 
      //Don't handle longpress here, because the user will have to get his finger back up first 
     } 
     shortPress = false; 
     return true; 
    } 
    return super.onKeyUp(keyCode, event); 
} 

: सुपर कॉल बिना

event.startTracking(); 
if(event.getRepeatCount() == 0){ 
    shortPress = true; 
} 
//return true; 
return super.onKeyDown(keyCode, event); 

कोड

कोड यहाँ नीचे मात्रा कुंजी जोड़ा, बस अपने पक्ष लेने के साथ है;)

private boolean shortPress = false; 

@Override 
public boolean onKeyLongPress(int keyCode, KeyEvent event) { 
    if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) { 
     shortPress = false; 
     Toast.makeText(this, "longPress Volume Down", Toast.LENGTH_LONG).show(); 
     return true; 
    } else if(keyCode == KeyEvent.KEYCODE_VOLUME_UP){ 
     shortPress = false; 
     Toast.makeText(this, "longPress Volume Up", Toast.LENGTH_LONG).show(); 
     return true; 
    } 
    //Just return false because the super call does always the same (returning false) 
    return false; 
} 

@Override 
public boolean onKeyDown(int keyCode, KeyEvent event) { 
    if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN || keyCode == KeyEvent.KEYCODE_VOLUME_UP) { 
     if(event.getAction() == KeyEvent.ACTION_DOWN){ 
      event.startTracking(); 
      if(event.getRepeatCount() == 0){ 
       shortPress = true; 
      } 
      return true; 
     } 
    } 
    return super.onKeyDown(keyCode, event); 
} 

@Override 
public boolean onKeyUp(int keyCode, KeyEvent event) { 
    if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) { 
     if(shortPress){ 
      Toast.makeText(this, "shortPress Volume Down", Toast.LENGTH_LONG).show(); 
     } else { 
      //Don't handle longpress here, because the user will have to get his finger back up first 
     } 
     shortPress = false; 
     return true; 
    } else if(keyCode == KeyEvent.KEYCODE_VOLUME_UP){ 
     if(shortPress){ 
      Toast.makeText(this, "shortPress Volume up", Toast.LENGTH_LONG).show(); 
     } else { 
      //Don't handle longpress here, because the user will have to get his finger back up first 
     } 
     shortPress = false; 
     return true; 

    } 
    return super.onKeyUp(keyCode, event); 
} 

Answer 4

लंबे बटन प्रेस को संभालने के लिए एसडीके के अनुसार सही तरीका।

import android.app.Activity; 
import android.util.Log; 
import android.view.KeyEvent; 


public class TestVolumeActivity extends Activity 
{ 
    private static final String TAG = TestVolumeActivity.class.getSimpleName(); 

    @Override 
    public boolean onKeyDown(int keyCode, KeyEvent event) { 
     if(keyCode == KeyEvent.KEYCODE_VOLUME_UP || 
      keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) 
     { 
      event.startTracking(); 
      return true; 
     } 
     return super.onKeyDown(keyCode, event); 
    } 

    @Override 
    public boolean onKeyLongPress(int keyCode, KeyEvent event) 
    { 
     if(keyCode == KeyEvent.KEYCODE_VOLUME_UP){ 
      Log.d(TAG, "Long press KEYCODE_VOLUME_UP"); 
      return true; 
     } 
     else if(keyCode == KeyEvent.KEYCODE_VOLUME_DOWN){ 
      Log.d(TAG, "Long press KEYCODE_VOLUME_DOWN"); 
      return true; 
     } 
     return super.onKeyLongPress(keyCode, event); 
    } 

    @Override 
    public boolean onKeyUp(int keyCode, KeyEvent event) 
    { 
     if((event.getFlags() & KeyEvent.FLAG_CANCELED_LONG_PRESS) == 0){ 
      if(keyCode == KeyEvent.KEYCODE_VOLUME_UP){ 
       Log.e(TAG, "Short press KEYCODE_VOLUME_UP"); 
       return true; 
      } 
      else if(keyCode == KeyEvent.KEYCODE_VOLUME_DOWN){ 
       Log.e(TAG, "Short press KEYCODE_VOLUME_DOWN"); 
       return true; 
      } 
     } 
     return super.onKeyUp(keyCode, event); 
    } 
}