android - एंड्रॉइड सॉफ्ट कीबोर्ड को बंद/छुपाएं



android-layout android-softkeyboard (20)

मेरे पास मेरे लेआउट में एक EditText और एक Button है।

संपादन क्षेत्र में लिखने और Button पर क्लिक करने के बाद, मैं वर्चुअल कीबोर्ड को छिपाना चाहता हूं। मुझे लगता है कि यह कोड का एक साधारण टुकड़ा है, लेकिन मुझे इसका उदाहरण कहां मिल सकता है?

https://code.i-harness.com


संक्षिप्त जवाब

अपने onEditorAction श्रोता में onEditorAction के साथ EditText के IME_ACTION_DONE onEditorAction पर कॉल करें

button.setOnClickListener(new OnClickListener() {

    @Override
    public void onClick(View v) {
        someEditText.onEditorAction(EditorInfo.IME_ACTION_DONE)
    }
});

ड्रिल-डाउन

मुझे लगता है कि एंड्रॉइड के डिजाइन पैटर्न के साथ यह विधि बेहतर, सरल और अधिक गठबंधन है। उपरोक्त सरल उदाहरण (और आमतौर पर अधिकांश सामान्य मामलों में) में आपके पास एक EditText जिसमें फोकस होता है और यह आमतौर पर कुंजीपटल को पहली बार आमंत्रित करने वाला होता है (यह निश्चित रूप से इसे आमंत्रित करने में सक्षम है कई आम परिदृश्य)। इसी तरह, यह कीबोर्ड को रिलीज़ करने वाला एक होना चाहिए, आमतौर पर एक ImeAction द्वारा किया जा सकता है। बस देखें कि android:imeOptions="actionDone" साथ android:imeOptions="actionDone" व्यवहार करता है, आप उसी व्यवहार से वही व्यवहार प्राप्त करना चाहते हैं।

इस संबंधित उत्तर की जांच करें


आप एंड्रॉइड को hideSoftInputFromWindow कीबोर्ड को छिपाने के लिए वर्चुअल कीबोर्ड को छिपाने के लिए मजबूर कर सकते हैं, जो आपके केंद्रित दृश्य वाले विंडो के टोकन में गुजरने वाले hideSoftInputFromWindow कॉल कर रहा है।

// Check if no view has focus:
View view = this.getCurrentFocus();
if (view != null) {  
    InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}

यह कीबोर्ड को सभी परिस्थितियों में छिपाने के लिए मजबूर करेगा। कुछ मामलों में आप InputMethodManager.HIDE_IMPLICIT_ONLY को दूसरे पैरामीटर के रूप में पास करना चाहते हैं ताकि आप यह सुनिश्चित कर सकें कि जब आप उपयोगकर्ता इसे स्पष्ट रूप से प्रकट करने के लिए मजबूर नहीं करते हैं (मेनू को दबाकर) कीबोर्ड को छुपाएं।

नोट: यदि आप context?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager में ऐसा करना चाहते हैं, तो इसका उपयोग करें: context?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager


इस पागलपन को स्पष्ट करने में मदद के लिए, मैं सॉफ्ट एंड्रॉइड के Google के निचले हास्यास्पद उपचार के लिए सभी एंड्रॉइड उपयोगकर्ताओं की तरफ से माफ़ी मांगना शुरू करना चाहता हूं। एक ही सरल सवाल के लिए, प्रत्येक अलग-अलग उत्तर हैं, क्योंकि अलग-अलग कारण यह है कि एंड्रॉइड में कई अन्य लोगों की तरह यह एपीआई बेहद डिज़ाइन किया गया है। मैं इसे बताने के लिए कोई विनम्र तरीका नहीं सोच सकता।

मैं कीबोर्ड को छिपाना चाहता हूं। मैं निम्नलिखित कथन के साथ एंड्रॉइड प्रदान करने की उम्मीद करता हूं: Keyboard.hide() । समाप्त। आपका बहुत बहुत धन्यवाद। लेकिन एंड्रॉइड में एक समस्या है। कीबोर्ड को छुपाने के लिए आपको InputMethodManager का उपयोग करना होगा। ठीक है, ठीक है, यह कीबोर्ड के लिए एंड्रॉइड एपीआई है। परंतु! आईएमएम तक पहुंच प्राप्त करने के लिए आपको एक Context होना आवश्यक है। अब हमें एक समस्या है। मैं कुंजीपटल को एक स्थैतिक या उपयोगिता वर्ग से छिपाना चाहता हूं जिसका कोई उपयोग या किसी Context लिए आवश्यकता नहीं है। या एफएआर खराब है, आईएमएम की आवश्यकता है कि आप निर्दिष्ट करें (या इससे भी बदतर, क्या Window ) आप कुंजीपटल से छिपाना चाहते हैं।

