दिलचस्प पोस्ट
मावेन 3.3.1 ईसीएलआईपीएसई: -डमेन। मल्टीमीडिया प्रोजेक्ट डायरेक्टरी सिस्टम प्रोपरीरी सेट नहीं है एचटीटीपी के साथ काम नहीं कर रहा PHP कर्ल वॉली के रेश्पेन्स पर समारोह से मैं मूल्य कैसे वापस कर सकता हूं? एंड्रॉइड – कस्टम विशेषताओं के साथ कस्टम यूआई सीज़े शैली विशेषता गतिशील रूप से कोणीय जेएस में लागू करें जावा 8: दो स्थानीय डेटटाइम के बीच अंतर की गणना करें ल्यूसीन का उपयोग करके सटीक वाक्यांश खोज? आप एचटीएमएल 5 फॉर्म सत्यापन संदेश कैसे शैली करते हैं? कैसे जाँचने के लिए कि एक स्ट्रिंग एक डबल करने के लिए parseable है? क्रॉस डोमेन एजेक्स अनुरोध को सक्षम करने के लिए फ़ायरफ़ॉक्स सेटिंग एनोटेशन का उपयोग करके कक्षा के एक विशेषता मान से XML तत्व नाम कैसे प्राप्त करना है? मल्टी प्रसंस्करण और डिल एक साथ क्या कर सकते हैं? एंड्रॉइड के लिए चेकबॉक्स के लिए चेक और अनचेक किए गए आइकन बदलें तालिका के पंक्ति के अंदर पेज ब्रेक से बचें समूह द्वारा पहले MySQL आदेश

एंड्रॉइड डिवाइस पर सॉफ़्टवेयर कीबोर्ड दृश्यमान है, तो मैं यह कैसे पता लगाऊँ?

क्या Android (एंड्रॉइड) में यह पता लगाने में कोई तरीका है कि सॉफ्टवेयर (उर्फ "सॉफ्ट") कीबोर्ड स्क्रीन पर दिखाई दे रहा है या नहीं?

Solutions Collecting From Web of "एंड्रॉइड डिवाइस पर सॉफ़्टवेयर कीबोर्ड दृश्यमान है, तो मैं यह कैसे पता लगाऊँ?"

कोई सीधा रास्ता नहीं है – http://groups.google.com/group/android-platform/browse_thread/thread/1728f26f2334c060/5e4910f0d9eb898a देखें जहां एंड्रॉइड टीम से डियान हैकबॉर्न ने उत्तर दिया है। हालांकि, आप यह जांचकर अप्रत्यक्ष रूप से पता लगा सकते हैं कि विंडो आकार #onMeasure में बदल गया है या नहीं। एंड्रॉइड में सॉफ्टवेयर कीबोर्ड की दृश्यता को कैसे देखें ? ।

यह मेरे लिए काम करता है शायद यह हमेशा सभी संस्करणों के लिए सबसे अच्छा तरीका है

