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




android-layout android-softkeyboard android-input-method soft-keyboard (25)

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

इसके साथ एक फ़ंक्शन बनाएं जो कुछ 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);

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

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


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

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

कोड पर नीचे दिए गए कोड को आजमाएं onCreate()

EditText edtView=(EditText)findViewById(R.id.editTextConvertValue);
edtView.setInputType(0);

इस पागलपन को स्पष्ट करने में मदद के लिए, मैं सॉफ्ट एंड्रॉइड के 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();


android:windowSoftInputMode="stateHidden"मैनिफेस्ट फ़ाइल में अपनी गतिविधि में जोड़ें । उदाहरण:

<activity
            android:name=".ui.activity.MainActivity"
            android:label="@string/mainactivity"
            android:windowSoftInputMode="stateHidden"/>

public void setKeyboardVisibility(boolean show) {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    if(show){
        imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
    }else{
        imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(),0);
    }
}

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

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

अपडेट करें: मुझे नहीं पता कि यह समाधान अब और क्यों काम नहीं कर रहा है (मैंने अभी एंड्रॉइड 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);

मैंने थ्रेड में पोस्ट किए गए सभी समाधानों के माध्यम से दो दिन से अधिक समय व्यतीत किया है और उन्हें एक तरफ या किसी अन्य तरीके से कमी महसूस हुई है। मेरी सटीक आवश्यकता एक बटन है जो 100% विश्वसनीयता के साथ स्क्रीन कीबोर्ड पर दिखाएगा या छुपाएगा। जब कीबोर्ड अपने छिपे हुए राज्य में होता है तो उसे फिर से प्रकट नहीं किया जाना चाहिए, इससे कोई फर्क नहीं पड़ता कि उपयोगकर्ता किस इनपुट फ़ील्ड पर क्लिक करता है। जब यह इसकी दृश्य स्थिति में होता है तो कीबोर्ड गायब नहीं होना चाहिए इससे कोई फर्क नहीं पड़ता कि उपयोगकर्ता किस बटन पर क्लिक करता है। इसे नवीनतम उपकरणों तक एंड्रॉइड 2.2+ पर सभी तरह से काम करने की ज़रूरत है।

आप मेरे ऐप क्लीन आरपीएन में इसका एक कार्यान्वयन कार्यान्वयन देख सकते हैं।

कई अलग-अलग फोन (फियोयो और जिंजरब्रेड डिवाइस सहित) पर सुझाए गए कई उत्तरों का परीक्षण करने के बाद यह स्पष्ट हो गया कि एंड्रॉइड ऐप्स विश्वसनीय रूप से विश्वसनीय हो सकते हैं:

  1. अस्थायी रूप से कीबोर्ड छुपाएं। जब कोई उपयोगकर्ता एक नया टेक्स्ट फ़ील्ड केंद्रित करता है तो यह फिर से दिखाई देगा।
  2. गतिविधि शुरू होने पर कीबोर्ड दिखाएं और गतिविधि पर ध्वज सेट करें जो इंगित करता है कि वे हमेशा कीबोर्ड दिखाना चाहिए। यह ध्वज केवल तभी सेट किया जा सकता है जब कोई गतिविधि प्रारंभ हो।
  3. कुंजीपटल के उपयोग को दिखाने या अनुमति देने के लिए किसी गतिविधि को चिह्नित करें। यह ध्वज केवल तभी सेट किया जा सकता है जब कोई गतिविधि प्रारंभ हो।

मेरे लिए, अस्थायी रूप से कीबोर्ड छुपाएं पर्याप्त नहीं है। कुछ उपकरणों पर जैसे ही एक नया टेक्स्ट फ़ील्ड केंद्रित होता है, यह फिर से दिखाई देगा। चूंकि मेरा ऐप एक पेज पर कई टेक्स्ट फ़ील्ड्स का उपयोग करता है, इसलिए एक नया टेक्स्ट फ़ील्ड फोकस करने से छुपा कीबोर्ड फिर से बैक अप हो जाएगा।

दुर्भाग्यवश सूची में आइटम 2 और 3 केवल एक गतिविधि शुरू होने पर ही विश्वसनीयता कार्य करते हैं। एक बार गतिविधि दिखाई देने के बाद आप कीबोर्ड को स्थायी रूप से छुपा या दिखा नहीं सकते हैं। यह चाल वास्तव में आपकी गतिविधि को पुनरारंभ करना है जब उपयोगकर्ता कुंजीपटल टॉगल बटन दबाता है। मेरे ऐप में जब उपयोगकर्ता टॉगल कीबोर्ड बटन पर दबाता है, तो निम्न कोड चलता है:

private void toggleKeyboard(){

    if(keypadPager.getVisibility() == View.VISIBLE){
        Intent i = new Intent(this, MainActivity.class);
        i.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
        Bundle state = new Bundle();
        onSaveInstanceState(state);
        state.putBoolean(SHOW_KEYBOARD, true);
        i.putExtras(state);

        startActivity(i);
    }
    else{
        Intent i = new Intent(this, MainActivity.class);
        i.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
        Bundle state = new Bundle();
        onSaveInstanceState(state);
        state.putBoolean(SHOW_KEYBOARD, false);
        i.putExtras(state);

        startActivity(i);
    }
}

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