यह कुंजीपटल को इतना चुनौतीपूर्ण छुपाता है। प्रिय Google: जब मैं एक केक के लिए नुस्खा देख रहा हूं, वहां पृथ्वी पर कोई पकाने की विधि नहीं है जो मुझे नुस्खा प्रदान करने से इनकार कर देगी जब तक कि मैं पहली बार डब्ल्यूएचओ का जवाब नहीं दूंगा और जहां इसे खाया जाएगा !!

यह दुखद कहानी बदसूरत सच्चाई के साथ समाप्त होती है: एंड्रॉइड कीबोर्ड को छिपाने के लिए, आपको पहचान के 2 रूप प्रदान करने होंगे: एक Context और या तो एक View या Window

मैंने एक स्थिर उपयोगिता विधि बनाई है जो बहुत ही कठिन काम कर सकती है, बशर्ते आप इसे एक Activity से बुलाएं।

public static void hideKeyboard(Activity activity) {
    InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
    //Find the currently focused view, so we can grab the correct window token from it.
    View view = activity.getCurrentFocus();
    //If no view currently has focus, create a new one, just so we can grab a window token from it
    if (view == null) {
        view = new View(activity);
    }
    imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}

ध्यान रखें कि इस उपयोगिता विधि केवल Activity से बुलाए जाने पर ही काम करती है! उपर्युक्त विधि कॉल उचित Activity टोकन लाने के लिए लक्षित Activity getCurrentFocus है।

लेकिन मान लीजिए कि आप एक DialogFragment में होस्ट किए गए DialogFragment से कीबोर्ड को छिपाना चाहते हैं? आप इसके लिए उपरोक्त विधि का उपयोग नहीं कर सकते हैं:

hideKeyboard(getActivity()); //won't work

यह काम नहीं करेगा क्योंकि आप Fragment की मेजबान Activity संदर्भ पारित करेंगे, जिसमें Fragment दिखाए जाने पर कोई ध्यान केंद्रित नहीं होगा! वाह! तो, टुकड़ों से कीबोर्ड को छिपाने के लिए, मैं निचले स्तर, अधिक आम, और उलझन का सहारा लेता हूं:

public static void hideKeyboardFrom(Context context, View view) {
    InputMethodManager imm = (InputMethodManager) context.getSystemService(Activity.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}

नीचे इस समाधान का पीछा करते हुए बर्बाद अधिक समय से कुछ अतिरिक्त जानकारी दी गई है:

WindowSoftInputMode के बारे में

इसके बारे में जागरूक होने के लिए विवाद का एक और बिंदु है। डिफ़ॉल्ट रूप से, एंड्रॉइड स्वचालित रूप से प्रारंभिक फोकस को पहले EditText या आपकी Activity में फोकस करने योग्य नियंत्रण में असाइन करेगा। यह स्वाभाविक रूप से निम्नानुसार है कि इनपुट मोड (आमतौर पर सॉफ्ट कीबोर्ड) स्वयं को दिखाकर फोकस ईवेंट का जवाब देगा। AndroidManifest.xml में windowSoftInputMode विशेषता, जब राज्य पर सेट किया जाता है stateAlwaysHidden , कीबोर्ड को स्वचालित रूप से असाइन किए गए प्रारंभिक फ़ोकस को अनदेखा करने के लिए निर्देश देता है।

<activity
    android:name=".MyActivity"
    android:windowSoftInputMode="stateAlwaysHidden"/>

लगभग अविश्वसनीय रूप से, ऐसा लगता है कि जब आप नियंत्रण को स्पर्श करते हैं तो कीबोर्ड को खोलने से रोकने के लिए कुछ भी नहीं होता है (जब तक focusable="false" और / या focusableInTouchMode="false" नियंत्रण में असाइन नहीं किया जाता है)। जाहिर है, windowSoftInputMode सेटिंग केवल स्वचालित फ़ोकस ईवेंट पर लागू होती है, न कि स्पर्श ईवेंट से ट्रिगर की गई घटनाओं पर ध्यान केंद्रित करने के लिए।

इसलिए, stateAlwaysHidden से stateAlwaysHidden है वास्तव में बहुत खराब नामित है। इसे शायद इसके बजाय ignoreInitialFocus कहा जाना चाहिए।

उम्मीद है की यह मदद करेगा।

अद्यतन: खिड़की टोकन पाने के अधिक तरीके

यदि कोई केंद्रित दृश्य नहीं है (उदाहरण के लिए यदि आप अभी टुकड़े बदल गए हैं तो हो सकता है), ऐसे अन्य विचार भी हैं जो उपयोगी विंडो टोकन की आपूर्ति करेंगे।

ये उपरोक्त कोड के विकल्प हैं if (view == null) view = new View(activity); ये आपकी गतिविधि के लिए स्पष्ट रूप से संदर्भित नहीं हैं।

एक खंड वर्ग के अंदर:

view = getView().getRootView().getWindowToken();

पैरामीटर के रूप में एक टुकड़े fragment को देखते हुए:

view = fragment.getView().getRootView().getWindowToken();

आपके सामग्री निकाय से शुरू करना:

view = findViewById(android.R.id.content).getRootView().getWindowToken();

अद्यतन 2: यदि आप पृष्ठभूमि से ऐप खोलते हैं तो कीबोर्ड को फिर से दिखाने से बचने के लिए फोकस साफ़ करें

इस लाइन को विधि के अंत में जोड़ें:

view.clearFocus();


कीबोर्ड को छुपाने के लिए मुझे एक और समाधान मिला:

InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);