contentView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() { @Override public void onGlobalLayout() { Rect r = new Rect(); contentView.getWindowVisibleDisplayFrame(r); int screenHeight = contentView.getRootView().getHeight(); // r.bottom is the position above soft keypad or device button. // if keypad is shown, the r.bottom is smaller than that before. int keypadHeight = screenHeight - r.bottom; Log.d(TAG, "keypadHeight = " + keypadHeight); if (keypadHeight > screenHeight * 0.15) { // 0.15 ratio is perhaps enough to determine keypad height. // keyboard is opened } else { // keyboard is closed } } }); 

इसे इस्तेमाल करे:

 InputMethodManager imm = (InputMethodManager) getActivity() .getSystemService(Context.INPUT_METHOD_SERVICE); if (imm.isAcceptingText()) { writeToLog("Software Keyboard was shown"); } else { writeToLog("Software Keyboard was not shown"); } 

मैंने एक साधारण वर्ग बनाया है जिसका उपयोग इसके लिए किया जा सकता है: https://github.com/ravindu1024/android-keyboardlistener बस इसे अपने प्रोजेक्ट में कॉपी करें और निम्नानुसार उपयोग करें:

 KeyboardUtils.addKeyboardToggleListener(this, new KeyboardUtils.SoftKeyboardToggleListener() { @Override public void onToggleSoftKeyboard(boolean isVisible) { Log.d("keyboard", "keyboard visible: "+isVisible); } }); 

बहुत आसान

1. अपने रूट व्यू पर आईडी डालें

rootView सिर्फ इस दृश्य में मेरे मूल दृश्य की ओर इशारा करते हुए एक दृश्य है जो एक relative layout :

 <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent" android:id="@+id/addresses_confirm_root_view" android:background="@color/WHITE_CLR"> 

2. अपनी गतिविधि में अपना मूल दृश्य प्रारंभ करें:

RelativeLayout rootView = (RelativeLayout) findViewById(R.id.addresses_confirm_root_view); 3. getViewTreeObserver() का उपयोग करके कीबोर्ड को खोला या बंद किया गया है, यह पता लगाएं

  rootView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() { @Override public void onGlobalLayout() { int heightDiff = rootView.getRootView().getHeight() - rootView.getHeight(); if (heightDiff > 100) { Log.e("MyActivity", "keyboard opened"); } else { Log.e("MyActivity", "keyboard closed"); } } }); 

आप इस उत्तर का संदर्भ लें – https://stackoverflow.com/a/24105062/3629912

यह मेरे लिए हर समय काम किया

 adb shell dumpsys window InputMethod | grep "mHasSurface" 

यह सच हो जाएगा, अगर सॉफ्टवेयर कीबोर्ड दिखाई दे रहा है

आप showSoftInput () के कॉलबैक परिणाम का उपयोग कर सकते हैं और कीबोर्ड की स्थिति की जांच करने के लिए सोफ्ट इन्पुट () को छिपा सकते हैं। पूर्ण विवरण और उदाहरण कोड में

http://www.ninthavenue.com.au/how-to-check-if-the-software-keyboard-is-shown-in-android

मैंने इसे एक आधार के रूप में इस्तेमाल किया: http://www.ninthavenue.com.au/how-to-check-if-the-software-keyboard-is-shown-in-android

 /** * To capture the result of IMM hide/show soft keyboard */ public class IMMResult extends ResultReceiver { public int result = -1; public IMMResult() { super(null); } @Override public void onReceiveResult(int r, Bundle data) { result = r; } // poll result value for up to 500 milliseconds public int getResult() { try { int sleep = 0; while (result == -1 && sleep < 500) { Thread.sleep(100); sleep += 100; } } catch (InterruptedException e) { Log.e("IMMResult", e.getMessage()); } return result; } } 

फिर इस विधि को लिखा है:

 public boolean isSoftKeyboardShown(InputMethodManager imm, View v) { IMMResult result = new IMMResult(); int res; imm.showSoftInput(v, 0, result); // if keyboard doesn't change, handle the keypress res = result.getResult(); if (res == InputMethodManager.RESULT_UNCHANGED_SHOWN || res == InputMethodManager.RESULT_UNCHANGED_HIDDEN) { return true; } else return false; } 

फिर आप इसका उपयोग सभी क्षेत्रों (संपादन टेक्स्ट, स्वत: पूर्ण पाठव्यू, आदि) का परीक्षण करने के लिए कर सकते हैं, जो कि एक सॉफ्ट कीबोर्ड खोल सकते हैं:

  InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE); if(isSoftKeyboardShown(imm, editText1) | isSoftKeyboardShown(imm, autocompletetextview1)) //close the softkeyboard imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0); 

बढ़िया नहीं एक आदर्श समाधान, लेकिन यह काम किया जाता है

यह कोड वास्तव में काम कर रहा है अगर कीबोर्डशॉन्शन दिखाया गया है तो यह फ़ंक्शन रिटर्न सही मान ….

 private final String TAG = "TextEditor"; private TextView mTextEditor; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_editor); mTextEditor = (TextView) findViewById(R.id.text_editor); mTextEditor.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() { @Override public void onGlobalLayout() { isKeyboardShown(mTextEditor.getRootView()); } }); } private boolean isKeyboardShown(View rootView) { /* 128dp = 32dp * 4, minimum button height 32dp and generic 4 rows soft keyboard */ final int SOFT_KEYBOARD_HEIGHT_DP_THRESHOLD = 128; Rect r = new Rect(); rootView.getWindowVisibleDisplayFrame(r); DisplayMetrics dm = rootView.getResources().getDisplayMetrics(); /* heightDiff = rootView height - status bar height (r.top) - visible frame height (r.bottom - r.top) */ int heightDiff = rootView.getBottom() - r.bottom; /* Threshold size: dp to pixels, multiply with display density */ boolean isKeyboardShown = heightDiff > SOFT_KEYBOARD_HEIGHT_DP_THRESHOLD * dm.density; Log.d(TAG, "isKeyboardShown ? " + isKeyboardShown + ", heightDiff:" + heightDiff + ", density:" + dm.density + "root view height:" + rootView.getHeight() + ", rect:" + r); return isKeyboardShown; } 