ऑनक्रेट विधि के अंदर निम्न कोड चलाया जाता है:

if(bundle.getBoolean(SHOW_KEYBOARD)){
    ((InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE)).showSoftInput(newEquationText,0);
    getWindow().setSoftInputMode(LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
}
else{
    getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
            WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
}

यदि मुलायम कीबोर्ड दिखाया जाना चाहिए, तो इनपुट मोड विधि प्रबंधक को कीबोर्ड दिखाने के लिए कहा जाता है और विंडो को नरम इनपुट हमेशा दिखाई देने के लिए निर्देश दिया जाता है। यदि सॉफ्ट कीबोर्ड छुपाया जाना चाहिए तो WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM सेट है।

यह दृष्टिकोण उन सभी उपकरणों पर विश्वसनीय रूप से काम करता है जिन पर मैंने परीक्षण किया है - 4 साल पुराने एचटीसी फोन से एंड्रॉइड 2.2 तक एक नेक्सस 7 तक 4.2.2 चल रहा है। इस दृष्टिकोण के साथ एकमात्र नुकसान यह है कि आपको बैक बटन को संभालने से सावधान रहना होगा। चूंकि मेरे ऐप में अनिवार्य रूप से केवल एक स्क्रीन है (इसका कैलकुलेटर) मैं बैकप्रेस () पर ओवरराइड कर सकता हूं और डिवाइस होम स्क्रीन पर वापस जा सकता हूं।


एंड्रॉइड के लिए मोनो में यह कैसे किया गया है (AKA MonoDroid)

InputMethodManager imm = GetSystemService (Context.InputMethodService) as InputMethodManager;
if (imm != null)
    imm.HideSoftInputFromWindow (searchbox.WindowToken , 0);

कुछ मामलों में यह विधियां अन्य सभी को छोड़कर काम कर सकती हैं। यह मेरा दिन बचाता है :)

public static void hideSoftKeyboard(Activity activity) {
    if (activity != null) {
        InputMethodManager inputManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
        if (activity.getCurrentFocus() != null && inputManager != null) {
            inputManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
            inputManager.hideSoftInputFromInputMethod(activity.getCurrentFocus().getWindowToken(), 0);
        }
    }
}

public static void hideSoftKeyboard(View view) {
    if (view != null) {
        InputMethodManager inputManager = (InputMethodManager) view.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
        if (inputManager != null) {
            inputManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
        }
    }
}

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

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

इतनी खोज से, यहां मुझे एक उत्तर मिला जो मेरे लिए काम करता है

// Show soft-keyboard:
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);

// Hide soft-keyboard:
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);

सरल और उपयोग करने में आसान तरीका, बस 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);    
}

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

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

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

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

यदि आप इकाई या कार्यात्मक परीक्षण के दौरान सॉफ्ट कीबोर्ड को बंद करना चाहते हैं, तो आप अपने परीक्षण से "बैक बटन" पर क्लिक करके ऐसा कर सकते हैं:

// Close the soft keyboard from a Test
getInstrumentation().sendKeyDownUpSync(KeyEvent.KEYCODE_BACK);

मैंने उद्धरणों में "बैक बटन" रखा है, क्योंकि उपरोक्त onBackPressed()गतिविधि में गतिविधि के लिए ट्रिगर नहीं करता है । यह सिर्फ कीबोर्ड बंद कर देता है।

आगे बढ़ने से पहले थोड़ी देर के लिए रुकना सुनिश्चित करें, क्योंकि बैक बटन को बंद करने में थोड़ी देर लगती है, इसलिए दृश्यों के बाद के क्लिक आदि को एक लघु विराम के बाद तक पंजीकृत नहीं किया जाएगा (1 सेकंड लंबा पर्याप्त समय है )।


मैंने लगभग इन सभी उत्तरों की कोशिश की है, मेरे पास कुछ यादृच्छिक मुद्दे थे, खासकर सैमसंग गैलेक्सी एस 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);
}

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

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

सॉफ्ट-कीबोर्ड को छिपाने के लिए भी उपयोगी है:

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

इसका उपयोग सॉफ्ट-कीबोर्ड को दबाने के लिए किया जा सकता है जब तक कि उपयोगकर्ता वास्तव में संपादन टेक्स्ट दृश्य को छूता नहीं है।


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

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

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


आप एंड्रॉइड को 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


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

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

Such OutofMemoryException cannot be totally resolved by calling the System.gc() and so on .

By referring to the Activity Life Cycle

The Activity States are determined by the OS itself subject to the memory usage for each process and the priority of each process.

You may consider the size and the resolution for each of the bitmap pictures used. I recommend to reduce the size ,resample to lower resolution , refer to the design of galleries (one small picture PNG , and one original picture.)





android android-layout android-softkeyboard android-input-method soft-keyboard