यहां HIDE_IMPLICIT_ONLY की स्थिति में showFlag और 0 की स्थिति पर hiddenFlag । यह नरम कीबोर्ड को मजबूती से बंद कर देगा।


मीयर का समाधान भी मेरे लिए काम करता है। मेरे मामले में मेरी ऐप का शीर्ष स्तर एक टैब हैस्ट और मैं टैब स्विच करते समय कीवर्ड को छिपाना चाहता हूं - मुझे टैबहोस्ट व्यू से विंडो टोकन मिलता है।

tabHost.setOnTabChangedListener(new OnTabChangeListener() {
    public void onTabChanged(String tabId) {
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(tabHost.getApplicationWindowToken(), 0);
    }
}

मैं एक हेक्स नंबर इनपुट करने के लिए एक कस्टम कीबोर्ड का उपयोग कर रहा हूं, इसलिए मेरे पास आईएमएम कीबोर्ड नहीं दिख सकता है ...

V3.2.4_r1 setSoftInputShownOnFocus(boolean show) को मौसम को नियंत्रित करने के लिए जोड़ा गया था या जब टेक्स्टव्यू फोकस हो जाता है तो कुंजीपटल प्रदर्शित नहीं किया जाता था, लेकिन यह अभी भी छुपा हुआ है इसलिए प्रतिबिंब का उपयोग किया जाना चाहिए:

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
    try {
        Method method = TextView.class.getMethod("setSoftInputShownOnFocus", boolean.class);
        method.invoke(mEditText, false);
    } catch (Exception e) {
        // Fallback to the second method
    }
}

पुराने संस्करणों के लिए, मुझे एक OnGlobalLayoutListener साथ बहुत अच्छे नतीजे मिले हैं (लेकिन बहुत दूर से), मेरे रूट व्यू से ViewTreeObserver की सहायता से जोड़ा गया है और फिर जांच कर रहा है कि कीबोर्ड इस तरह दिखाया गया है या नहीं:

@Override
public void onGlobalLayout() {
    Configuration config = getResources().getConfiguration();

    // Dont allow the default keyboard to show up
    if (config.keyboardHidden != Configuration.KEYBOARDHIDDEN_YES) {
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(mRootView.getWindowToken(), 0);
    }
}

यह अंतिम समाधान कुंजीपटल दूसरे के लिए कुंजीपटल दिखा सकता है और चयन हैंडल के साथ गड़बड़ कर सकता है।

कीबोर्ड में पूर्ण स्क्रीन में प्रवेश करते समय, ग्लोबललायआउट को कॉल नहीं किया जाता है। इससे बचने के लिए, TextView#setImeOptions(int) या TextView#setImeOptions(int) एक्सएमएल घोषणा में उपयोग करें:

android:imeOptions="actionNone|actionUnspecified|flagNoFullscreen|flagNoExtractUi"

अपडेट करें: बस यह पता चला कि कीबोर्ड को कभी भी दिखाने के लिए कौन से संवाद उपयोग नहीं करते हैं और सभी संस्करणों में काम करता है:

getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
        WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);

यदि यहां दिए गए सभी अन्य उत्तर आपके लिए काम नहीं करते हैं, तो आप कीबोर्ड को मैन्युअल रूप से नियंत्रित करने का एक और तरीका है।

इसके साथ एक फ़ंक्शन बनाएं जो कुछ EditText की गुणों का प्रबंधन करेगा:

public void setEditTextFocus(boolean isFocused) {
    searchEditText.setCursorVisible(isFocused);
    searchEditText.setFocusable(isFocused);
    searchEditText.setFocusableInTouchMode(isFocused);

    if (isFocused) {
        searchEditText.requestFocus();
    }
}

फिर, सुनिश्चित करें कि संपादन टेक्स्ट के EditText आप कीबोर्ड खोलें / बंद करें:

searchEditText.setOnFocusChangeListener(new OnFocusChangeListener() {
    @Override
    public void onFocusChange(View v, boolean hasFocus) {
        if (v == searchEditText) {
            if (hasFocus) {
                // Open keyboard
                ((InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE)).showSoftInput(searchEditText, InputMethodManager.SHOW_FORCED);
            } else {
                // Close keyboard
                ((InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow(searchEditText.getWindowToken(), 0);
            }
        }
    }
});

अब, जब भी आप कीबोर्ड खोलना चाहते हैं मैन्युअल रूप से कॉल करें:

setEditTextFocus(true);

और कॉल बंद करने के लिए:

setEditTextFocus(false);

यह काम करना चाहिए:

public class KeyBoard {

    public static void show(Activity activity){
        InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
        imm.toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY); // show
    }

    public static void hide(Activity activity){
        InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
        imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0); // hide
    }

    public static void toggle(Activity activity){
        InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
        if (imm.isActive()){
            hide(activity); 
        } else {
            show(activity); 
        }
    }
}

KeyBoard.toggle(activity);

अपडेट करें: मुझे नहीं पता कि यह समाधान अब और क्यों काम नहीं कर रहा है (मैंने अभी एंड्रॉइड 23 पर परीक्षण किया है)। कृपया इसके बजाय सौरभ पारीक के समाधान का उपयोग करें। यह रहा:

InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
//Hide:
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
//Show
imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);

पुराना उत्तर:

//Show soft-keyboard:
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
//hide keyboard :
 getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);

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

this.getWindow().setSoftInputMode(
            WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);

बस अपनी गतिविधि में इस अनुकूलित कोड का उपयोग करें:

if (this.getCurrentFocus() != null) {
    InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE);
    inputManager.hideSoftInputFromWindow(this.getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}

मैंने लगभग इन सभी उत्तरों की कोशिश की है, मेरे पास कुछ यादृच्छिक मुद्दे थे, खासकर सैमसंग गैलेक्सी एस 5 के साथ।

मैं जो दिखाता हूं वह शो और छिपाने के लिए मजबूर है, और यह पूरी तरह से काम करता है:

/**
 * Force show softKeyboard.
 */
public static void forceShow(@NonNull Context context) {
    InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
}

/**
 * Force hide softKeyboard.
 */
public static void forceHide(@NonNull Activity activity, @NonNull EditText editText) {
    if (activity.getCurrentFocus() == null || !(activity.getCurrentFocus() instanceof EditText)) {
        editText.requestFocus();
    }
    InputMethodManager imm = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(editText.getWindowToken(), 0);
    activity.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
}

यह मेरे लिए सभी विचित्र कीबोर्ड व्यवहार के लिए काम किया

private boolean isKeyboardVisible() {
    Rect r = new Rect();
    //r will be populated with the coordinates of your view that area still visible.
    mRootView.getWindowVisibleDisplayFrame(r);

    int heightDiff = mRootView.getRootView().getHeight() - (r.bottom - r.top);
    return heightDiff > 100; // if more than 100 pixels, its probably a keyboard...
}