मेरे मामले में मेरे लेआउट में प्रबंधन करने के लिए मेरे पास केवल एक ही EditText था, इसलिए मैं इस समाधान को EditText करने आया। यह अच्छी तरह से काम करता है, मूल रूप से यह एक कस्टम EditText जो फोकस के लिए सुनता है और एक स्थानीय प्रसारण भेजता है यदि फ़ोकस बदल जाता है या यदि बैक / ग्रीन बटन दबाया जाता है। android:focusable="true" साथ अपने लेआउट में एक डमी को View की आवश्यकता है android:focusable="true" और android:focusableInTouchMode="true" clearFocus() android:focusableInTouchMode="true" क्योंकि जब आप clearFocus() को कॉल करते हैं, तो फ़ोकस पहले फ़ोकसएबल व्यू में फिर से नियत किया जाएगा। डमी दृश्य का उदाहरण:

 <View android:layout_width="1dp" android:layout_height="1dp" android:focusable="true" android:focusableInTouchMode="true"/> 

अतिरिक्त इंफोस

समाधान जो लेआउट परिवर्तनों में अंतर का पता लगाता है बहुत अच्छा काम नहीं करता है क्योंकि यह दृढ़ता से स्क्रीन घनत्व पर निर्भर करता है, क्योंकि 100px एक निश्चित डिवाइस में बहुत कुछ हो सकता है और कुछ अन्य में कुछ भी आप झूठी सकारात्मक प्राप्त कर सकते हैं। इसके अलावा अलग-अलग विक्रेताओं में अलग-अलग कीबोर्ड हैं

मुझे जरूरत के लिए यह बहुत कम जटिल था उम्मीद है कि यह मदद कर सकता है:

मुख्य गतिविधि पर:

 public void dismissKeyboard(){ InputMethodManager imm =(InputMethodManager)this.getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(mSearchBox.getWindowToken(), 0); mKeyboardStatus = false; } public void showKeyboard(){ InputMethodManager imm =(InputMethodManager)this.getSystemService(Context.INPUT_METHOD_SERVICE); imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, InputMethodManager.HIDE_IMPLICIT_ONLY); mKeyboardStatus = true; } private boolean isKeyboardActive(){ return mKeyboardStatus; } 

MKeyboardStatus के लिए मूलभूत मूलभूत बूलियन मान को गलत रूप से आरंभ किया जाएगा।

इसके बाद मान की जांच करें, और यदि आवश्यक हो तो कोई क्रिया करें:

  mSearchBox.requestFocus(); if(!isKeyboardActive()){ showKeyboard(); }else{ dismissKeyboard(); } 

मुझे भी ऐसी ही समस्या का समाधान करना पड़ा था। मुझे स्क्रीन पर एन्टर बटन पर प्रतिक्रिया करने की आवश्यकता थी (जो कीबोर्ड को छुपाता था)। इस मामले में आप पाठ के ऑनइडिटेटर एक्शन की सदस्यता ले सकते हैं, जिसका उपयोग कीबोर्ड के साथ किया गया था – यदि आपके पास कई संपादन योग्य बॉक्स हैं, तो उन सभी को सदस्यता लें।

आपकी गतिविधि में आपके पास कुंजीपटल का पूर्ण नियंत्रण है, इसलिए आपको कोई समस्या नहीं होगी कि कीबोर्ड खोल दी गई है या नहीं, अगर आप सभी खोलने और बंद होने वाले घटनाओं को सुनते हैं