protected void showKeyboard() {
    if (isKeyboardVisible())
        return;
    InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    if (getCurrentFocus() == null) {
        inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
    } else {
        View view = getCurrentFocus();
        inputMethodManager.showSoftInput(view, InputMethodManager.SHOW_FORCED);
    }
}

protected void hideKeyboard() {
    if (!isKeyboardVisible())
        return;
    InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    View view = getCurrentFocus();
    if (view == null) {
        if (inputMethodManager.isAcceptingText())
            inputMethodManager.toggleSoftInput(InputMethodManager.HIDE_NOT_ALWAYS, 0);
    } else {
        if (view instanceof EditText)
            ((EditText) view).setText(((EditText) view).getText().toString()); // reset edit text bug on some keyboards bug
        inputMethodManager.hideSoftInputFromInputMethod(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
    }
}

सौरभ पारीक का अब तक का सबसे अच्छा जवाब है।

हालांकि, सही झंडे का भी उपयोग कर सकते हैं।

/* hide keyboard */
((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
    .toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);

/* show keyboard */
((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
    .toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY);

वास्तविक उपयोग का उदाहरण

/* click button */
public void onClick(View view) {      
  /* hide keyboard */
  ((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
      .toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);

  /* start loader to check parameters ... */
}

/* loader finished */
public void onLoadFinished(Loader<Object> loader, Object data) {
    /* parameters not valid ... */

    /* show keyboard */
    ((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
        .toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY);

    /* parameters valid ... */
}

इस SO उत्तर के लिए धन्यवाद , मैंने निम्नलिखित को प्राप्त किया है, जो मेरे मामले में, ViewPager के टुकड़ों के माध्यम से स्क्रॉल करते समय अच्छी तरह से काम करता है ...

private void hideKeyboard() {   
    // Check if no view has focus:
    View view = this.getCurrentFocus();
    if (view != null) {
        InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE);
        inputManager.hideSoftInputFromWindow(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
    }
}

private void showKeyboard() {   
    // Check if no view has focus:
    View view = this.getCurrentFocus();
    if (view != null) {
        InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE);
        inputManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);
    }
}

उत्तर के ऊपर विभिन्न परिदृश्यों के लिए काम करते हैं, लेकिन यदि आप दृश्य के अंदर कीबोर्ड को छिपाना चाहते हैं और सही संदर्भ प्राप्त करने के लिए संघर्ष करना चाहते हैं तो इसे आजमाएं:

setOnClickListener(new OnClickListener() {
    @Override
    public void onClick(View v) {
        hideSoftKeyBoardOnTabClicked(v);
    }
}

private void hideSoftKeyBoardOnTabClicked(View v) {
    if (v != null && context != null) {
        InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(v.getApplicationWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
    }
}

और संदर्भ प्राप्त करने के लिए इसे कन्स्ट्रक्टर से प्राप्त करें :)

public View/RelativeLayout/so and so (Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);
    this.context = context;
    init();
}

मेरे पास मामला है, जहां मेरा EditTextभी एक में स्थित हो सकता है AlertDialog, इसलिए कुंजीपटल को खारिज कर दिया जाना चाहिए। निम्न कोड कहीं भी काम कर रहा है:

public static void hideKeyboard( Activity activity ) {
    InputMethodManager imm = (InputMethodManager)activity.getSystemService( Context.INPUT_METHOD_SERVICE );
    View f = activity.getCurrentFocus();
    if( null != f && null != f.getWindowToken() && EditText.class.isAssignableFrom( f.getClass() ) )
        imm.hideSoftInputFromWindow( f.getWindowToken(), 0 );
    else 
        activity.getWindow().setSoftInputMode( WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN );
}

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

InputMethodManager का उपयोग कीबोर्ड को बंद नहीं किया था। मुझे फोकस करना था और खोज दृश्य के फोकस योग्य को गलत पर सेट करना था:

mSearchView.clearFocus();
mSearchView.setFocusable(false);

सरल और उपयोग करने में आसान तरीका, बस hideKeyboardFrom (YourActivity.this) को कॉल करें ; कीबोर्ड छुपाने के लिए

/**
 * This method is used to hide keyboard
 * @param activity
 */
public static void hideKeyboardFrom(Activity activity) {
    InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
}

protected void hideSoftKeyboard(EditText input) {
    input.setInputType(0);
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(input.getWindowToken(), 0);    
}




soft-keyboard