मैंने इसे GlobalLayoutListener सेट करके किया, इस प्रकार है:

 final View activityRootView = findViewById(R.id.activityRoot); activityRootView.getViewTreeObserver().addOnGlobalLayoutListener( new OnGlobalLayoutListener() { @Override public void onGlobalLayout() { int heightView = activityRootView.getHeight(); int widthView = activityRootView.getWidth(); if (1.0 * widthView / heightView > 3) { //Make changes for Keyboard not visible } else { //Make changes for keyboard visible } } }); 

यह पता लगाने के लिए एक सीधा तरीका है और, लेआउट परिवर्तनों की आवश्यकता नहीं है।
तो यह इमर्सिव फ़ुलस्क्रीन मोड में भी काम करता है I
लेकिन दुर्भाग्य से, यह सभी उपकरणों पर काम नहीं करता है। तो आपको इसे अपने डिवाइस (उपकरणों) के साथ परीक्षण करना होगा

चाल यह है कि आप को छिपाना या नरम कीबोर्ड दिखाने की कोशिश करते हैं और उस कोशिश के परिणाम पर कब्जा करते हैं।
यदि यह सही काम करता है तो कुंजीपटल वास्तव में दिखाई नहीं दे रही है या छुपा नहीं है हम सिर्फ राज्य के लिए पूछें

अप-टू-डेट रहने के लिए, आप इस ऑपरेशन को दोहराएं, जैसे कि हर 200 मिलीसेकेंड, हेन्डलर का उपयोग करते हुए।

नीचे कार्यान्वयन केवल एक जांच करता है।
यदि आप एकाधिक चेक करते हैं, तो आपको सभी (_keyboardVisible) परीक्षणों को सक्षम करना चाहिए।

 public interface OnKeyboardShowHide { void onShowKeyboard( Object param ); void onHideKeyboard( Object param ); } private static Handler _keyboardHandler = new Handler(); private boolean _keyboardVisible = false; private OnKeyboardShowHide _keyboardCallback; private Object _keyboardCallbackParam; public void start( OnKeyboardShowHide callback, Object callbackParam ) { _keyboardCallback = callback; _keyboardCallbackParam = callbackParam; // View view = getCurrentFocus(); if (view != null) { InputMethodManager imm = (InputMethodManager) getSystemService( Activity.INPUT_METHOD_SERVICE ); imm.hideSoftInputFromWindow( view.getWindowToken(), InputMethodManager.HIDE_IMPLICIT_ONLY, _keyboardResultReceiver ); imm.showSoftInput( view, InputMethodManager.SHOW_IMPLICIT, _keyboardResultReceiver ); } else // if (_keyboardVisible) { _keyboardVisible = false; _keyboardCallback.onHideKeyboard( _keyboardCallbackParam ); } } private ResultReceiver _keyboardResultReceiver = new ResultReceiver( _keyboardHandler ) { @Override protected void onReceiveResult( int resultCode, Bundle resultData ) { switch (resultCode) { case InputMethodManager.RESULT_SHOWN : case InputMethodManager.RESULT_UNCHANGED_SHOWN : // if (!_keyboardVisible) { _keyboardVisible = true; _keyboardCallback.onShowKeyboard( _keyboardCallbackParam ); } break; case InputMethodManager.RESULT_HIDDEN : case InputMethodManager.RESULT_UNCHANGED_HIDDEN : // if (_keyboardVisible) { _keyboardVisible = false; _keyboardCallback.onHideKeyboard( _keyboardCallbackParam ); } break; } } }; 

एंड्रॉइड में आप एडीबी खोल के माध्यम से पता लगा सकते हैं मैंने लिखा और इस पद्धति का उपयोग किया है:

 { JSch jsch = new JSch(); try { Session session = jsch.getSession("<userName>", "<IP>", 22); session.setPassword("<Password>"); Properties config = new Properties(); config.put("StrictHostKeyChecking", "no"); session.setConfig(config); session.connect(); ChannelExec channel = (ChannelExec)session.openChannel("exec"); BufferedReader in = new BufferedReader(new InputStreamReader(channel.getInputStream())); channel.setCommand("C:/Android/android-sdk/platform-tools/adb shell dumpsys window InputMethod | findstr \"mHasSurface\""); channel.connect(); String msg = null; String msg2 = " mHasSurface=true"; while ((msg = in.readLine()) != null) { Boolean isContain = msg.contains(msg2); log.info(isContain); if (isContain){ log.info("Hiding keyboard..."); driver.hideKeyboard(); } else { log.info("No need to hide keyboard."); } } channel.disconnect(); session.disconnect(); } catch (JSchException | IOException | InterruptedException e) { e.printStackTrace(); } } } 

यह जानने के लिए एक वैकल्पिक उपाय है कि क्या सॉफ्ट कीबोर्ड दिखाई दे रहा है

  1. ActivityManager.getRunningServices (max_count_of_services) का उपयोग कर सिस्टम पर सेवाएं चलाने के लिए जांचें;
  2. लौटे हुए गतिविधि प्रबंधक से। RunningServiceInfo उदाहरणों, मुलायम कीबोर्ड सेवा के लिए ग्राहक मूल्य की जांच करें।
  3. उपर्युक्त ग्राहक संख्या हर बार बढ़ी जाएगी, नरम कीबोर्ड दिखाया गया है। उदाहरण के लिए, यदि क्लाइंटकाउंट प्रारंभ में 1 था, तो यह 2 होगा जब कीबोर्ड दिखाई देगा।
  4. कुंजीपटल बर्खास्तगी पर, ग्राहक गणना कम हो गई है। इस मामले में, यह 1 पर रीसेट हो जाता है

कुछ लोकप्रिय कीबोर्डों में उनके क्लासेस नामों में कुछ कीवर्ड होते हैं:

  1. Google AOSP = IME
  2. Swype = IME
  3. स्विफ्टकी = कीबोर्डसेवा
  4. फ्लेक्सी = कीबोर्ड
  5. एडाप्टेक्ट = आईएमई (केपीटीएएडीपीटीटीएमईई)
  6. स्मार्ट = कीबोर्ड (स्मार्टकीबोर्ड)

ActivityManager.RunningServiceInfo से, क्लासनामों में उपरोक्त पैटर्न की जांच करें इसके अलावा, ActivityManager.RunningServiceInfo के ग्राहक पैकेज = एंड्रॉइड, यह दर्शाता है कि कीबोर्ड सिस्टम के लिए बाध्य है।

नरम कीबोर्ड दिखाई दे रहा है या नहीं, यह जानने के लिए उपर्युक्त जानकारी को सख्त तरीके से जोड़ा जा सकता है।

@ आईवन्तस्काला का जवाब महान है परन्तु मेरे लिए काम नहीं कर रहा है
rootView.getRootView().getHeight() हमेशा एक ही मूल्य है

एक तरीका दो वार्स को परिभाषित करना है

 private int maxRootViewHeight = 0; private int currentRootViewHeight = 0; 

वैश्विक श्रोता जोड़ें

 rootView.getViewTreeObserver() .addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() { @Override public void onGlobalLayout() { currentRootViewHeight = rootView.getHeight(); if (currentRootViewHeight > maxRootViewHeight) { maxRootViewHeight = currentRootViewHeight; } } }); 

तो जाँच

 if (currentRootViewHeight >= maxRootViewHeight) { // Keyboard is hidden } else { // Keyboard is shown } 

ठीक काम करता है

मैंने ऐसा किया, इस प्रकार है, लेकिन इसकी relevet केवल अगर आपका लक्ष्य बंद करने / keyboad खोलने के लिए है

करीब उदाहरण: (यदि पहले से ही बंद कर दिया गया है, तो नहीं बंद होने पर)

 imm.showSoftInput(etSearch, InputMethodManager.HIDE_IMPLICIT_ONLY, new ResultReceiver(null) { @Override protected void onReceiveResult(int resultCode, Bundle resultData) { super.onReceiveResult(resultCode, resultData); if (resultCode != InputMethodManager.RESULT_UNCHANGED_HIDDEN) imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0); } }); 
 final View activityRootView = findViewById(R.id.rootlayout); activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() { @Override public void onGlobalLayout() { Rect r = new Rect(); activityRootView.getWindowVisibleDisplayFrame(r); int screenHeight = activityRootView.getRootView().getHeight(); Log.e("screenHeight", String.valueOf(screenHeight)); int heightDiff = screenHeight - (r.bottom - r.top); Log.e("heightDiff", String.valueOf(heightDiff)); boolean visible = heightDiff > screenHeight / 3; Log.e("visible", String.valueOf(visible)); if (visible) { Toast.makeText(LabRegister.this, "I am here 1", Toast.LENGTH_SHORT).show(); } else { Toast.makeText(LabRegister.this, "I am here 2", Toast.LENGTH_SHORT).show(); } } }); 

एक का उपयोग हो सकता है:

 @Override public void onConfigurationChanged(Configuration newConfig) { super.onConfigurationChanged(newConfig); Log.d( getClass().getSimpleName(), String.format("conf: %s", newConfig)); if (newConfig.hardKeyboardHidden != hardKeyboardHidden) { onHardwareKeyboardChange(newConfig.hardKeyboardHidden); hardKeyboardHidden = newConfig.hardKeyboardHidden; } if (newConfig.keyboardHidden != keyboardHidden) { onKeyboardChange(newConfig.keyboardHidden); keyboardHidden = newConfig.hardKeyboardHidden; } } public static final int KEYBOARDHIDDEN_UNDEFINED = 0; public static final int KEYBOARDHIDDEN_NO = 1; public static final int KEYBOARDHIDDEN_YES = 2; public static final int KEYBOARDHIDDEN_SOFT = 3; //todo private void onKeyboardChange(int keyboardHidden) { } //todo private void onHardwareKeyboardChange(int hardKeyboardHidden) { } 

मेरा सबसे अच्छा अनुभव मेरे खुद के कीबोर्ड बनाने के लिए किया गया था